{ TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
};
+static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
+
/** MV P mode - the 5th element is only used for mode 1 */
static const uint8_t mv_pmode_table[2][5] = {
{ MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
{ MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
};
+static const uint8_t mv_pmode_table2[2][4] = {
+ { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
+ { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
+};
/** One more frame type */
#define BI_TYPE 7
//@}
int ttfrm; ///< Transform type info present at frame level
uint8_t ttmbf; ///< Transform type flag
- int ttmb; ///< Transform type
uint8_t ttblk4x4; ///< Value of ttblk which indicates a 4x4 transform
int codingset; ///< index of current table set from 11.8 to use for luma block decoding
int codingset2; ///< index of current table set from 11.8 to use for chroma block decoding
VLC *cbpcy_vlc; ///< CBPCY VLC table
int tt_index; ///< Index for Transform Type tables
uint8_t* mv_type_mb_plane; ///< bitplane for mv_type == (4MV)
-// BitPlane direct_mb_plane; ///< bitplane for "direct" MBs
+ uint8_t* direct_mb_plane; ///< bitplane for "direct" MBs
int mv_type_is_raw; ///< mv type mb plane is not coded
+ int dmb_is_raw; ///< direct mb plane is raw
int skip_is_raw; ///< skip mb plane is not coded
+ uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
+ int rnd; ///< rounding control
/** Frame decoding info for S/M profiles only */
//@{
}
if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
} else { // 3x2
+ planep += (height & 1) * stride;
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);
v->dqbilevel = get_bits(gb, 1);
default: break; //Forbidden ?
}
- if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
+ if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
{
pqdiff = get_bits(gb, 3);
if (pqdiff == 7) v->altpq = get_bits(gb, 5);
}
}
-/** Apply overlap transform
+/** Apply overlap transform to vertical edge
* @todo optimize
* @todo move to DSPContext
*/
-static void vc1_overlap_block(MpegEncContext *s, DCTELEM block[64], int n, int do_hor, int do_vert)
-{
- int i;
-
- if(do_hor) { //TODO
- }
- if(do_vert) { //TODO
- }
-
- for(i = 0; i < 64; i++)
- block[i] += 128;
-}
-
-
-static void vc1_v_overlap(uint8_t* src, int stride)
+static void vc1_v_overlap(uint8_t* src, int stride, int rnd)
{
int i;
int a, b, c, d;
c = src[0];
d = src[stride];
- src[-2*stride] = clip_uint8((7*a + d + 3) >> 3);
- src[-stride] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
- src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
- src[stride] = clip_uint8((a + 7*d + 3) >> 3);
+ src[-2*stride] = clip_uint8((7*a + d + 4 - rnd) >> 3);
+ src[-stride] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3);
+ src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3);
+ src[stride] = clip_uint8((a + 7*d + 3 + rnd) >> 3);
src++;
}
}
-static void vc1_h_overlap(uint8_t* src, int stride)
+/** Apply overlap transform to horizontal edge
+ * @todo optimize
+ * @todo move to DSPContext
+ */
+static void vc1_h_overlap(uint8_t* src, int stride, int rnd)
{
int i;
int a, b, c, d;
c = src[0];
d = src[1];
- src[-2] = clip_uint8((7*a + d + 3) >> 3);
- src[-1] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
- src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
- src[1] = clip_uint8((a + 7*d + 3) >> 3);
+ src[-2] = clip_uint8((7*a + d + 4 - rnd) >> 3);
+ src[-1] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3);
+ src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3);
+ src[1] = clip_uint8((a + 7*d + 3 + rnd) >> 3);
src += stride;
}
}
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
*/
-static void vc1_mc_1mv(VC1Context *v)
+static void vc1_mc_1mv(VC1Context *v, int dir)
{
MpegEncContext *s = &v->s;
DSPContext *dsp = &v->s.dsp;
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(v->fastuvmc) { // XXX: 8.3.5.4.5 specifies something different
- uvmx = (uvmx + 1) & ~1;
- uvmy = (uvmy + 1) & ~1;
+ if(!dir) {
+ srcY = s->last_picture.data[0];
+ srcU = s->last_picture.data[1];
+ srcV = s->last_picture.data[2];
+ } else {
+ srcY = s->next_picture.data[0];
+ srcU = s->next_picture.data[1];
+ srcV = s->next_picture.data[2];
}
src_x = s->mb_x * 16 + (mx >> 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);
+ src_x = clip( src_x, -16, s->mb_width * 16);
+ src_y = clip( src_y, -16, s->mb_height * 16);
+ uvsrc_x = clip(uvsrc_x, -8, s->mb_width * 8);
+ uvsrc_y = clip(uvsrc_y, -8, s->mb_height * 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
+ if((v->mv_mode == MV_PMODE_INTENSITY_COMP)
+ || (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;
uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
srcU = uvbuf;
srcV = uvbuf + 16;
+ /* if we deal with intensity compensation we need to scale source blocks */
+ if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
+ int i, j;
+ uint8_t *src, *src2;
+
+ src = srcY;
+ for(j = 0; j < 17; j++) {
+ for(i = 0; i < 17; i++) src[i] = v->luty[src[i]];
+ src += s->linesize;
+ }
+ src = srcU; src2 = srcV;
+ for(j = 0; j < 9; j++) {
+ for(i = 0; i < 9; i++) {
+ src[i] = v->lutuv[src[i]];
+ src2[i] = v->lutuv[src2[i]];
+ }
+ src += s->uvlinesize;
+ src2 += s->uvlinesize;
+ }
+ }
+ }
+
+ if(v->fastuvmc) {
+ uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
+ uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
}
if(!s->quarter_sample) { // hpel mc
mx >>= 1;
my >>= 1;
dxy = ((my & 1) << 1) | (mx & 1);
- uvdxy = 0;
- dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
+ if(!v->rnd)
+ dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
+ else
+ dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
} else {
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);
+ if(!v->rnd)
+ dsp->put_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
+ else
+ dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
+ }
+ /* Chroma MC always uses qpel blilinear */
+ uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
+ if(!v->rnd){
+ dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
+ dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
+ }else{
+ dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
+ dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
}
- 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);
}
/** Do motion compensation for 4-MV macroblock - luminance block
src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 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);
+ src_x = clip( src_x, -16, s->mb_width * 16);
+ src_y = clip( src_y, -16, s->mb_height * 16);
srcY += src_y * s->linesize + src_x;
my >>= 1;
dxy = ((my & 1) << 1) | (mx & 1);
- dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
+ if(!v->rnd)
+ dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
+ else
+ dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
} else {
dxy = ((my & 3) << 2) | (mx & 3);
- dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
+ if(!v->rnd)
+ dsp->put_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
+ else
+ dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
}
}
-#define SETMAXMIN(var) \
- if(var > ma) ma = var; \
- if(var < mi) mi = var;
-
static inline int median4(int a, int b, int c, int d)
{
- int ma, mi;
-
- ma = mi = a;
- SETMAXMIN(b);
- SETMAXMIN(c);
- SETMAXMIN(d);
-
- return (a + b + c + d - ma - mi) >> 1;
+ if(a < b) {
+ if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
+ else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
+ } else {
+ if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
+ else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
+ }
}
}
/* calculate chroma MV vector from four luma MVs */
- idx = (intra[0] << 3) | (intra[1] << 2) | (intra[2] << 1) | intra[3];
+ idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
if(!idx) { // all blocks are inter
tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
switch(idx) {
case 0x1:
tx = mid_pred(mvx[1], mvx[2], mvx[3]);
- tx = mid_pred(mvy[1], mvy[2], mvy[3]);
+ ty = mid_pred(mvy[1], mvy[2], mvy[3]);
break;
case 0x2:
tx = mid_pred(mvx[0], mvx[2], mvx[3]);
- tx = mid_pred(mvy[0], mvy[2], mvy[3]);
+ ty = mid_pred(mvy[0], mvy[2], mvy[3]);
break;
case 0x4:
tx = mid_pred(mvx[0], mvx[1], mvx[3]);
- tx = mid_pred(mvy[0], mvy[1], mvy[3]);
+ ty = mid_pred(mvy[0], mvy[1], mvy[3]);
break;
case 0x8:
tx = mid_pred(mvx[0], mvx[1], mvx[2]);
- tx = mid_pred(mvy[0], mvy[1], mvy[2]);
+ ty = mid_pred(mvy[0], mvy[1], mvy[2]);
break;
}
} else if(count[idx] == 2) {
int t1 = 0, t2 = 0;
for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
- tx = (mvx[t1] + mvx[t2]) >> 1;
- ty = (mvy[t1] + mvy[t2]) >> 1;
+ tx = (mvx[t1] + mvx[t2]) / 2;
+ ty = (mvy[t1] + mvy[t2]) / 2;
} else
return; //no need to do MC for inter blocks
uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
- CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width * 8, 8);
- CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height * 8, 8);
+ uvsrc_x = clip(uvsrc_x, -8, s->mb_width * 8);
+ uvsrc_y = clip(uvsrc_y, -8, s->mb_height * 8);
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)uvsrc_x > (s->h_edge_pos >> 1) - ((uvmx >> 1)&1) - 8
- || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - ((uvmy >> 1)&1) - 8){
+ if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
+ || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
ff_emulated_edge_mc(s->edge_emu_buffer , 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(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
srcV = s->edge_emu_buffer + 16;
}
- if(!s->quarter_sample) // hpel mc
- uvdxy = 0;
- else
- uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
- 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);
+ if(v->fastuvmc) {
+ uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
+ uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
+ }
+
+ /* Chroma MC always uses qpel blilinear */
+ uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
+ if(!v->rnd){
+ dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
+ dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
+ }else{
+ dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
+ dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
+ }
}
/**
}
av_log(avctx, AV_LOG_DEBUG,
"Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
- "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
+ "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
"Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
"DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
if(v->s.pict_type == I_TYPE)
get_bits(gb, 7); // skip buffer fullness
+ if(v->s.pict_type == B_TYPE) {
+ v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
+ v->bfraction = vc1_bfraction_lut[v->bfraction];
+ if(v->bfraction == -1) {
+ v->s.pict_type = BI_TYPE;
+ }
+ }
+
+ /* calculate RND */
+ if(v->s.pict_type == I_TYPE)
+ v->rnd = 1;
+ if(v->s.pict_type == P_TYPE)
+ v->rnd ^= 1;
/* Quantizer stuff */
pqindex = get_bits(gb, 5);
if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
v->pq = pquant_table[0][pqindex];
else
- v->pq = pquant_table[v->quantizer_mode-1][pqindex];
+ v->pq = pquant_table[1][pqindex];
+ v->pquantizer = 1;
if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
v->pquantizer = pqindex < 9;
- if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
- v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
+ if (v->quantizer_mode == QUANT_NON_UNIFORM)
+ v->pquantizer = 0;
v->pqindex = pqindex;
if (pqindex < 9) v->halfpq = get_bits(gb, 1);
else v->halfpq = 0;
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
v->pquantizer = get_bits(gb, 1);
v->dquantfrm = 0;
+ if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
+ v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
+ v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
+ v->range_x = 1 << (v->k_x - 1);
+ v->range_y = 1 << (v->k_y - 1);
+ if (v->profile == PROFILE_ADVANCED)
+ {
+ if (v->postprocflag) v->postproc = get_bits(gb, 1);
+ }
+ else
+ if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
//av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
// (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
else if(v->pq < 13) v->tt_index = 1;
else v->tt_index = 2;
- if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
- v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
- v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
- v->range_x = 1 << (v->k_x - 1);
- v->range_y = 1 << (v->k_y - 1);
- if (v->profile == PROFILE_ADVANCED)
- {
- if (v->postprocflag) v->postproc = get_bits(gb, 1);
- }
- else
- if (v->multires) v->respic = get_bits(gb, 2);
lowquant = (v->pq > 12) ? 0 : 1;
v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
{
- v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
+ int scale, shift, i;
+ v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
v->lumscale = get_bits(gb, 6);
v->lumshift = get_bits(gb, 6);
+ /* fill lookup tables for intensity compensation */
+ if(!v->lumscale) {
+ scale = -64;
+ shift = (255 - v->lumshift * 2) << 6;
+ if(v->lumshift > 31)
+ shift += 128 << 6;
+ } else {
+ scale = v->lumscale + 32;
+ if(v->lumshift > 31)
+ shift = (v->lumshift - 64) << 6;
+ else
+ shift = v->lumshift << 6;
+ }
+ for(i = 0; i < 256; i++) {
+ v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
+ v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
+ }
}
if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
v->s.quarter_sample = 0;
- else
+ else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
+ if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
+ v->s.quarter_sample = 0;
+ else
+ v->s.quarter_sample = 1;
+ } else
v->s.quarter_sample = 1;
if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
v->ttmbf = get_bits(gb, 1);
if (v->ttmbf)
{
- v->ttfrm = get_bits(gb, 2);
+ v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
}
+ } else {
+ v->ttmbf = 1;
+ v->ttfrm = TT_8X8;
}
break;
case B_TYPE:
+ if (v->pq < 5) v->tt_index = 0;
+ else if(v->pq < 13) v->tt_index = 1;
+ else v->tt_index = 2;
+
+ lowquant = (v->pq > 12) ? 0 : 1;
+ v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
+ v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
+
+ status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
+ if (status < 0) return -1;
+ av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
+ "Imode: %i, Invert: %i\n", status>>1, status&1);
+ status = bitplane_decoding(v->s.mbskip_table, &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);
+
+ v->s.mv_table_index = get_bits(gb, 2);
+ v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
+
+ if (v->dquant)
+ {
+ av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
+ vop_dquant_decoding(v);
+ }
+
+ v->ttfrm = 0;
+ if (v->vstransform)
+ {
+ v->ttmbf = get_bits(gb, 1);
+ if (v->ttmbf)
+ {
+ v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
+ }
+ } else {
+ v->ttmbf = 1;
+ v->ttfrm = TT_8X8;
+ }
break;
}
#define GET_MQUANT() \
if (v->dquantfrm) \
{ \
+ int edges = 0; \
if (v->dqprofile == DQPROFILE_ALL_MBS) \
{ \
if (v->dqbilevel) \
{ \
- mquant = (get_bits(gb, 1)) ? v->pq : v->altpq; \
+ mquant = (get_bits(gb, 1)) ? v->altpq : v->pq; \
} \
else \
{ \
else mquant = get_bits(gb, 5); \
} \
} \
- else if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
- { \
- switch(v->dqsbedge){ \
- case 0: /* left */ \
- mquant = (s->mb_x) ? v->pq : v->altpq; \
- break; \
- case 1: /* top */ \
- mquant = (s->mb_y) ? v->pq : v->altpq; \
- break; \
- case 2: /* right */ \
- mquant = (s->mb_x != (s->mb_width - 1)) ? v->pq : v->altpq; \
- break; \
- case 3: /* bottom */ \
- mquant = (s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
- break; \
- default: \
- mquant = v->pq; \
- } \
- } \
+ if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
+ edges = 1 << v->dqsbedge; \
else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
- { \
- switch(v->dqsbedge){ \
- case 0: /* left and top */ \
- mquant = (s->mb_x && s->mb_y) ? v->pq : v->altpq; \
- break; \
- case 1: /* top and right */ \
- mquant = (s->mb_y && s->mb_x != (s->mb_width - 1)) ? v->pq : v->altpq; \
- break; \
- case 2: /* right and bottom */ \
- mquant = (s->mb_x != (s->mb_width - 1) && s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
- break; \
- case 3: /* bottom and left */ \
- mquant = (s->mb_x && s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
- break; \
- default: \
- mquant = v->pq; \
- } \
- } \
+ edges = (3 << v->dqsbedge) % 15; \
else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
- { \
- mquant = (s->mb_x && s->mb_y && s->mb_x != (s->mb_width - 1) && s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
- } \
- else mquant = v->pq; \
+ edges = 15; \
+ if((edges&1) && !s->mb_x) \
+ mquant = v->altpq; \
+ if((edges&2) && s->first_slice_line) \
+ mquant = v->altpq; \
+ if((edges&4) && s->mb_x == (s->mb_width - 1)) \
+ mquant = v->altpq; \
+ if((edges&8) && s->mb_y == (s->mb_height - 1)) \
+ mquant = v->altpq; \
}
/**
}
}
+/** Reconstruct motion vector for B-frame and do motion compensation
+ */
+static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
+{
+ MpegEncContext *s = &v->s;
+ int mx[4], my[4], mv_x, mv_y;
+ int i;
+
+ /* scale MV difference to be quad-pel */
+ dmv_x[0] <<= 1 - s->quarter_sample;
+ dmv_y[0] <<= 1 - s->quarter_sample;
+ dmv_x[1] <<= 1 - s->quarter_sample;
+ dmv_y[1] <<= 1 - s->quarter_sample;
+
+ if(direct || mode == BMV_TYPE_INTERPOLATED) {
+ /* TODO */
+ return;
+ }
+
+ if(mode == BMV_TYPE_BACKWARD) {
+ for(i = 0; i < 4; i++) {
+ mx[i] = s->last_picture.motion_val[0][s->block_index[i]][0];
+ my[i] = s->last_picture.motion_val[0][s->block_index[i]][1];
+ }
+ } else {
+ for(i = 0; i < 4; i++) {
+ mx[i] = s->next_picture.motion_val[0][s->block_index[i]][0];
+ my[i] = s->next_picture.motion_val[0][s->block_index[i]][1];
+ }
+ }
+
+ /* XXX: not right but how to determine 4-MV intra/inter in another frame? */
+ mv_x = median4(mx[0], mx[1], mx[2], mx[3]);
+ mv_y = median4(my[0], my[1], my[2], my[3]);
+ s->mv[0][0][0] = mv_x;
+ s->mv[0][0][1] = mv_y;
+
+ vc1_mc_1mv(v, (mode == BMV_TYPE_FORWARD));
+}
+
/** Get predicted DC value for I-frames only
* prediction dir: left=0, top=1
* @param s MpegEncContext
if (pq < 9 || !overlap)
{
/* Set outer values */
- if (!s->mb_y && (n!=2 && n!=3)) b=a=dcpred[scale];
+ if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
}
else
{
/* Set outer values */
- if (!s->mb_y && (n!=2 && n!=3)) b=a=0;
+ if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
}
int a, b, c, wrap, pred, scale;
int16_t *dc_val;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
- int mb_pos2, q1, q2;
+ int q1, q2 = 0;
/* find prediction - wmv3_dc_scale always used here in fact */
if (n < 4) scale = s->y_dc_scale;
c = dc_val[ - 1];
b = dc_val[ - 1 - wrap];
a = dc_val[ - wrap];
+ /* scale predictors if needed */
+ q1 = s->current_picture.qscale_table[mb_pos];
+ if(c_avail && (n!= 1 && n!=3)) {
+ q2 = s->current_picture.qscale_table[mb_pos - 1];
+ if(q2 && q2 != q1)
+ c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
+ }
+ if(a_avail && (n!= 2 && n!=3)) {
+ q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
+ if(q2 && q2 != q1)
+ a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
+ }
+ if(a_avail && c_avail && (n!=3)) {
+ int off = mb_pos;
+ if(n != 1) off--;
+ if(n != 2) off -= s->mb_stride;
+ q2 = s->current_picture.qscale_table[off];
+ if(q2 && q2 != q1)
+ b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
+ }
if(a_avail && c_avail) {
if(abs(a - b) <= abs(b - c)) {
*dir_ptr = 1;//left
}
- /* scale coeffs if needed
- mb_pos2 = mb_pos - *dir_ptr - (1 - *dir_ptr) * s->mb_stride;
- q1 = s->y_dc_scale_table[s->current_picture.qscale_table[mb_pos]];
- q2 = s->y_dc_scale_table[s->current_picture.qscale_table[mb_pos2]];
- if(q2 && q1!=q2 && ((*dir_ptr && c_avail) || (!*dir_ptr && a_avail))) {
- pred = (pred * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
- } */
-
/* update predictor */
*dc_val_ptr = &dc_val[0];
return pred;
if(dc_pred_dir) { //left
for(k = 1; k < 8; k++) {
block[k << 3] = ac_val[k] * scale;
- if(!v->pquantizer)
+ if(!v->pquantizer && block[k << 3])
block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
}
} else { //top
for(k = 1; k < 8; k++) {
block[k] = ac_val[k + 8] * scale;
- if(!v->pquantizer)
+ if(!v->pquantizer && block[k])
block[k] += (block[k] < 0) ? -v->pq : v->pq;
}
}
int a_avail = v->a_avail, c_avail = v->c_avail;
int use_pred = s->ac_pred;
int scale;
+ int q1, q2 = 0;
/* XXX: Guard against dumb values of mquant */
mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
ac_val2 = ac_val;
- scale = mquant * 2;
+ scale = mquant * 2 + v->halfpq;
if(dc_pred_dir) //left
ac_val -= 16;
else //top
ac_val -= 16 * s->block_wrap[n];
+ q1 = s->current_picture.qscale_table[mb_pos];
+ if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
+ if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
+ if(n && n<4) q2 = q1;
+
if(coded) {
int last = 0, skip, value;
const int8_t *zz_table;
/* apply AC prediction if needed */
if(use_pred) {
/* scale predictors if needed*/
- int mb_pos2, q1, q2;
-
- mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
- q1 = s->current_picture.qscale_table[mb_pos];
- q2 = s->current_picture.qscale_table[mb_pos2];
-
- if(0 && q2 && q1!=q2 && ((dc_pred_dir && c_avail) || (!dc_pred_dir && a_avail))) {
+ if(q2 && q1!=q2) {
q1 = q1 * 2 - 1;
q2 = q2 * 2 - 1;
if(use_pred) i = 63;
} else { // no AC coeffs
int k;
- int mb_pos2, q1, q2;
-
- mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
- q1 = s->current_picture.qscale_table[mb_pos];
- q2 = s->current_picture.qscale_table[mb_pos2];
memset(ac_val2, 0, 16 * 2);
if(dc_pred_dir) {//left
if(use_pred) {
memcpy(ac_val2, ac_val, 8 * 2);
- if(0 && q2 && q1!=q2 && c_avail) {
+ if(q2 && q1!=q2) {
q1 = q1 * 2 - 1;
q2 = q2 * 2 - 1;
for(k = 1; k < 8; k++)
} else {//top
if(use_pred) {
memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
- if(0 && q2 && q1!=q2 && a_avail) {
+ if(q2 && q1!=q2) {
q1 = q1 * 2 - 1;
q2 = q2 * 2 - 1;
for(k = 1; k < 8; k++)
if(dc_pred_dir) { //left
for(k = 1; k < 8; k++) {
block[k << 3] = ac_val2[k] * scale;
- if(!v->pquantizer)
+ if(!v->pquantizer && block[k << 3])
block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
}
} else { //top
for(k = 1; k < 8; k++) {
block[k] = ac_val2[k + 8] * scale;
- if(!v->pquantizer)
+ if(!v->pquantizer && block[k])
block[k] += (block[k] < 0) ? -mquant : mquant;
}
}
if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
}
- scale = 2 * mquant;
+ scale = 2 * mquant + v->halfpq;
// convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
break;
idx = vc1_simple_progressive_8x8_zz[i++];
block[idx] = value * scale;
+ if(!v->pquantizer)
+ block[idx] += (block[idx] < 0) ? -mquant : mquant;
}
vc1_inv_trans(block, 8, 8);
break;
break;
idx = vc1_simple_progressive_4x4_zz[i++];
block[idx + off] = value * scale;
+ if(!v->pquantizer)
+ block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
}
if(!(subblkpat & (1 << (3 - j))))
vc1_inv_trans(block + off, 4, 4);
break;
idx = vc1_simple_progressive_8x4_zz[i++];
block[idx + off] = value * scale;
+ if(!v->pquantizer)
+ block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
}
if(!(subblkpat & (1 << (1 - j))))
vc1_inv_trans(block + off, 8, 4);
break;
idx = vc1_simple_progressive_4x8_zz[i++];
block[idx + off] = value * scale;
+ if(!v->pquantizer)
+ block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
}
if(!(subblkpat & (1 << (1 - j))))
vc1_inv_trans(block + off, 4, 8);
* @todo TODO: Extend to AP
* @fixme FIXME: DC value for inter blocks not set
*/
-static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
+static int vc1_decode_p_mb(VC1Context *v)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int cbp; /* cbp decoding stuff */
int mqdiff, mquant; /* MB quantization */
- int ttmb = v->ttmb; /* MB Transform type */
+ int ttmb = v->ttfrm; /* MB Transform type */
int status;
static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
VC1_TTMB_VLC_BITS, 2);
- if(!s->mb_intra) vc1_mc_1mv(v);
+ if(!s->mb_intra) vc1_mc_1mv(v, 0);
dst_idx = 0;
for (i=0; i<6; i++)
{
if(s->mb_intra) {
/* check if prediction blocks A and C are available */
v->a_avail = v->c_avail = 0;
- if(i == 2 || i == 3 || s->mb_y)
+ if(i == 2 || i == 3 || !s->first_slice_line)
v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
if(i == 1 || i == 3 || s->mb_x)
v->c_avail = v->mb_type[0][s->block_index[i] - 1];
- vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
- 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));
+ vc1_decode_intra_block(v, s->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));
/* TODO: proper loop filtering */
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);
+ vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
if(v->c_avail)
- s->dsp.h263_h_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
+ vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
}
} else if(val) {
- vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block);
+ vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
if(!v->ttmbf && ttmb < 8) ttmb = -1;
first_block = 0;
- s->dsp.add_pixels_clamped(block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
+ s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
}
}
}
else //Skipped
{
s->mb_intra = 0;
- for(i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
+ for(i = 0; i < 6; i++) {
+ v->mb_type[0][s->block_index[i]] = 0;
+ s->dc_val[0][s->block_index[i]] = 0;
+ }
s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
s->current_picture.qscale_table[mb_pos] = 0;
vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
- vc1_mc_1mv(v);
+ vc1_mc_1mv(v, 0);
return 0;
}
} //1MV mode
v->mb_type[0][s->block_index[i]] = is_intra[i];
if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
}
+ // if there are no coded blocks then don't do anything more
+ if(!intra_count && !coded_inter) return 0;
dst_idx = 0;
GET_MQUANT();
s->current_picture.qscale_table[mb_pos] = mquant;
int intrapred = 0;
for(i=0; i<6; i++)
if(is_intra[i]) {
- if(v->mb_type[0][s->block_index[i] - s->block_wrap[i]] || v->mb_type[0][s->block_index[i] - 1]) {
+ if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
+ || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
intrapred = 1;
break;
}
else s->ac_pred = 0;
}
if (!v->ttmbf && coded_inter)
- ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 12);
+ ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
for (i=0; i<6; i++)
{
dst_idx += i >> 2;
if (is_intra[i]) {
/* check if prediction blocks A and C are available */
v->a_avail = v->c_avail = 0;
- if(i == 2 || i == 3 || s->mb_y)
+ if(i == 2 || i == 3 || !s->first_slice_line)
v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
if(i == 1 || i == 3 || s->mb_x)
v->c_avail = v->mb_type[0][s->block_index[i] - 1];
vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
- vc1_inv_trans(block[i], 8, 8);
- for(j = 0; j < 64; j++) block[i][j] += 128;
+ 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, (i&4)?s->uvlinesize:s->linesize);
/* TODO: proper loop filtering */
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);
+ vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
if(v->c_avail)
- s->dsp.h263_h_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
+ vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
}
} else if(is_coded[i]) {
status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
else //Skipped MB
{
s->mb_intra = 0;
- for (i=0; i<6; i++) v->mb_type[0][s->block_index[i]] = 0;
+ s->current_picture.qscale_table[mb_pos] = 0;
+ for (i=0; i<6; i++) {
+ v->mb_type[0][s->block_index[i]] = 0;
+ s->dc_val[0][s->block_index[i]] = 0;
+ }
for (i=0; i<4; i++)
{
vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
return -1;
}
+/** Decode one B-frame MB (in Main profile)
+ */
+static void vc1_decode_b_mb(VC1Context *v)
+{
+ MpegEncContext *s = &v->s;
+ GetBitContext *gb = &s->gb;
+ int i, j;
+ int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
+ int cbp; /* cbp decoding stuff */
+ int mqdiff, mquant; /* MB quantization */
+ int ttmb = v->ttfrm; /* MB Transform type */
+
+ static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
+ offset_table[6] = { 0, 1, 3, 7, 15, 31 };
+ int mb_has_coeffs = 0; /* last_flag */
+ int index, index1; /* LUT indices */
+ int val, sign; /* temp values */
+ int first_block = 1;
+ int dst_idx, off;
+ int skipped, direct;
+ int dmv_x[2], dmv_y[2];
+ int bmvtype = BMV_TYPE_BACKWARD; /* XXX: is it so? */
+
+ mquant = v->pq; /* Loosy initialization */
+ s->mb_intra = 0;
+
+ if (v->dmb_is_raw)
+ direct = get_bits1(gb);
+ else
+ direct = v->direct_mb_plane[mb_pos];
+ if (v->skip_is_raw)
+ skipped = get_bits1(gb);
+ else
+ skipped = v->s.mbskip_table[mb_pos];
+
+ s->dsp.clear_blocks(s->block[0]);
+ dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
+ for(i = 0; i < 6; i++) {
+ v->mb_type[0][s->block_index[i]] = 0;
+ s->dc_val[0][s->block_index[i]] = 0;
+ }
+ s->current_picture.qscale_table[mb_pos] = 0;
+
+ if (!direct) {
+ if (!skipped) {
+ GET_MVDATA(dmv_x[0], dmv_y[0]);
+ }
+ if(skipped || !s->mb_intra) {
+ bmvtype = decode012(gb);
+ switch(bmvtype) {
+ case 0:
+ bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
+ break;
+ case 1:
+ bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
+ break;
+ case 2:
+ bmvtype = BMV_TYPE_INTERPOLATED;
+ }
+ }
+ }
+
+ if (skipped) {
+ vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
+ return;
+ }
+ if (direct) {
+ cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
+ GET_MQUANT();
+ s->current_picture.qscale_table[mb_pos] = mquant;
+ if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
+ ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
+ vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
+ } else {
+ if(!mb_has_coeffs && !s->mb_intra) {
+ /* no coded blocks - effectively skipped */
+ vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
+ return;
+ }
+ if(s->mb_intra && !mb_has_coeffs) {
+ GET_MQUANT();
+ s->current_picture.qscale_table[mb_pos] = mquant;
+ s->ac_pred = get_bits1(gb);
+ cbp = 0;
+ } else {
+ if(bmvtype == BMV_TYPE_INTERPOLATED) {
+ GET_MVDATA(dmv_x[1], dmv_y[1]);
+ if(!mb_has_coeffs) {
+ /* interpolated skipped block */
+ vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
+ return;
+ }
+ }
+ if(!s->mb_intra)
+ vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
+ if(s->mb_intra)
+ s->ac_pred = get_bits1(gb);
+ cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
+ GET_MQUANT();
+ s->current_picture.qscale_table[mb_pos] = mquant;
+ if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
+ ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
+ }
+ }
+ dst_idx = 0;
+ for (i=0; i<6; i++)
+ {
+ s->dc_val[0][s->block_index[i]] = 0;
+ dst_idx += i >> 2;
+ val = ((cbp >> (5 - i)) & 1);
+ off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
+ v->mb_type[0][s->block_index[i]] = s->mb_intra;
+ if(s->mb_intra) {
+ /* check if prediction blocks A and C are available */
+ v->a_avail = v->c_avail = 0;
+ if(i == 2 || i == 3 || !s->first_slice_line)
+ v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
+ if(i == 1 || i == 3 || s->mb_x)
+ v->c_avail = v->mb_type[0][s->block_index[i] - 1];
+
+ vc1_decode_intra_block(v, s->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));
+ /* TODO: proper loop filtering */
+ if(v->pq >= 9 && v->overlap) {
+ if(v->a_avail)
+ vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
+ if(v->c_avail)
+ vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
+ }
+ } else if(val) {
+ vc1_decode_p_block(v, s->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);
+ }
+ }
+}
+
/** Decode blocks of I-frame
*/
static void vc1_decode_i_blocks(VC1Context *v)
{
- int k;
+ int k, j;
MpegEncContext *s = &v->s;
int cbp, val;
uint8_t *coded_val;
//do frame decode
s->mb_x = s->mb_y = 0;
s->mb_intra = 1;
+ s->first_slice_line = 1;
ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
vc1_inv_trans(s->block[k], 8, 8);
if(v->pq >= 9 && v->overlap) {
- vc1_overlap_block(s, s->block[k], k, (s->mb_y || k>1), (s->mb_x || (k != 0 && k != 2)));
+ for(j = 0; j < 64; j++) s->block[k][j] += 128;
}
}
vc1_put_block(v, s->block);
if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
- if(s->mb_y) {
- s->dsp.h263_v_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
- s->dsp.h263_v_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
- s->dsp.h263_v_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
- s->dsp.h263_v_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
+ if(!s->first_slice_line) {
+ vc1_v_overlap(s->dest[0], s->linesize, 0);
+ vc1_v_overlap(s->dest[0] + 8, s->linesize, 0);
+ vc1_v_overlap(s->dest[1], s->uvlinesize, s->mb_y&1);
+ vc1_v_overlap(s->dest[2], s->uvlinesize, s->mb_y&1);
}
- s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
- s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
+ vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1);
+ vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
if(s->mb_x) {
- s->dsp.h263_h_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
- s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
- s->dsp.h263_h_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
- s->dsp.h263_h_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
+ vc1_h_overlap(s->dest[0], s->linesize, 0);
+ vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0);
+ vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1);
+ vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1);
}
- s->dsp.h263_h_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
- s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
+ vc1_h_overlap(s->dest[0] + 8, s->linesize, 1);
+ vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
}
if(get_bits_count(&s->gb) > v->bits) {
}
}
ff_draw_horiz_band(s, s->mb_y * 16, 16);
+ s->first_slice_line = 0;
}
}
ff_update_block_index(s);
s->dsp.clear_blocks(s->block[0]);
- vc1_decode_p_mb(v, s->block);
+ vc1_decode_p_mb(v);
+ if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
+ av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
+ return;
+ }
+ }
+ ff_draw_horiz_band(s, s->mb_y * 16, 16);
+ s->first_slice_line = 0;
+ }
+}
+
+static void vc1_decode_b_blocks(VC1Context *v)
+{
+ MpegEncContext *s = &v->s;
+
+ /* select codingmode used for VLC tables selection */
+ switch(v->c_ac_table_index){
+ case 0:
+ v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
+ break;
+ case 1:
+ v->codingset = CS_HIGH_MOT_INTRA;
+ break;
+ case 2:
+ v->codingset = CS_MID_RATE_INTRA;
+ break;
+ }
+
+ switch(v->c_ac_table_index){
+ case 0:
+ v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
+ break;
+ case 1:
+ v->codingset2 = CS_HIGH_MOT_INTER;
+ break;
+ case 2:
+ v->codingset2 = CS_MID_RATE_INTER;
+ break;
+ }
+
+ ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
+ s->first_slice_line = 1;
+ for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
+ for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
+ ff_init_block_index(s);
+ ff_update_block_index(s);
+ s->dsp.clear_blocks(s->block[0]);
+
+ vc1_decode_b_mb(v);
if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
return;
case P_TYPE:
vc1_decode_p_blocks(v);
break;
+ case B_TYPE:
+ vc1_decode_b_blocks(v);
+ break;
}
}
return -1;
if (vc1_init_common(v) < 0) return -1;
- 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->coded_width = avctx->width;
avctx->coded_height = avctx->height;
if (avctx->codec_id == CODEC_ID_WMV3)
/* Allocate mb bitplanes */
v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
+ v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
/* allocate block type info in that way so it could be used with s->block_index[] */
v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
if(vc1_parse_frame_header(v, &s->gb) == -1)
return -1;
- if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
+// if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
// for hurry_up==5
s->current_picture.pict_type= s->pict_type;
av_freep(&v->hrd_buffer);
MPV_common_end(&v->s);
av_freep(&v->mv_type_mb_plane);
+ av_freep(&v->direct_mb_plane);
av_freep(&v->mb_type_base);
return 0;
}
projects / ffmpeg / blobdiff