Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Some optimization and fixes - mostly reworked MC and bitplanes.

Browse Source 
Originally committed as revision 5543 to svn://svn.ffmpeg.org/ffmpeg/trunk
pull/126/head
Kostya Shishkov 19 years ago
parent e8ba1cea3c
commit 87dfe848fa
1 changed files with 216 additions and 242 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 458
      libavcodec/vc1.c

458
libavcodec/vc1.c
Unescape View File

@ -203,30 +203,6 @@ enum CodingSet {
CS_HIGH_RATE_INTER
};
/** Bitplane struct
* We mainly need data and is_raw, so this struct could be avoided
* to save a level of indirection; feel free to modify
* @fixme For now, stride=width
* @warning Data are bits, either 1 or 0
*/
typedef struct BitPlane {
uint8_t *data; ///< Data buffer
int width; ///< Width of the buffer
int stride; ///< Stride of the buffer
int height; ///< Plane height
uint8_t is_raw; ///< Bit values must be read at MB level
} BitPlane;
/** Block data for DC/AC prediction
*/
typedef struct Block {
uint16_t dc;
int16_t hor_ac[7];
int16_t vert_ac[7];
int16_t dcstep, step;
} Block;
/** The VC1 Context
* @fixme Change size wherever another size is more efficient
* Many members are only used for Advanced Profile
@ -334,9 +310,11 @@ typedef struct VC1Context{
uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY
VLC *cbpcy_vlc; ///< CBPCY VLC table
int tt_index; ///< Index for Transform Type tables
BitPlane mv_type_mb_plane; ///< bitplane for mv_type == (4MV)
BitPlane skip_mb_plane; ///< bitplane for skipped MBs
BitPlane direct_mb_plane; ///< bitplane for "direct" MBs
uint8_t* mv_type_mb_plane; ///< bitplane for mv_type == (4MV)
uint8_t* skip_mb_plane; ///< bitplane for skipped MBs
// BitPlane direct_mb_plane; ///< bitplane for "direct" MBs
int mv_type_is_raw; ///< mv type mb plane is not coded
int skip_is_raw; ///< skip mb plane is not coded
/** Frame decoding info for S/M profiles only */
//@{
@ -359,8 +337,8 @@ typedef struct VC1Context{
int hrd_num_leaky_buckets;
uint8_t bit_rate_exponent;
uint8_t buffer_size_exponent;
BitPlane ac_pred_plane; ///< AC prediction flags bitplane
BitPlane over_flags_plane; ///< Overflags bitplane
// BitPlane ac_pred_plane; ///< AC prediction flags bitplane
// BitPlane over_flags_plane; ///< Overflags bitplane
uint8_t condover;
uint16_t *hrd_rate, *hrd_buffer;
uint8_t *hrd_fullness;
@ -436,11 +414,6 @@ static int vc1_init_common(VC1Context *v)
static int done = 0;
int i = 0;
/* Set the bit planes */
v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };
v->hrd_rate = v->hrd_buffer = NULL;
/* VLC tables */
@ -521,33 +494,6 @@ enum Imode {
};
/** @} */ //imode defines
/** Allocate the buffer from a bitplane, given its dimensions
* @param bp Bitplane which buffer is to allocate
* @param[in] width Width of the buffer
* @param[in] height Height of the buffer
* @return Status
* @todo TODO: Take into account stride
* @todo TODO: Allow use of external buffers ?
*/
static int alloc_bitplane(BitPlane *bp, int width, int height)
{
if (!bp || bp->width<0 || bp->height<0) return -1;
bp->data = (uint8_t*)av_malloc(width*height);
if (!bp->data) return -1;
bp->width = bp->stride = width;
bp->height = height;
return 0;
}
/** Free the bitplane's buffer
* @param bp Bitplane which buffer is to free
*/
static void free_bitplane(BitPlane *bp)
{
bp->width = bp->stride = bp->height = 0;
if (bp->data) av_freep(&bp->data);
}
/** Decode rows by checking if they are skipped
* @param plane Buffer to store decoded bits
* @param[in] width Width of this buffer
@ -595,53 +541,57 @@ static void decode_colskip(uint8_t* plane, int width, int height, int stride, Ge
* @fixme FIXME: Optimize
* @todo TODO: Decide if a struct is needed
*/
static int bitplane_decoding(BitPlane *bp, VC1Context *v)
static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
{
GetBitContext *gb = &v->s.gb;
int imode, x, y, code, offset;
uint8_t invert, *planep = bp->data;
uint8_t invert, *planep = data;
int width, height, stride;
width = v->s.mb_width;
height = v->s.mb_height;
stride = v->s.mb_stride;
invert = get_bits(gb, 1);
imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
bp->is_raw = 0;
*raw_flag = 0;
switch (imode)
{
case IMODE_RAW:
//Data is actually read in the MB layer (same for all tests == "raw")
bp->is_raw = 1; //invert ignored
*raw_flag = 1; //invert ignored
return invert;
case IMODE_DIFF2:
case IMODE_NORM2:
if ((bp->height * bp->width) & 1)
if ((height * width) & 1)
{
*planep++ = get_bits(gb, 1);
offset = 1;
}
else offset = 0;
// decode bitplane as one long line
for (y = offset; y < bp->height * bp->width; y += 2) {
for (y = offset; y < height * width; y += 2) {
code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
*planep++ = code & 1;
offset++;
if(offset == bp->width) {
if(offset == width) {
offset = 0;
planep += bp->stride - bp->width;
planep += stride - width;
}
*planep++ = code >> 1;
offset++;
if(offset == bp->width) {
if(offset == width) {
offset = 0;
planep += bp->stride - bp->width;
planep += stride - width;
}
}
break;
case IMODE_DIFF6:
case IMODE_NORM6:
if(!(bp->height % 3) && (bp->width % 3)) { // use 2x3 decoding
for(y = 0; y < bp->height; y+= 3) {
for(x = bp->width & 1; x < bp->width; x += 2) {
if(!(height % 3) && (width % 3)) { // use 2x3 decoding
for(y = 0; y < height; y+= 3) {
for(x = width & 1; x < width; x += 2) {
code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
if(code < 0){
av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
@ -649,17 +599,17 @@ static int bitplane_decoding(BitPlane *bp, VC1Context *v)
}
planep[x + 0] = (code >> 0) & 1;
planep[x + 1] = (code >> 1) & 1;
planep[x + 0 + bp->stride] = (code >> 2) & 1;
planep[x + 1 + bp->stride] = (code >> 3) & 1;
planep[x + 0 + bp->stride * 2] = (code >> 4) & 1;
planep[x + 1 + bp->stride * 2] = (code >> 5) & 1;
planep[x + 0 + stride] = (code >> 2) & 1;
planep[x + 1 + stride] = (code >> 3) & 1;
planep[x + 0 + stride * 2] = (code >> 4) & 1;
planep[x + 1 + stride * 2] = (code >> 5) & 1;
}
planep += bp->stride * 3;
planep += stride * 3;
}
if(bp->width & 1) decode_colskip(bp->data, 1, bp->height, bp->stride, &v->s.gb);
if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
} else { // 3x2
for(y = bp->height & 1; y < bp->height; y += 2) {
for(x = bp->width % 3; x < bp->width; x += 3) {
for(y = height & 1; y < height; y += 2) {
for(x = width % 3; x < width; x += 3) {
code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
if(code < 0){
av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
@ -668,22 +618,22 @@ static int bitplane_decoding(BitPlane *bp, VC1Context *v)
planep[x + 0] = (code >> 0) & 1;
planep[x + 1] = (code >> 1) & 1;
planep[x + 2] = (code >> 2) & 1;
planep[x + 0 + bp->stride] = (code >> 3) & 1;
planep[x + 1 + bp->stride] = (code >> 4) & 1;
planep[x + 2 + bp->stride] = (code >> 5) & 1;
planep[x + 0 + stride] = (code >> 3) & 1;
planep[x + 1 + stride] = (code >> 4) & 1;
planep[x + 2 + stride] = (code >> 5) & 1;
}
planep += bp->stride * 2;
planep += stride * 2;
}
x = bp->width % 3;
if(x) decode_colskip(bp->data , x, bp->height , bp->stride, &v->s.gb);
if(bp->height & 1) decode_rowskip(bp->data+x, bp->width - x, bp->height & 1, bp->stride, &v->s.gb);
x = width % 3;
if(x) decode_colskip(data , x, height , stride, &v->s.gb);
if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
}
break;
case IMODE_ROWSKIP:
decode_rowskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
decode_rowskip(data, width, height, stride, &v->s.gb);
break;
case IMODE_COLSKIP:
decode_colskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
decode_colskip(data, width, height, stride, &v->s.gb);
break;
default: break;
}
@ -691,28 +641,29 @@ static int bitplane_decoding(BitPlane *bp, VC1Context *v)
/* Applying diff operator */
if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
{
planep = bp->data;
planep = data;
planep[0] ^= invert;
for (x=1; x<bp->width; x++)
for (x=1; x<width; x++)
planep[x] ^= planep[x-1];
for (y=1; y<bp->height; y++)
for (y=1; y<height; y++)
{
planep += bp->stride;
planep[0] ^= planep[-bp->stride];
for (x=1; x<bp->width; x++)
planep += stride;
planep[0] ^= planep[-stride];
for (x=1; x<width; x++)
{
if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
else planep[x] ^= planep[x-1];
if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
else planep[x] ^= planep[x-1];
}
}
}
else if (invert)
{
planep = bp->data;
for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
planep = data;
for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
}
return (imode<<1) + invert;
}
/** @} */ //Bitplane group
/***********************************************************************/
@ -886,6 +837,42 @@ static void vc1_overlap_block(MpegEncContext *s, DCTELEM block[64], int n, int d
}
static void vc1_v_overlap(uint8_t* src, int stride)
{
int i;
int a, b, c, d;
for(i = 0; i < 8; i++) {
a = src[-2*stride];
b = src[-stride];
c = src[0];
d = src[stride];
src[-2*stride] = (7*a + d) >> 3;
src[-stride] = (-a + 7*b + c + d) >> 3;
src[0] = (a + b + 7*c - d) >> 3;
src[stride] = (a + 7*d) >> 3;
src++;
}
}
static void vc1_h_overlap(uint8_t* src, int stride)
{
int i;
int a, b, c, d;
for(i = 0; i < 8; i++) {
a = src[-2];
b = src[-1];
c = src[0];
d = src[1];
src[-2] = (7*a + d) >> 3;
src[-1] = (-a + 7*b + c + d) >> 3;
src[0] = (a + b + 7*c - d) >> 3;
src[1] = (a + 7*d) >> 3;
src += stride;
}
}
/** Put block onto picture
* @todo move to DSPContext
*/
@ -910,6 +897,11 @@ static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
}
/* clip motion vector as specified in 8.3.6.5 */
#define CLIP_RANGE(mv, src, lim, bs) \
if(mv < -bs) mv = -bs - src * bs; \
if(mv > lim) mv = lim - src * bs;
/** Do motion compensation over 1 macroblock
* Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
*/
@ -918,89 +910,69 @@ static void vc1_mc_1mv(VC1Context *v)
MpegEncContext *s = &v->s;
DSPContext *dsp = &v->s.dsp;
uint8_t *srcY, *srcU, *srcV;
int dxy, mx, my, src_x, src_y;
int width = s->mb_width * 16, height = s->mb_height * 16;
int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
if(!v->s.last_picture.data[0])return;
mx = s->mv[0][0][0] >> s->mspel;
my = s->mv[0][0][1] >> s->mspel;
mx = s->mv[0][0][0];
my = s->mv[0][0][1];
uvmx = (mx + ((mx & 3) == 3)) >> 1;
uvmy = (my + ((my & 3) == 3)) >> 1;
srcY = s->last_picture.data[0];
srcU = s->last_picture.data[1];
srcV = s->last_picture.data[2];
if(s->mspel) { // hpel mc
if(v->fastuvmc) { // XXX: 8.3.5.4.5 specifies something different
uvmx = (uvmx + 1) >> 1;
uvmy = (uvmy + 1) >> 1;
}
src_x = s->mb_x * 16 + (mx >> 2);
src_y = s->mb_y * 16 + (my >> 2);
uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
CLIP_RANGE( src_x, s->mb_x, s->mb_width * 16, 16);
CLIP_RANGE( src_y, s->mb_y, s->mb_height * 16, 16);
CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width * 8, 8);
CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height * 8, 8);
srcY += src_y * s->linesize + src_x;
srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
|| (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
src_x, src_y, s->h_edge_pos, s->v_edge_pos);
srcY = s->edge_emu_buffer;
ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
srcU = uvbuf;
srcV = uvbuf + 16;
}
if(!s->quarter_sample) { // hpel mc
mx >>= 1;
my >>= 1;
uvmx >>= 1;
uvmy >>= 1;
dxy = ((my & 1) << 1) | (mx & 1);
src_x = s->mb_x * 16 + (mx >> 1);
src_y = s->mb_y * 16 + (my >> 1);
/* src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
if (src_x == width)
dxy &= ~1;
src_y = clip(src_y, -16, height);
if (src_y == height)
dxy &= ~2;*/
srcY += src_y * s->linesize + src_x;
srcU += (src_y >> 1) * s->uvlinesize + (src_x >> 1);
srcV += (src_y >> 1) * s->uvlinesize + (src_x >> 1);
if((unsigned)src_x > s->h_edge_pos - (mx&1) - 16
|| (unsigned)src_y > s->v_edge_pos - (my&1) - 16){
uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
src_x, src_y, s->h_edge_pos, s->v_edge_pos);
srcY = s->edge_emu_buffer;
ff_emulated_edge_mc(uvbuf, srcU, s->uvlinesize, 8+1, 8+1,
src_x >> 1, src_y >> 1, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
src_x >> 1, src_y >> 1, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
srcU = uvbuf;
srcV = uvbuf + 16;
}
uvdxy = 0;
dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
dsp->put_no_rnd_pixels_tab[1][0](s->dest[1], srcU, s->uvlinesize, 8);
dsp->put_no_rnd_pixels_tab[1][0](s->dest[2], srcV, s->uvlinesize, 8);
} else {
int motion_x = mx, motion_y = my, uvdxy, uvsrc_x, uvsrc_y;
dxy = ((motion_y & 3) << 2) | (motion_x & 3);
src_x = s->mb_x * 16 + (mx >> 2);
src_y = s->mb_y * 16 + (my >> 2);
mx= motion_x/2;
my= motion_y/2;
mx= (mx>>1)|(mx&1);
my= (my>>1)|(my&1);
uvdxy= (mx&1) | ((my&1)<<1);
mx>>=1;
my>>=1;
uvsrc_x = s->mb_x * 8 + mx;
uvsrc_y = s->mb_y * 8 + my;
srcY = s->last_picture.data[0] + src_y * s->linesize + src_x;
srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
|| (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 16 ){
uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17, 17,
src_x, src_y, s->h_edge_pos, s->v_edge_pos);
srcY = s->edge_emu_buffer;
ff_emulated_edge_mc(uvbuf, srcU, s->uvlinesize, 9, 9,
uvsrc_x, uvsrc_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 9, 9,
uvsrc_x, uvsrc_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
srcU = uvbuf;
srcV = uvbuf + 16;
}
dxy = ((my & 3) << 2) | (mx & 3);
uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
}
dsp->put_mspel_pixels_tab[uvdxy](s->dest[1], srcU, s->uvlinesize);
dsp->put_mspel_pixels_tab[uvdxy](s->dest[2], srcV, s->uvlinesize);
}
/**
@ -1215,9 +1187,9 @@ static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
v->lumshift = get_bits(gb, 6);
}
if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
v->s.mspel = 1;
v->s.quarter_sample = 0;
else
v->s.mspel = 0;
v->s.quarter_sample = 1;
if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode != MV_PMODE_1MV_HPEL_BILIN) {
av_log(v->s.avctx, AV_LOG_ERROR, "Only 1MV P-frames are supported by now\n");
@ -1227,12 +1199,15 @@ if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode !
v->mv_mode2 == MV_PMODE_MIXED_MV)
|| v->mv_mode == MV_PMODE_MIXED_MV)
{
status = bitplane_decoding(&v->mv_type_mb_plane, v);
status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
if (status < 0) return -1;
av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
"Imode: %i, Invert: %i\n", status>>1, status&1);
} else {
v->mv_type_is_raw = 0;
memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
}
status = bitplane_decoding(&v->skip_mb_plane, v);
status = bitplane_decoding(v->skip_mb_plane, &v->skip_is_raw, v);
if (status < 0) return -1;
av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
"Imode: %i, Invert: %i\n", status>>1, status&1);
@ -1327,8 +1302,8 @@ if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode !
if (!index) { _dmv_x = _dmv_y = 0; } \
else if (index == 35) \
{ \
_dmv_x = get_bits(gb, v->k_x - s->mspel); \
_dmv_y = get_bits(gb, v->k_y - s->mspel); \
_dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
_dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
} \
else if (index == 36) \
{ \
@ -1339,8 +1314,8 @@ if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode !
else \
{ \
index1 = index%6; \
if (s->mspel && index1 == 5) val = 1; \
else val = 0; \
if (!s->quarter_sample && index1 == 5) val = 1; \
else val = 0; \
if(size_table[index1] - val > 0) \
val = get_bits(gb, size_table[index1] - val); \
else val = 0; \
@ -1348,8 +1323,8 @@ if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode !
_dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
\
index1 = index/6; \
if (s->mspel && index1 == 5) val = 1; \
else val = 0; \
if (!s->quarter_sample && index1 == 5) val = 1; \
else val = 0; \
if(size_table[index1] - val > 0) \
val = get_bits(gb, size_table[index1] - val); \
else val = 0; \
@ -1368,8 +1343,8 @@ static inline void vc1_pred_mv(MpegEncContext *s, int dmv_x, int dmv_y, int mv1,
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
/* scale MV difference to be quad-pel */
dmv_x <<= s->mspel;
dmv_y <<= s->mspel;
dmv_x <<= 1 - s->quarter_sample;
dmv_y <<= 1 - s->quarter_sample;
wrap = s->b8_stride;
xy = s->block_index[0];
@ -1627,26 +1602,22 @@ static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value,
level = -level;
} else {
escape = decode210(gb);
if (escape == 0) {
index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
run = vc1_index_decode_table[codingset][index][0];
level = vc1_index_decode_table[codingset][index][1];
lst = index >= vc1_last_decode_table[codingset];
if(lst)
level += vc1_last_delta_level_table[codingset][run];
else
level += vc1_delta_level_table[codingset][run];
if(get_bits(gb, 1))
level = -level;
} else if (escape == 1) {
if (escape != 2) {
index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
run = vc1_index_decode_table[codingset][index][0];
level = vc1_index_decode_table[codingset][index][1];
lst = index >= vc1_last_decode_table[codingset];
if(lst)
run += vc1_last_delta_run_table[codingset][level] + 1;
else
run += vc1_delta_run_table[codingset][level] + 1;
if(escape == 0) {
if(lst)
level += vc1_last_delta_level_table[codingset][run];
else
level += vc1_delta_level_table[codingset][run];
} else {
if(lst)
run += vc1_last_delta_run_table[codingset][level] + 1;
else
run += vc1_delta_run_table[codingset][level] + 1;
}
if(get_bits(gb, 1))
level = -level;
} else {
@ -1944,7 +1915,7 @@ static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int c
}
/* apply AC prediction if needed */
if(s->ac_pred) {
if(s->ac_pred && (v->a_avail || v->c_avail)) {
/* scale predictors if needed*/
int mb_pos2, q1, q2;
@ -1960,7 +1931,7 @@ static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int c
memset(ac_val + 8, 0, 8 * sizeof(ac_val[0]));
dc_pred_dir = 1;
}
if(!q1 && q1 && q2 && q1 != q2) {
if(q2 && q1 != q2) {
q1 = q1 * 2 - 1;
q2 = q2 * 2 - 1;
@ -2017,16 +1988,16 @@ not_coded:
memset(ac_val2, 0, 16 * 2);
if(dc_pred_dir) {//left
ac_val -= 16;
if(s->ac_pred)
if(s->ac_pred && (v->a_avail || v->c_avail))
memcpy(ac_val2, ac_val, 8 * 2);
} else {//top
ac_val -= 16 * s->block_wrap[n];
if(s->ac_pred)
if(s->ac_pred && (v->a_avail || v->c_avail))
memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
}
/* apply AC prediction if needed */
if(s->ac_pred) {
if(s->ac_pred && (v->a_avail || v->c_avail)) {
if(dc_pred_dir) { //left
for(k = 1; k < 8; k++) {
block[k << 3] = ac_val[k] * scale;
@ -2082,7 +2053,6 @@ static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquan
ttblk = TT_4X8;
subblkpat = 2 - (ttblk == TT_4X8_LEFT);
}
switch(ttblk) {
case TT_8X8:
i = 0;
@ -2101,7 +2071,7 @@ static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquan
for(j = 0; j < 4; j++) {
last = subblkpat & (1 << (3 - j));
i = 0;
off = (j & 1) * 4 + (j & 2) * 32;
off = (j & 1) * 4 + (j & 2) * 16;
while (!last) {
vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
i += skip;
@ -2110,7 +2080,8 @@ static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquan
idx = vc1_simple_progressive_4x4_zz[i++];
block[idx + off] = value * scale;
}
vc1_inv_trans(block + off, 4, 4);
if(!(subblkpat & (1 << (3 - j))))
vc1_inv_trans(block + off, 4, 4);
}
break;
case TT_8X4:
@ -2126,7 +2097,8 @@ static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquan
idx = vc1_simple_progressive_8x4_zz[i++];
block[idx + off] = value * scale;
}
if(!(subblkpat & (1 << (1 - j)))) vc1_inv_trans(block + off, 8, 4);
if(!(subblkpat & (1 << (1 - j))))
vc1_inv_trans(block + off, 8, 4);
}
break;
case TT_4X8:
@ -2142,7 +2114,8 @@ static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquan
idx = vc1_simple_progressive_8x4_zz[i++];
block[idx + off] = value * scale;
}
vc1_inv_trans(block + off, 4, 8);
if(!(subblkpat & (1 << (1 - j))))
vc1_inv_trans(block + off, 4, 8);
}
break;
}
@ -2158,7 +2131,7 @@ static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
int i, j, mb_offset = s->mb_x + s->mb_y*s->mb_width; /* XXX: mb_stride */
int i, j;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp; /* cbp decoding stuff */
int hybrid_pred; /* Prediction types */
@ -2174,17 +2147,22 @@ static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
int val, sign; /* temp values */
int first_block = 1;
int dst_idx, off;
int skipped, fourmv;
mquant = v->pq; /* Loosy initialization */
if (v->mv_type_mb_plane.is_raw)
v->mv_type_mb_plane.data[mb_offset] = get_bits(gb, 1);
if (v->skip_mb_plane.is_raw)
v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
s->current_picture.mbskip_table[mb_pos] = v->skip_mb_plane.data[mb_offset];
if (!v->mv_type_mb_plane.data[mb_offset]) /* 1MV mode */
if (v->mv_type_is_raw)
fourmv = get_bits1(gb);
else
fourmv = v->mv_type_mb_plane[mb_pos];
if (v->skip_is_raw)
skipped = get_bits1(gb);
else
skipped = v->skip_mb_plane[mb_pos];
if (!fourmv) /* 1MV mode */
{
if (!v->skip_mb_plane.data[mb_offset])
if (!skipped)
{
GET_MVDATA(dmv_x, dmv_y);
@ -2232,19 +2210,21 @@ static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
v->c_avail = 1;
vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
vc1_inv_trans(s->block[i], 8, 8);
for(j = 0; j < 64; j++) s->block[i][j] += 128;
s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
vc1_inv_trans(block[i], 8, 8);
for(j = 0; j < 64; j++) block[i][j] += 128;
s->dsp.put_pixels_clamped(block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
/* TODO: proper loop filtering */
if(v->a_avail)
s->dsp.h263_v_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
if(v->c_avail)
s->dsp.h263_h_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
if(v->pq >= 9 && v->overlap) {
if(v->a_avail)
s->dsp.h263_v_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
if(v->c_avail)
s->dsp.h263_h_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
}
} else if(val) {
vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block);
if(!v->ttmbf && ttmb < 8) ttmb = -1;
first_block = 0;
s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
s->dsp.add_pixels_clamped(block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
}
}
}
@ -2259,7 +2239,7 @@ static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
} //1MV mode
else //4MV mode
{//FIXME: looks not conforming to standard and is not even theoretically complete
if (!v->skip_mb_plane.data[mb_offset] /* unskipped MB */)
if (!skipped /* unskipped MB */)
{
int blk_intra[4], blk_coded[4];
/* Get CBPCY */
@ -2495,6 +2475,8 @@ static int vc1_decode_init(AVCodecContext *avctx)
if (!avctx->extradata_size || !avctx->extradata) return -1;
avctx->pix_fmt = PIX_FMT_YUV420P;
v->s.avctx = avctx;
avctx->flags |= CODEC_FLAG_EMU_EDGE;
v->s.flags |= CODEC_FLAG_EMU_EDGE;
if(ff_h263_decode_init(avctx) < 0)
return -1;
@ -2503,7 +2485,6 @@ static int vc1_decode_init(AVCodecContext *avctx)
av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
av_log(avctx, AV_LOG_INFO, "If you see a picture, don't believe your eyes.\n");
avctx->flags |= CODEC_FLAG_EMU_EDGE;
avctx->coded_width = avctx->width;
avctx->coded_height = avctx->height;
if (avctx->codec_id == CODEC_ID_WMV3)
@ -2537,14 +2518,8 @@ static int vc1_decode_init(AVCodecContext *avctx)
s->mb_height = (avctx->coded_height+15)>>4;
/* Allocate mb bitplanes */
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
v->skip_mb_plane = av_malloc(s->mb_stride * s->mb_height);
/* For predictors */
v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
@ -2553,10 +2528,10 @@ static int vc1_decode_init(AVCodecContext *avctx)
/* Init coded blocks info */
if (v->profile == PROFILE_ADVANCED)
{
if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
return -1;
// if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
// return -1;
// if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
// return -1;
}
return 0;
@ -2670,9 +2645,8 @@ static int vc1_decode_end(AVCodecContext *avctx)
av_freep(&v->hrd_rate);
av_freep(&v->hrd_buffer);
MPV_common_end(&v->s);
free_bitplane(&v->mv_type_mb_plane);
free_bitplane(&v->skip_mb_plane);
free_bitplane(&v->direct_mb_plane);
av_freep(&v->mv_type_mb_plane);
av_freep(&v->skip_mb_plane);
return 0;
}

Write Preview
Loading…
Cancel
Save