libavcodec.hg: vc9.c comparison

comparison vc9.c @ 2462:5fd4de95731f libavcodec

Fixes: - i/p/b_decode_mbs functions now checks the proper values (from bitplane). I didn't find it very clear, but it seems "raw" = "to read at the MB layer". I used a structure, but we could spare that indirection and add a flag in the VC9Context for each array. - Properly decode (or so I think) the CBPCY (as it is predicted) - many more things patch by anonymous

author	michael
date	Mon, 24 Jan 2005 23:01:18 +0000
parents	1d818bf32736
children	9baa47d8297b

comparison

equal deleted inserted replaced

-:1d818bf32736
+:5fd4de95731f
 /*
 * VC-9 and WMV3 decoder
 * Copyright (c) 2005 Anonymous
 * Copyright (c) 2005 Alex Beregszaszi
+* Copyright (c) 2005 Michael Niedermayer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * @file vc9.c
 * VC-9 and WMV3 decoder
 *
 * TODO: Norm-6 bitplane imode, most AP stuff, optimize, all of MB layer :)
 * TODO: use MPV_ !!
+* TODO: export decode012 in bitstream.h ?
 */
 #include "common.h"
 #include "dsputil.h"
 #include "avcodec.h"
 #include "mpegvideo.h"
 #define DQDOUBLE_BEDGE_TOPLEFT     0
 #define DQDOUBLE_BEDGE_TOPRIGHT    1
 #define DQDOUBLE_BEDGE_BOTTOMRIGHT 2
 #define DQDOUBLE_BEDGE_BOTTOMLEFT  3
-/* Start Codes */
-#define SEQ_SC      0x00000010F /* Sequence Start Code */
-#define SEQ_EC      0x00000000A /* Sequence End code */
-#define SEQ_HDR     /* Sequence Header */
-#define ENTRY_SC    0x00000010E /* Entry Point Start Code */
-#define ENTRY_HDR /* Entry Point Header */
-#define FRM_SC      0x00000010D /* Frame Start Code */
-#define FRM_DAT /* Frame Data (includes a Frame Header) */
-#define FLD_SC      0x00000010C /* Field Start Code */
-#define FLD1_DAT /* Field 1 Data (includes a Frame Header) */
-#define FLD2_DAT /* Field 2 Data (includes a Field Header) */
-#define SLC_SC      0x00000010B /* Slice Start Code */
-#define SLC_HDR /* Slice Header */
-#define SLC_DAT /* Slice Data (FrH or FiH possible) */
 /* MV P modes */
 #define MV_PMODE_1MV_HPEL_BILIN   0
 #define MV_PMODE_1MV              1
 #define MV_PMODE_1MV_HPEL         2
 #define MV_PMODE_MIXED_MV         3
 #define MV_PMODE_INTENSITY_COMP   4
+#define BMV_TYPE_BACKWARD          0
+#define BMV_TYPE_FORWARD           1
+#define BMV_TYPE_INTERPOLATED      3
 /* 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_MIXED_MV, MV_PMODE_INTENSITY_COMP },
 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_INTENSITY_COMP }
 #define VC9_NORM2_VLC_BITS 3
 static VLC vc9_norm2_vlc;
 #define VC9_NORM6_VLC_BITS 9
 static VLC vc9_norm6_vlc;
 /* Could be optimized, one table only needs 8 bits */
-#define VC9_TTMB_VLC_BITS 12
+#define VC9_TTMB_VLC_BITS 9 //12
 static VLC vc9_ttmb_vlc[3];
-#define VC9_MV_DIFF_VLC_BITS 15
+#define VC9_MV_DIFF_VLC_BITS 9 //15
 static VLC vc9_mv_diff_vlc[4];
-#define VC9_CBPCY_I_VLC_BITS 13
+#define VC9_CBPCY_I_VLC_BITS 9 //13
 static VLC vc9_cbpcy_i_vlc;
-#define VC9_CBPCY_P_VLC_BITS 14
+#define VC9_CBPCY_P_VLC_BITS 9 //14
 static VLC vc9_cbpcy_p_vlc[4];
 #define VC9_4MV_BLOCK_PATTERN_VLC_BITS 6
 static VLC vc9_4mv_block_pattern_vlc[4];
 #define VC9_LUMA_DC_VLC_BITS 9
 static VLC vc9_luma_dc_vlc[2];
+#define VC9_CHROMA_DC_VLC_BITS 9
+static VLC vc9_chroma_dc_vlc[2];
+//We mainly need data and is_raw, so this struct could be avoided
+//to save a level of indirection; feel free to modify
+typedef struct BitPlane {
+uint8_t *data;
+int width, stride;
+int height;
+uint8_t is_raw;
+} BitPlane;
 typedef struct VC9Context{
 /* No MpegEnc context, might be good to use it */
 GetBitContext gb;
 AVCodecContext *avctx;
 uint8_t pict_type; /* Picture type, mapped on MPEG types */
 uint8_t pq, altpq; /* Quantizers */
 uint8_t dquantfrm, dqprofile, dqsbedge, dqbilevel; /* pquant parameters */
 int width_mb, height_mb;
 int tile; /* 3x2 if (width_mb%3) else 2x3 */
-int transacfrm2, transacfrm, transacdctab; //1bit elements
+VLC *luma_ac_vlc, *chroma_ac_vlc,
+*luma_dc_vlc, *chroma_dc_vlc; /* transac/dcfrm bits are indexes */
 uint8_t ttmbf, ttfrm; /* Transform type */
 uint8_t lumscale, lumshift; /* Luma compensation parameters */
 int16_t bfraction; /* Relative position % anchors=> how to scale MVs */
 uint8_t halfpq; /* Uniform quant over image and qp+.5 */
 uint8_t respic;
 * 2 -> [-512, 511.f] x [-128, 127.f]
 * 3 -> [-1024, 1023.f] x [-256, 255.f]
 */
 uint8_t mvrange;
 uint8_t pquantizer;
+uint8_t *previous_line_cbpcy; /* To use for predicted CBPCY */
 VLC *cbpcy_vlc /* Current CBPCY VLC table */,
 *mv_diff_vlc /* Current MV Diff VLC table */,
 *ttmb_vlc /* Current MB Transform Type VLC table */;
-uint8_t *mv_type_mb_plane; /* bitplane for mv_type == "raw" */
+BitPlane mv_type_mb_plane; /* bitplane for mv_type == (4MV) */
-uint8_t *skip_mb_plane, /* bitplane for skipped MBs */
+BitPlane skip_mb_plane, /* bitplane for skipped MBs */
-*direct_mb_plane; /* bitplane for "direct" MBs */
+direct_mb_plane; /* bitplane for "direct" MBs */
 /* S/M only ? */
-uint8_t rangeredfrm, interpfrm;
+uint8_t rangeredfrm; /* out_sample = CLIP((in_sample-128)*2+128) */
+uint8_t interpfrm;
 #if HAS_ADVANCED_PROFILE
 /* Advanced */
 uint8_t fcm; //0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
 uint8_t numpanscanwin;
 uint8_t uvsamp;
 uint8_t postproc;
 int hrd_num_leaky_buckets;
 uint8_t bit_rate_exponent;
 uint8_t buffer_size_exponent;
-uint8_t *ac_pred_plane;
+BitPlane ac_pred_plane; //AC prediction flags bitplane
-uint8_t *over_flags_plane;
+BitPlane over_flags_plane; //Overflags bitplane
+uint8_t condover;
 uint16_t *hrd_rate, *hrd_buffer;
+VLC *luma_ac2_vlc, *chroma_ac2_vlc;
 #endif
 } VC9Context;
 /* FIXME Slow and ugly */
 static int get_prefix(GetBitContext *gb, int stop, int len)
 {
+#if 1
 int i = 0, tmp = !stop;
 while (i != len && tmp != stop)
 {
 tmp = get_bits(gb, 1);
 i++;
 }
 return i;
+#else
+unsigned int buf;
+int log;
+OPEN_READER(re, gb);
+UPDATE_CACHE(re, gb);
+buf=GET_CACHE(re, gb); //Still not sure
+if (stop) buf = ~buf;
+log= av_log2(-buf); //FIXME: -?
+if (log < limit){
+LAST_SKIP_BITS(re, gb, log+1);
+CLOSE_READER(re, gb);
+return log;
+}
+LAST_SKIP_BITS(re, gb, limit);
+CLOSE_READER(re, gb);
+return limit;
+#endif
+}
+static int decode012(GetBitContext *gb)
+{
+int n;
+n = get_bits1(gb);
+if (n == 0)
+return 0;
+else
+return get_bits1(gb) + 1;
 }
 static int init_common(VC9Context *v)
 {
 static int done = 0;
 int i;
-v->mv_type_mb_plane = v->direct_mb_plane = v->skip_mb_plane = NULL;
+/* Set the bit planes */
-v->pq = -1;
+/* FIXME memset better ? (16bytes) */
+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 };
 #if HAS_ADVANCED_PROFILE
-v->ac_pred_plane = v->over_flags_plane = NULL;
+v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };
 v->hrd_rate = v->hrd_buffer = NULL;
 #endif
+/* VLC tables */
 #if 0 // spec -> actual tables converter
 for(i=0; i<64; i++){
 int code= (vc9_norm6_spec[i][1] << vc9_norm6_spec[i][4]) + vc9_norm6_spec[i][3];
 av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
 if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
 vc9_cbpcy_i_bits, 1, 1,
 vc9_cbpcy_i_codes, 2, 2, 1);
 INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,
 vc9_imode_bits, 1, 1,
 vc9_imode_codes, 1, 1, 1);
-for(i=0; i<3; i++)
+for (i=0; i<2; i++)
+{
+INIT_VLC(&vc9_luma_dc_vlc[i], VC9_LUMA_DC_VLC_BITS, 26,
+vc9_luma_dc_bits[i], 1, 1,
+vc9_luma_dc_codes[i], 4, 4, 1);
+INIT_VLC(&vc9_chroma_dc_vlc[i], VC9_CHROMA_DC_VLC_BITS, 26,
+vc9_chroma_dc_bits[i], 1, 1,
+vc9_chroma_dc_codes[i], 4, 4, 1);
+}
+for (i=0; i<3; i++)
+{
+INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,
+vc9_ttmb_bits[i], 1, 1,
+vc9_ttmb_codes[i], 2, 2, 1);
+}
+for(i=0; i<4; i++)
 {
 INIT_VLC(&vc9_4mv_block_pattern_vlc[i], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,
 vc9_4mv_block_pattern_bits[i], 1, 1,
 vc9_4mv_block_pattern_codes[i], 1, 1, 1);
 INIT_VLC(&vc9_cbpcy_p_vlc[i], VC9_CBPCY_P_VLC_BITS, 64,
 vc9_cbpcy_p_bits[i], 1, 1,
 vc9_cbpcy_p_codes[i], 2, 2, 1);
-}
-for (i=0; i<2; i++)
-{
 INIT_VLC(&vc9_mv_diff_vlc[i], VC9_MV_DIFF_VLC_BITS, 73,
 vc9_mv_diff_bits[i], 1, 1,
 vc9_mv_diff_codes[i], 2, 2, 1);
-INIT_VLC(&vc9_luma_dc_vlc[i], VC9_LUMA_DC_VLC_BITS, 120,
+}
-vc9_luma_dc_bits[i], 1, 1,
+}
-vc9_luma_dc_codes[i], 4, 4, 1);
-INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,
+/* Other defaults */
-vc9_ttmb_bits[i], 1, 1,
+v->pq = -1;
-vc9_ttmb_codes[i], 2, 2, 1);
+v->mvrange = 0; /* 7.1.1.18, p80 */
-}
-}
 return 0;
 }
 #if HAS_ADVANCED_PROFILE
+/* 6.2.1, p32 */
 static int decode_hrd(VC9Context *v, GetBitContext *gb)
 {
 int i, num;
 num = get_bits(gb, 5);
 if (v->hrd_rate || num != v->hrd_num_leaky_buckets)
 {
 av_freep(&v->hrd_rate);
 }
-if (!v->hrd_rate) v->hrd_rate = av_malloc(num);
+if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));
 if (!v->hrd_rate) return -1;
 if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)
 {
 av_freep(&v->hrd_buffer);
 }
-if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num);
+if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));
 if (!v->hrd_buffer) return -1;
 v->hrd_num_leaky_buckets = num;
 //exponent in base-2 for rate
 }
 }
 return 0;
 }
+/* Table 2, p18 */
 static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
 {
 VC9Context *v = avctx->priv_data;
 int nr, dr, aspect_ratio;
 return -1;
 }
 if (v->extended_mv)
 v->extended_dmv = get_bits(gb, 1);
+/* 6.1.7, p21 */
 if (get_bits(gb, 1) /* pic_size_flag */)
 {
 avctx->coded_width = get_bits(gb, 12);
 avctx->coded_height = get_bits(gb, 12);
 if ( get_bits(gb, 1) /* disp_size_flag */)
 {
 avctx->width = get_bits(gb, 14);
 avctx->height = get_bits(gb, 14);
 }
+/* 6.1.7.4, p22 */
 if ( get_bits(gb, 1) /* aspect_ratio_flag */)
 {
 aspect_ratio = get_bits(gb, 4); //SAR
 if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED
 {
 {
 avctx->coded_width = avctx->width;
 avctx->coded_height = avctx->height;
 }
+/* 6.1.8, p23 */
 if ( get_bits(gb, 1) /* framerateflag */)
 {
 if ( get_bits(gb, 1) /* framerateind */)
 {
 nr = get_bits(gb, 8);
 avctx->frame_rate = 1000000;
 avctx->frame_rate_base = 31250*(1+nr);
 }
 }
+/* 6.1.9, p25 */
 if ( get_bits(gb, 1) /* color_format_flag */)
 {
 //Chromacity coordinates of color primaries
 //like ITU-R BT.709-2, BT.470-2, ...
 v->color_prim = get_bits(gb, 8);
 av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");
 return -1;
 }
 #endif
+/* Figure 7-8, p16-17 */
 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
 {
 VC9Context *v = avctx->priv_data;
 v->profile = get_bits(gb, 2);
 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
 v->loopfilter, v->multires, v->fastuvmc, v->extended_mv,
 v->rangered, v->vstransform, v->overlap, v->syncmarker,
 v->dquant, v->quantizer_mode, avctx->max_b_frames
 );
+return 0;
 #endif
 }
 #if HAS_ADVANCED_PROFILE
-else decode_advanced_sequence_header(avctx, gb);
+else return decode_advanced_sequence_header(avctx, gb);
 #endif
 }
 #if HAS_ADVANCED_PROFILE
 return 0;
 }
 #endif
 /******************************************************************************/
-/* Bitplane decoding                                                          */
+/* Bitplane decoding: 8.7, p56                                                */
 /******************************************************************************/
 #define IMODE_RAW     0
 #define IMODE_NORM2   1
 #define IMODE_DIFF2   2
 #define IMODE_NORM6   3
 #define IMODE_DIFF6   4
 #define IMODE_ROWSKIP 5
 #define IMODE_COLSKIP 6
+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; //FIXME Needed for aligned data ?
+bp->height = height;
+return 0;
+}
 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, VC9Context *v){
 int x, y;
 for (y=0; y<height; y++){
 plane ++;
 }
 }
 //FIXME optimize
-//FIXME is this supposed to set elements to 0/FF or 0/1?
+//FIXME is this supposed to set elements to 0/FF or 0/1? 0/x!=0, not used for
-static int bitplane_decoding(uint8_t* plane, int width, int height, VC9Context *v)
+//      prediction
-{
+//FIXME Use BitPlane struct or return if table is raw (no bits read here but
-int imode, x, y, i, code, use_vertical_tile, tile_w, tile_h;
+//      later on)
-uint8_t invert, *planep = plane;
+static int bitplane_decoding(BitPlane *bp, VC9Context *v)
-int stride= width;
+{
+int imode, x, y, code, use_vertical_tile, tile_w, tile_h;
+uint8_t invert, *planep = bp->data;
 invert = get_bits(&v->gb, 1);
 imode = get_vlc2(&v->gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);
-av_log(v->avctx, AV_LOG_DEBUG, "Bitplane: imode=%i, invert=%i\n",
-imode, invert);
+bp->is_raw = 0;
 switch (imode)
 {
 case IMODE_RAW:
-for (y=0; y<height; y++)
+//Data is actually read in the MB layer (same for all tests == "raw")
-{
+bp->is_raw = 1; //invert ignored
-for (x=0; x<width; x++)
+return invert;
-planep[x] = (-get_bits(&v->gb, 1)); //-1=0xFF
-planep += stride;
-}
-invert=0; //spec says ignore invert if raw
-break;
 case IMODE_DIFF2:
 case IMODE_NORM2:
-if ((height*width) & 1) *(++planep) = get_bits(&v->gb, 1);
+if ((bp->height*bp->width) & 1) *(++planep) = get_bits(&v->gb, 1);
-for(i=0; i<(height*width)>>1; i++){
+for(x=0; x<(bp->height*bp->width)>>1; x++){
 code = get_vlc2(&v->gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);
 *(++planep) = code&1; //lsb => left
-*(++planep) = code&2; //msb => right - this is a bitplane, so only !0 matters
+*(++planep) = code&2; //msb => right - bitplane => only !0 matters
 //FIXME width->stride
 }
 break;
 case IMODE_DIFF6:
 case IMODE_NORM6:
-use_vertical_tile= height%3==0 && width%3!=0;
+use_vertical_tile=  bp->height%3==0 &&  bp->width%3!=0;
 tile_w= use_vertical_tile ? 2 : 3;
 tile_h= use_vertical_tile ? 3 : 2;
-for(y= height%tile_h; y<height; y+=tile_h){
+for(y=  bp->height%tile_h; y< bp->height; y+=tile_h){
-for(x= width%tile_w; x<width; x+=tile_w){
+for(x=  bp->width%tile_w; x< bp->width; x+=tile_w){
 code = get_vlc2(&v->gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);
 //FIXME following is a pure guess and probably wrong
-planep[x     + 0*stride]= (code>>0)&1;
+//FIXME A bitplane (0 | !0), so could the shifts be avoided ?
-planep[x + 1 + 0*stride]= (code>>1)&1;
+planep[x     + 0*bp->stride]= (code>>0)&1;
+planep[x + 1 + 0*bp->stride]= (code>>1)&1;
 if(use_vertical_tile){
-planep[x + 0 + 1*stride]= (code>>2)&1;
+planep[x + 0 + 1*bp->stride]= (code>>2)&1;
-planep[x + 1 + 1*stride]= (code>>3)&1;
+planep[x + 1 + 1*bp->stride]= (code>>3)&1;
-planep[x + 0 + 2*stride]= (code>>4)&1;
+planep[x + 0 + 2*bp->stride]= (code>>4)&1;
-planep[x + 1 + 2*stride]= (code>>5)&1;
+planep[x + 1 + 2*bp->stride]= (code>>5)&1;
 }else{
-planep[x + 2 + 0*stride]= (code>>2)&1;
+planep[x + 2 + 0*bp->stride]= (code>>2)&1;
-planep[x + 0 + 1*stride]= (code>>3)&1;
+planep[x + 0 + 1*bp->stride]= (code>>3)&1;
-planep[x + 1 + 1*stride]= (code>>4)&1;
+planep[x + 1 + 1*bp->stride]= (code>>4)&1;
-planep[x + 2 + 1*stride]= (code>>5)&1;
+planep[x + 2 + 1*bp->stride]= (code>>5)&1;
 }
 }
 }
-x= width % tile_w;
+x=  bp->width % tile_w;
-decode_colskip(plane  ,         x, height         , stride, v);
+decode_colskip(bp->data  ,             x, bp->height         , bp->stride, v);
-decode_rowskip(plane+x, width - x, height % tile_h, stride, v);
+decode_rowskip(bp->data+x, bp->width - x, bp->height % tile_h, bp->stride, v);
 break;
 case IMODE_ROWSKIP:
-decode_rowskip(plane, width, height, stride, v);
+decode_rowskip(bp->data, bp->width, bp->height, bp->stride, v);
 break;
 case IMODE_COLSKIP: //Teh ugly
-decode_colskip(plane, width, height, stride, v);
+decode_colskip(bp->data, bp->width, bp->height, bp->stride, v);
 break;
 default: break;
 }
 /* Applying diff operator */
 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
 {
-planep = plane;
+planep = bp->data;
 planep[0] ^= invert;
-for (x=1; x<width; x++)
+for (x=1; x<bp->width; x++)
 planep[x] ^= planep[x-1];
-for (y=1; y<height; y++)
+for (y=1; y<bp->height; y++)
 {
-planep += stride;
+planep += bp->stride;
-planep[0] ^= planep[-stride];
+planep[0] ^= planep[-bp->stride];
-for (x=1; x<width; x++)
+for (x=1; x<bp->width; x++)
 {
-if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
+if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
-else                                 planep[x] ^= planep[x-1];
+else                                     planep[x] ^= planep[x-1];
 }
 }
 }
 else if (invert)
 {
-planep = plane;
+planep = bp->data;
-for (x=0; x<width*height; x++) planep[x] = !planep[x]; //FIXME stride
+for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
 }
-return 0;
+return (imode<<1) + invert;
 }
 /*****************************************************************************/
 /* VOP Dquant decoding                                                       */
 /*****************************************************************************/
 av_log(v->avctx, AV_LOG_ERROR, "BI_TYPE not supported yet\n");
 /* Epilog should be done in caller */
 return -1;
 }
+/* Tables 11+12, p62-65 */
 static int decode_b_picture_header(VC9Context *v)
 {
-int pqindex;
+int pqindex, status;
 /* Prolog common to all frametypes should be done in caller */
 if (v->profile == PROFILE_SIMPLE)
 {
 av_log(v, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");
 v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping
 }
 if (v->mv_mode == MV_PMODE_MIXED_MV)
 {
-if (bitplane_decoding( v->mv_type_mb_plane, v->width_mb,
+status = bitplane_decoding(&v->mv_type_mb_plane, v);
-v->height_mb, v)<0)
+if (status < 0)
 return -1;
+#if TRACE
+av_log(v->avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
+"Imode: %i, Invert: %i\n", status>>1, status&1);
+#endif
 }
 //bitplane
-bitplane_decoding(v->direct_mb_plane, v->width_mb, v->height_mb, v);
+status = bitplane_decoding(&v->direct_mb_plane, v);
-bitplane_decoding(v->skip_mb_plane, v->width_mb, v->height_mb, v);
+if (status < 0) return -1;
+#if TRACE
+av_log(v->avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "
+"Imode: %i, Invert: %i\n", status>>1, status&1);
+#endif
+bitplane_decoding(&v->skip_mb_plane, v);
+if (status < 0) return -1;
+#if TRACE
+av_log(v->avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "
+"Imode: %i, Invert: %i\n", status>>1, status&1);
+#endif
 /* FIXME: what is actually chosen for B frames ? */
 v->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(&v->gb, 2)];
 v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(&v->gb, 2)];
 if (v->dquant)
 }
 /* Epilog should be done in caller */
 return 0;
 }
+/* Tables 5+7, p53-54 and 55-57 */
 static int decode_i_picture_header(VC9Context *v)
 {
-int pqindex, status = 0, ac_pred, condover;
+int pqindex, status = 0, ac_pred;
 /* Prolog common to all frametypes should be done in caller */
 //BF = Buffer Fullness
 if (v->profile <= PROFILE_MAIN && get_bits(&v->gb, 7))
 {
 ac_pred = get_bits(&v->gb, 1);
 if (v->postprocflag) v->postproc = get_bits(&v->gb, 1);
 /* 7.1.1.34 + 8.5.2 */
 if (v->overlap && v->pq<9)
 {
-condover = get_bits(&v->gb, 1);
+v->condover = get_bits(&v->gb, 1);
-if (condover)
+if (v->condover)
 {
-condover = 2+get_bits(&v->gb, 1);
+v->condover = 2+get_bits(&v->gb, 1);
-if (condover == 3)
+if (v->condover == 3)
-status = bitplane_decoding(v->over_flags_plane,
+{
-v->width_mb, v->height_mb, v);
+status = bitplane_decoding(&v->over_flags_plane, v);
+if (status < 0) return -1;
+#if TRACE
+av_log(v->avctx, AV_LOG_DEBUG, "Overflags plane encoding: "
+"Imode: %i, Invert: %i\n", status>>1, status&1);
+#endif
+}
 }
 }
 }
 #endif
 /* Epilog should be done in caller */
 return status;
 }
+/* Table 9, p58-60 */
 static int decode_p_picture_header(VC9Context *v)
 {
 /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */
-int lowquant, pqindex;
+int lowquant, pqindex, status = 0;
 pqindex = get_bits(&v->gb, 5);
 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
 v->pq = pquant_table[0][pqindex];
 else
 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
 v->mv_mode2 == MV_PMODE_MIXED_MV)
 || v->mv_mode == MV_PMODE_MIXED_MV)
 {
-if (bitplane_decoding(v->mv_type_mb_plane, v->width_mb,
+status = bitplane_decoding(&v->mv_type_mb_plane, v);
-v->height_mb, v) < 0)
+if (status < 0) return -1;
-return -1;
+#if TRACE
-}
+av_log(v->avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
+"Imode: %i, Invert: %i\n", status>>1, status&1);
-if (bitplane_decoding(v->skip_mb_plane, v->width_mb,
+#endif
-v->height_mb, v) < 0)
+}
-return -1;
+status = bitplane_decoding(&v->skip_mb_plane, v);
+if (status < 0) return -1;
+#if TRACE
+av_log(v->avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
+"Imode: %i, Invert: %i\n", status>>1, status&1);
+#endif
 /* Hopefully this is correct for P frames */
 v->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(&v->gb, 2)];
 v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(&v->gb, 2)];
 }
 static int standard_decode_picture_header(VC9Context *v)
 {
-int status = 0;
+int status = 0, index;
 if (v->finterpflag) v->interpfrm = get_bits(&v->gb, 1);
 skip_bits(&v->gb, 2); //framecnt unused
 if (v->rangered) v->rangeredfrm = get_bits(&v->gb, 1);
 v->pict_type = get_bits(&v->gb, 1);
 {
 av_log(v, AV_LOG_INFO, "Skipping frame...\n");
 return status;
 }
-/* AC/DC Syntax */
+/* AC Syntax */
-v->transacfrm = get_bits(&v->gb, 1);
+index = decode012(&v->gb);
-if (v->transacfrm) v->transacfrm += get_bits(&v->gb, 1);
+v->luma_ac_vlc = NULL + index; //FIXME Add AC table
+v->chroma_ac_vlc = NULL +  index;
 if (v->pict_type == I_TYPE || v->pict_type == BI_TYPE)
 {
-v->transacfrm2 = get_bits(&v->gb, 1);
+index = decode012(&v->gb);
-if (v->transacfrm2) v->transacfrm2 += get_bits(&v->gb, 1);
+v->luma_ac2_vlc = NULL + index; //FIXME Add AC2 table
-}
+v->chroma_ac2_vlc = NULL + index;
-v->transacdctab = get_bits(&v->gb, 1);
+}
+/* DC Syntax */
+index = decode012(&v->gb);
+v->luma_dc_vlc = vc9_luma_dc_vlc + index;
+v->chroma_dc_vlc = vc9_chroma_dc_vlc + index;
 return 0;
 }
 /* Advanced Profile picture header decoding specific functions                */
 /******************************************************************************/
 static int advanced_decode_picture_header(VC9Context *v)
 {
 static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };
-int type, i, ret;
+int type, i, index;
 if (v->interlace)
 {
 v->fcm = get_bits(&v->gb, 1);
 if (v->fcm) v->fcm = 2+get_bits(&v->gb, 1);
 case BI_TYPE:
 case B_TYPE: if (decode_b_picture_header(v) < 0) return FRAME_SKIPED;
 default: break;
 }
-/* AC/DC Syntax */
+/* AC Syntax */
-v->transacfrm = get_bits(&v->gb, 1);
+index = decode012(&v->gb);
-if (v->transacfrm) v->transacfrm += get_bits(&v->gb, 1);
+v->luma_ac_vlc = NULL + index; //FIXME
+v->chroma_ac_vlc = NULL +  index; //FIXME
 if (v->pict_type == I_TYPE || v->pict_type == BI_TYPE)
 {
-v->transacfrm2 = get_bits(&v->gb, 1);
+index = decode012(&v->gb); //FIXME
-if (v->transacfrm2) v->transacfrm2 += get_bits(&v->gb, 1);
+v->luma_ac2_vlc = NULL + index;
-}
+v->chroma_ac2_vlc = NULL + index;
-v->transacdctab = get_bits(&v->gb, 1);
+}
-if (v->pict_type == I_TYPE) vop_dquant_decoding(v);
+/* DC Syntax */
+index = decode012(&v->gb);
+v->luma_dc_vlc = vc9_luma_dc_vlc + index;
+v->chroma_dc_vlc = vc9_chroma_dc_vlc + index;
 return 0;
 }
 #endif
+/******************************************************************************/
+/* Block decoding functions                                                   */
+/******************************************************************************/
+/* 7.1.4, p91 and 8.1.1.7, p(1)04 */
+/* FIXME proper integration (unusable and lots of parameters to send */
+int decode_luma_intra_block(VC9Context *v, int mquant)
+{
+int dcdiff;
+dcdiff = get_vlc2(&v->gb, v->luma_dc_vlc->table,
+VC9_LUMA_DC_VLC_BITS, 2);
+if (dcdiff)
+{
+if (dcdiff == 119 /* ESC index value */)
+{
+/* TODO: Optimize */
+if (mquant == 1) dcdiff = get_bits(&v->gb, 10);
+else if (mquant == 2) dcdiff = get_bits(&v->gb, 9);
+else dcdiff = get_bits(&v->gb, 8);
+}
+else
+{
+if (mquant == 1)
+dcdiff = (dcdiff<<2) + get_bits(&v->gb, 2) - 3;
+else if (mquant == 2)
+dcdiff = (dcdiff<<1) + get_bits(&v->gb, 1) - 1;
+}
+if (get_bits(&v->gb, 1))
+dcdiff = -dcdiff;
+}
+/* FIXME: 8.1.1.15, p(1)13, coeff scaling for Adv Profile */
+return 0;
+}
 /******************************************************************************/
 /* MacroBlock decoding functions                                              */
 /******************************************************************************/
+/* 8.1.1.5, p(1)02-(1)03 */
+/* We only need to store 3 flags, but math with 4 is easier */
+#define GET_CBPCY(table, bits)                                      \
+predicted_cbpcy = get_vlc2(&v->gb, table, bits, 2);             \
+cbpcy[0] = (p_cbpcy[-1] == p_cbpcy[2])                          \
+? previous_cbpcy[1] : p_cbpcy[+2];                         \
+cbpcy[0] ^= ((predicted_cbpcy>>5)&0x01);                        \
+cbpcy[1] = (p_cbpcy[2] == p_cbpcy[3]) ? cbpcy[0] : p_cbpcy[3];  \
+cbpcy[1] ^= ((predicted_cbpcy>>4)&0x01);                        \
+cbpcy[2] = (previous_cbpcy[1] == cbpcy[0])                      \
+? previous_cbpcy[3] : cbpcy[0];                            \
+cbpcy[2] ^= ((predicted_cbpcy>>3)&0x01);                        \
+cbpcy[3] = (cbpcy[1] == cbpcy[0]) ? cbpcy[2] : cbpcy[1];        \
+cbpcy[3] ^= ((predicted_cbpcy>>2)&0x01);
+/* 8.1, p100 */
 static int standard_decode_i_mbs(VC9Context *v)
 {
-int x, y, ac_pred, cbpcy;
+int x, y, current_mb = 0; /* MB/Block Position info */
+int ac_pred;
+/* FIXME: better to use a pointer than using (x<<4) */
+uint8_t cbpcy[4], previous_cbpcy[4], predicted_cbpcy,
+*p_cbpcy /* Pointer to skip some math */;
+/* Reset CBPCY predictors */
+memset(v->previous_line_cbpcy, 0, (v->width_mb+1)<<2);
 /* Select ttmb table depending on pq */
 if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];
 else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];
 else v->ttmb_vlc = &vc9_ttmb_vlc[2];
 for (y=0; y<v->height_mb; y++)
 {
-for (x=0; x<v->width_mb; x++)
+/* Init CBPCY for line */
-{
+*((uint32_t*)previous_cbpcy) = 0x00000000;
-cbpcy = get_vlc2(&v->gb, vc9_cbpcy_i_vlc.table,
+p_cbpcy = v->previous_line_cbpcy+4;
-VC9_CBPCY_I_VLC_BITS, 2);
+for (x=0; x<v->width_mb; x++, p_cbpcy += 4)
+{
+/* Get CBPCY */
+GET_CBPCY(vc9_cbpcy_i_vlc.table, VC9_CBPCY_I_VLC_BITS);
 ac_pred = get_bits(&v->gb, 1);
-//Decode blocks from that mb wrt cbpcy
+/* TODO: Decode blocks from that mb wrt cbpcy */
+/* Update for next block */
+*((uint32_t*)p_cbpcy) = *((uint32_t*)previous_cbpcy);
+*((uint32_t*)previous_cbpcy) = *((uint32_t*)cbpcy);
+current_mb++;
 }
 }
 return 0;
 }
 else mquant = get_bits(&v->gb, 5);                     \
 }                                                        \
 }                                                          \
 }
-/* MVDATA decoding from 8.3.5.2 */
+/* MVDATA decoding from 8.3.5.2, p(1)20 */
-#define GET_MVDATA()                                           \
+#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
-index = 1 + get_vlc2(&v->gb, v->mv_diff_vlc->table,          \
+index = 1 + get_vlc2(&v->gb, v->mv_diff_vlc->table,               \
-VC9_MV_DIFF_VLC_BITS, 2);               \
+VC9_MV_DIFF_VLC_BITS, 2);                    \
-if (index > 36)                                              \
+if (index > 36)                                                   \
-{                                                            \
+{                                                                 \
-mb_has_coeffs = 1;                                         \
+mb_has_coeffs = 1;                                              \
-index -= 37;                                               \
+index -= 37;                                                    \
-}                                                            \
+}                                                                 \
-else mb_has_coeffs = 0;                                      \
+else mb_has_coeffs = 0;                                           \
-mb_is_intra = 0;                                             \
+mb_is_intra = 0;                                                  \
-if (!index) { dmv_x = dmv_y = 0; }                           \
+if (!index) { _dmv_x = _dmv_y = 0; }                              \
-else if (index == 35)                                        \
+else if (index == 35)                                             \
-{                                                            \
+{                                                                 \
-dmv_x = get_bits(&v->gb, k_x);                             \
+_dmv_x = get_bits(&v->gb, k_x);                                 \
-dmv_y = get_bits(&v->gb, k_y);                             \
+_dmv_y = get_bits(&v->gb, k_y);                                 \
-mb_is_intra = 1;                                           \
+mb_is_intra = 1;                                                \
-}                                                            \
+}                                                                 \
-else                                                         \
+else                                                              \
-{                                                            \
+{                                                                 \
-index1 = index%6;                                          \
+index1 = index%6;                                               \
-if (hpel_flag && index1 == 5) val = 1;                     \
+if (hpel_flag && index1 == 5) val = 1;                          \
-else val = 0;                                              \
+else                          val = 0;                          \
-val = get_bits(&v->gb, size_table[index1] - val);          \
+val = get_bits(&v->gb, size_table[index1] - val);               \
-sign = 0 - (val&1);                                        \
+sign = 0 - (val&1);                                             \
-dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
+_dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
 \
-index1 = index/6;                                          \
+index1 = index/6;                                               \
-if (hpel_flag && index1 == 5) val = 1;                     \
+if (hpel_flag && index1 == 5) val = 1;                          \
-else val = 0;                                              \
+else                          val = 0;                          \
-val = get_bits(&v->gb, size_table[index1] - val);          \
+val = get_bits(&v->gb, size_table[index1] - val);               \
-sign = 0 - (val&1);                                        \
+sign = 0 - (val&1);                                             \
-dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
+_dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
 }
+/* 8.1, p(1)15 */
 static int decode_p_mbs(VC9Context *v)
 {
 int x, y, current_mb = 0, i; /* MB/Block Position info */
-int skip_mb_bit = 0, cbpcy; /* MB/B skip */
+uint8_t cbpcy[4], previous_cbpcy[4], predicted_cbpcy,
+*p_cbpcy /* Pointer to skip some math */;
 int hybrid_pred, ac_pred; /* Prediction types */
-int mb_has_coeffs = 1  /* last_flag */, mb_is_intra;
+int mv_mode_bit = 0;
-int dmv_x, dmv_y; /* Differential MV components */
-int mv_mode_bit = 0; /* mv_mode_bit: 1MV=0, 4MV=0 */
 int mqdiff, mquant; /* MB quantization */
-int tt_block; /* MB Transform type */
+int ttmb; /* 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 = 1 /* last_flag */, mb_is_intra;
+int dmv_x, dmv_y; /* Differential MV components */
 int k_x, k_y; /* Long MV fixed bitlength */
-int hpel_flag, intra_flag; /* Some MB properties */
+int hpel_flag; /* Some MB properties */
 int index, index1; /* LUT indices */
-int val, sign;
+int val, sign; /* MVDATA temp values */
 /* Select ttmb table depending on pq */
 if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];
 else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];
 else v->ttmb_vlc = &vc9_ttmb_vlc[2];
 hpel_flag = v->mv_mode & 1; //MV_PMODE is HPEL
 k_x -= hpel_flag;
 k_y -= hpel_flag;
+/* Reset CBPCY predictors */
+memset(v->previous_line_cbpcy, 0, (v->width_mb+1)<<2);
 for (y=0; y<v->height_mb; y++)
 {
+/* Init CBPCY for line */
+*((uint32_t*)previous_cbpcy) = 0x00000000;
+p_cbpcy = v->previous_line_cbpcy+4;
 for (x=0; x<v->width_mb; x++)
 {
-if (v->mv_type_mb_plane[current_mb])
+if (v->mv_type_mb_plane.is_raw)
-mv_mode_bit = get_bits(&v->gb, 1);
+v->mv_type_mb_plane.data[current_mb] = get_bits(&v->gb, 1);
-if (0) //skipmb is rawmode
+if (v->skip_mb_plane.is_raw)
-skip_mb_bit = get_bits(&v->gb, 1);
+v->skip_mb_plane.data[current_mb] = get_bits(&v->gb, 1);
 if (!mv_mode_bit) /* 1MV mode */
 {
-if (!v->skip_mb_plane[current_mb])
+if (!v->skip_mb_plane.data[current_mb])
 {
-GET_MVDATA();
+GET_MVDATA(dmv_x, dmv_y);
 /* hybrid mv pred, 8.3.5.3.4 */
 if (v->mv_mode == MV_PMODE_1MV ||
 v->mv_mode == MV_PMODE_MIXED_MV)
 hybrid_pred = get_bits(&v->gb, 1);
 ac_pred = get_bits(&v->gb, 1);
 }
 else if (mb_has_coeffs)
 {
 if (mb_is_intra) ac_pred = get_bits(&v->gb, 1);
-cbpcy = get_vlc2(&v->gb, v->cbpcy_vlc->table,
+GET_CBPCY(v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS);
-VC9_CBPCY_P_VLC_BITS, 2);
 GET_MQUANT();
 }
 if (!v->ttmbf)
-v->ttfrm = get_vlc2(&v->gb, v->ttmb_vlc->table,
+ttmb = get_vlc2(&v->gb, v->ttmb_vlc->table,
-VC9_TTMB_VLC_BITS, 2);
+VC9_TTMB_VLC_BITS, 12);
-//Decode blocks from that mb wrt cbpcy
+/* TODO: decode blocks from that mb wrt cbpcy */
 }
 else //Skipped
 {
 /* hybrid mv pred, 8.3.5.3.4 */
 if (v->mv_mode == MV_PMODE_1MV ||
 hybrid_pred = get_bits(&v->gb, 1);
 }
 } //1MV mode
 else //4MV mode
 {
-if (!v->skip_mb_plane[current_mb] /* unskipped MB */)
+if (!v->skip_mb_plane.data[current_mb] /* unskipped MB */)
 {
-cbpcy = get_vlc2(&v->gb, v->cbpcy_vlc->table,
+/* Get CBPCY */
-VC9_CBPCY_P_VLC_BITS, 2);
+GET_CBPCY(v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS);
 for (i=0; i<4; i++) //For all 4 Y blocks
 {
-if (cbpcy & (1<<6) /* cbpcy set for this block */)
+if (cbpcy[i] /* cbpcy set for this block */)
 {
-GET_MVDATA();
+GET_MVDATA(dmv_x, dmv_y);
 }
 if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
 hybrid_pred = get_bits(&v->gb, 1);
 GET_MQUANT();
 if (mb_is_intra /* One of the 4 blocks is intra */ &&
 index /* non-zero pred for that block */)
 ac_pred = get_bits(&v->gb, 1);
 if (!v->ttmbf)
-tt_block = get_vlc2(&v->gb, v->ttmb_vlc->table,
+ttmb = get_vlc2(&v->gb, v->ttmb_vlc->table,
-VC9_TTMB_VLC_BITS, 2);
+VC9_TTMB_VLC_BITS, 12);
 /* TODO: Process blocks wrt cbpcy */
-/* Prepare cbpcy for next block */
-cbpcy <<= 1;
 }
 }
 else //Skipped MB
 {
 for (i=0; i<4; i++) //All 4 Y blocks
 {
 if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
 hybrid_pred = get_bits(&v->gb, 1);
-/* FIXME: do something */
+/* TODO: do something */
 }
 }
 }
-}
-current_mb++;
+/* Update for next block */
+#if TRACE > 2
+av_log(v->avctx, AV_LOG_DEBUG, "Block %4i: p_cbpcy=%i%i%i%i, previous_cbpcy=%i%i%i%i,"
+" cbpcy=%i%i%i%i\n", current_mb,
+p_cbpcy[0], p_cbpcy[1], p_cbpcy[2], p_cbpcy[3],
+previous_cbpcy[0], previous_cbpcy[1], previous_cbpcy[2], previous_cbpcy[3],
+cbpcy[0], cbpcy[1], cbpcy[2], cbpcy[3]);
+#endif
+*((uint32_t*)p_cbpcy) = *((uint32_t*)previous_cbpcy);
+*((uint32_t*)previous_cbpcy) = *((uint32_t*)cbpcy);
+current_mb++;
+}
 }
 return 0;
 }
 static int decode_b_mbs(VC9Context *v)
 {
-int x, y, current_mb = 0 , last_mb = v->height_mb*v->width_mb,
+int x, y, current_mb = 0, i /* MB / B postion information */;
-i /* MB / B postion information */;
-int direct_b_bit = 0, skip_mb_bit = 0;
 int ac_pred;
-int b_mv1 = 0, b_mv2 = 0, b_mv_type = 0;
+int b_mv_type = BMV_TYPE_BACKWARD;
 int mquant, mqdiff; /* MB quant stuff */
-int tt_block; /* Block transform type */
+int ttmb; /* MacroBlock 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 = 1 /* last_flag */, mb_is_intra = 1;
+int dmv1_x, dmv1_y, dmv2_x, dmv2_y; /* Differential MV components */
+int k_x, k_y; /* Long MV fixed bitlength */
+int hpel_flag; /* Some MB properties */
+int index, index1; /* LUT indices */
+int val, sign; /* MVDATA temp values */
+/* Select proper long MV range */
+switch (v->mvrange)
+{
+case 1: k_x = 10; k_y = 9; break;
+case 2: k_x = 12; k_y = 10; break;
+case 3: k_x = 13; k_y = 11; break;
+default: /*case 0 too */ k_x = 9; k_y = 8; break;
+}
+hpel_flag = v->mv_mode & 1; //MV_PMODE is HPEL
+k_x -= hpel_flag;
+k_y -= hpel_flag;
+/* Select ttmb table depending on pq */
+if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];
+else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];
+else v->ttmb_vlc = &vc9_ttmb_vlc[2];
 for (y=0; y<v->height_mb; y++)
 {
 for (x=0; x<v->width_mb; x++)
 {
-if (v->direct_mb_plane[current_mb])
+if (v->direct_mb_plane.is_raw)
-direct_b_bit = get_bits(&v->gb, 1);
+v->direct_mb_plane.data[current_mb] = get_bits(&v->gb, 1);
-if (1 /* Skip mode is raw */)
+if (v->skip_mb_plane.is_raw)
+v->skip_mb_plane.data[current_mb] = get_bits(&v->gb, 1);
+if (!v->direct_mb_plane.data[current_mb])
 {
-/* FIXME getting tired commenting */
+if (v->skip_mb_plane.data[current_mb])
-#if 0
-skip_mb_bit = get_bits(&v->gb, n); //vlc
-#endif
-}
-if (!direct_b_bit)
-{
-if (skip_mb_bit)
 {
-/* FIXME getting tired commenting */
+b_mv_type = decode012(&v->gb);
-#if 0
+if (v->bfraction > 420 /*1/2*/ &&
-b_mv_type = get_bits(&v->gb, n); //vlc
+b_mv_type < 3) b_mv_type = 1-b_mv_type;
-#endif
 }
 else
 {
 /* FIXME getting tired commenting */
-#if 0
+GET_MVDATA(dmv1_x, dmv1_y);
-b_mv1 = get_bits(&v->gb, n); //VLC
+if (!mb_is_intra /* b_mv1 tells not intra */)
-#endif
-if (1 /* b_mv1 isn't intra */)
 {
 /* FIXME: actually read it */
-b_mv_type = 0; //vlc
+b_mv_type = decode012(&v->gb);
+if (v->bfraction > 420 /*1/2*/ &&
+b_mv_type < 3) b_mv_type = 1-b_mv_type;
 }
 }
 }
-if (!skip_mb_bit)
+if (!v->skip_mb_plane.data[current_mb])
 {
-if (b_mv1 != last_mb)
+if (mb_has_coeffs /* BMV1 == "last" */)
 {
 GET_MQUANT();
-if (1 /* intra mb */)
+if (mb_is_intra /* intra mb */)
 ac_pred = get_bits(&v->gb, 1);
 }
 else
 {
-if (1 /* forward_mb is interpolate */)
+/* if bmv1 tells MVs are interpolated */
+if (b_mv_type == BMV_TYPE_INTERPOLATED)
 {
-/* FIXME: actually read it */
+GET_MVDATA(dmv2_x, dmv2_y);
-b_mv2 = 0; //vlc
 }
-if (1 /* b_mv2 isn't the last */)
+/* GET_MVDATA has reset some stuff */
+if (mb_has_coeffs /* b_mv2 == "last" */)
 {
-if (1 /* intra_mb */)
+if (mb_is_intra /* intra_mb */)
 ac_pred = get_bits(&v->gb, 1);
 GET_MQUANT();
 }
 }
 }
 //End1
-/* FIXME getting tired, commenting */
-#if 0
 if (v->ttmbf)
-v->ttmb = get_bits(&v->gb, n); //vlc
+ttmb = get_vlc2(&v->gb, v->ttmb_vlc->table,
-#endif
+VC9_TTMB_VLC_BITS, 12);
-}
 //End2
 for (i=0; i<6; i++)
 {
 /* FIXME: process the block */
 }
 current_mb++;
+}
 }
 return 0;
 }
 #if HAS_ADVANCED_PROFILE
 static int advanced_decode_i_mbs(VC9Context *v)
 {
-int i, x, y, cbpcy, mqdiff, absmq, mquant, ac_pred, condover,
+int x, y, mqdiff, mquant, ac_pred, current_mb = 0, over_flags_mb = 0;
-current_mb = 0, over_flags_mb = 0;
 for (y=0; y<v->height_mb; y++)
 {
 for (x=0; x<v->width_mb; x++)
 {
-if (v->ac_pred_plane[i])
+if (v->ac_pred_plane.data[current_mb])
 ac_pred = get_bits(&v->gb, 1);
-if (condover == 3 && v->over_flags_plane)
+if (v->condover == 3 && v->over_flags_plane.is_raw)
 over_flags_mb = get_bits(&v->gb, 1);
 GET_MQUANT();
+/* TODO: lots */
 }
 current_mb++;
 }
 return 0;
 }
 avctx->pix_fmt = PIX_FMT_YUV420P;
 v->avctx = avctx;
 if (init_common(v) < 0) return -1;
+avctx->coded_width = avctx->width;
+avctx->coded_height = avctx->height;
 if (avctx->codec_id == CODEC_ID_WMV3)
 {
 int count = 0;
 	// looks like WMV3 has a sequence header stored in the extradata
 //FIXME I feel like this is wrong
 v->width_mb = (avctx->coded_width+15)>>4;
 v->height_mb = (avctx->coded_height+15)>>4;
 /* Allocate mb bitplanes */
-v->mv_type_mb_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);
+if (alloc_bitplane(&v->mv_type_mb_plane, v->width_mb, v->height_mb) < 0)
-if (!v->mv_type_mb_plane) return -1;
+return -1;
-v->skip_mb_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);
+if (alloc_bitplane(&v->mv_type_mb_plane, v->width_mb, v->height_mb) < 0)
-if (!v->skip_mb_plane) return -1;
+return -1;
-v->direct_mb_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);
+if (alloc_bitplane(&v->skip_mb_plane, v->width_mb, v->height_mb) < 0)
-if (!v->direct_mb_plane) return -1;
+return -1;
+if (alloc_bitplane(&v->direct_mb_plane, v->width_mb, v->height_mb) < 0)
+return -1;
+/* For predictors */
+v->previous_line_cbpcy = (uint8_t *)av_malloc((v->width_mb+1)*4);
+if (!v->previous_line_cbpcy) return -1;
 #if HAS_ADVANCED_PROFILE
 if (v->profile > PROFILE_MAIN)
 {
-v->over_flags_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);
+if (alloc_bitplane(&v->over_flags_plane, v->width_mb, v->height_mb) < 0)
-if (!v->over_flags_plane) return -1;
+return -1;
-v->ac_pred_plane = (uint8_t *)av_malloc(v->width_mb*v->height_mb);
+if (alloc_bitplane(&v->ac_pred_plane, v->width_mb, v->height_mb) < 0)
-if (!v->ac_pred_plane) return -1;
+return -1;
 }
 #endif
 return 0;
 }
 avpicture_fill((AVPicture *)pict, tmp_buf, avctx->pix_fmt,
 avctx->width, avctx->height);
 if (avctx->codec_id == CODEC_ID_WMV3)
 {
+//No IDU
 	init_get_bits(&v->gb, buf, buf_size*8);
-	av_log(avctx, AV_LOG_INFO, "Frame: %i bits to decode\n", buf_size*8);
 #if HAS_ADVANCED_PROFILE
 	if (v->profile > PROFILE_MAIN)
 	{
 	    if (advanced_decode_picture_header(v) == FRAME_SKIPED) return buf_size;
 		case BI_TYPE: ret = decode_b_mbs(v); break;
 		default: ret = FRAME_SKIPED;
 	    }
 	    if (ret == FRAME_SKIPED) return buf_size;
 	}
-	/* Size of the output data = image */
-	av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",
-get_bits_count(&v->gb), buf_size*8);
 }
 else
 {
 #if 0
 	// search for IDU's
 	    init_get_bits(&v->gb, buf+i, (buf_size-i)*8);
 	    switch(scs)
 	    {
-		case 0xf:
+case 0x0A: //Sequence End Code
-		    decode_sequence_header(avctx, &v->gb);
+return 0;
-		    break;
+case 0x0B: //Slice Start Code
-		// to be finished
+av_log(avctx, AV_LOG_ERROR, "Slice coding not supported\n");
-	    }
+return -1;
+case 0x0C: //Field start code
+av_log(avctx, AV_LOG_ERROR, "Interlaced coding not supported\n");
+return -1;
+case 0x0D: //Frame start code
+break;
+case 0x0E: //Entry point Start Code
+if (v->profile <= MAIN_PROFILE)
+av_log(avctx, AV_LOG_ERROR,
+"Found an entry point in profile %i\n", v->profile);
+advanced_entry_point_process(avctx, &v->gb);
+break;
+case 0x0F: //Sequence header Start Code
+decode_sequence_header(avctx, &v->gb);
+break;
+default:
+av_log(avctx, AV_LOG_ERROR,
+"Unsupported IDU suffix %lX\n", scs);
+}
 	    i += get_bits_count(&v->gb)*8;
 	}
 #else
 	av_abort();
 #endif
 }
+av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",
+get_bits_count(&v->gb), buf_size*8);
+/* Fake consumption of all data */
 *data_size = len;
-/* Fake consumption of all data */
 return buf_size; //Number of bytes consumed
 }
 static int vc9_decode_end(AVCodecContext *avctx)
 {

Mercurial > libavcodec.hg

comparison vc9.c @ 2462:5fd4de95731f libavcodec