Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc9.c @ 5e424311

History | View | Annotate | Download (70.4 KB)

1
/*
2
 * VC-9 and WMV3 decoder
3
 * Copyright (c) 2005 Anonymous
4
 * Copyright (c) 2005 Alex Beregszaszi
5
 * Copyright (c) 2005 Michael Niedermayer
6
 *
7
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2 of the License, or (at your option) any later version.
11
 *
12
 * This library is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
 *
21
 */
22

    
23
/**
24
 * @file vc9.c
25
 * VC-9 and WMV3 decoder
26
 *
27
 * TODO: Norm-6 bitplane imode, most AP stuff, optimize, all of MB layer :)
28
 * TODO: use MPV_ !!
29
 */
30
#include "common.h"
31
#include "dsputil.h"
32
#include "avcodec.h"
33
#include "mpegvideo.h"
34
#include "vc9data.h"
35

    
36
extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
37
extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
38
extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
39
#define MB_INTRA_VLC_BITS 9
40
extern VLC ff_msmp4_mb_i_vlc;
41
#define DC_VLC_BITS 9
42
static const uint16_t table_mb_intra[64][2];
43

    
44
/* Some inhibiting stuff */
45
#define HAS_ADVANCED_PROFILE   1
46
#define TRACE                  1
47

    
48
#if TRACE
49
#  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
50
                   codes, codes_wrap, codes_size, use_static)          \
51
  if (init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,     \
52
               codes, codes_wrap, codes_size, use_static) < 0)         \
53
  {                                                                    \
54
    av_log(v->s.avctx, AV_LOG_ERROR, "Error for " # vlc " (%i)\n", i);   \
55
    return -1;                                                         \
56
  }
57
#else
58
#  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
59
                   codes, codes_wrap, codes_size, use_static)          \
60
  init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,         \
61
           codes, codes_wrap, codes_size, use_static)
62
#endif
63

    
64
#define PROFILE_SIMPLE   0
65
#define PROFILE_MAIN     1
66
#define PROFILE_ADVANCED 3
67

    
68
#define QUANT_FRAME_IMPLICIT   0
69
#define QUANT_FRAME_EXPLICIT   1
70
#define QUANT_NON_UNIFORM      2
71
#define QUANT_UNIFORM          3
72

    
73
/* Where quant can be changed */
74
#define DQPROFILE_FOUR_EDGES   0
75
#define DQPROFILE_DOUBLE_EDGES 1
76
#define DQPROFILE_SINGLE_EDGE  2
77
#define DQPROFILE_ALL_MBS      3
78

    
79
/* Which edge is quantized with ALTPQUANT */
80
#define DQSINGLE_BEDGE_LEFT   0
81
#define DQSINGLE_BEDGE_TOP    1
82
#define DQSINGLE_BEDGE_RIGHT  2
83
#define DQSINGLE_BEDGE_BOTTOM 3
84

    
85
/* Which pair of edges is quantized with ALTPQUANT */
86
#define DQDOUBLE_BEDGE_TOPLEFT     0
87
#define DQDOUBLE_BEDGE_TOPRIGHT    1
88
#define DQDOUBLE_BEDGE_BOTTOMRIGHT 2
89
#define DQDOUBLE_BEDGE_BOTTOMLEFT  3
90

    
91
/* MV P modes */
92
#define MV_PMODE_1MV_HPEL_BILIN   0
93
#define MV_PMODE_1MV              1
94
#define MV_PMODE_1MV_HPEL         2
95
#define MV_PMODE_MIXED_MV         3
96
#define MV_PMODE_INTENSITY_COMP   4
97

    
98
#define BMV_TYPE_BACKWARD          0
99
#define BMV_TYPE_FORWARD           1
100
#define BMV_TYPE_INTERPOLATED      3
101

    
102
/* MV P mode - the 5th element is only used for mode 1 */
103
static const uint8_t mv_pmode_table[2][5] = {
104
  { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV, MV_PMODE_INTENSITY_COMP },
105
  { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_INTENSITY_COMP }
106
};
107

    
108
/* One more frame type */
109
#define BI_TYPE 7
110

    
111
/* FIXME Worse than ugly */
112
static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
113
  fps_dr[2] = { 1000, 1001 };
114
static const uint8_t pquant_table[3][32] = {
115
  {  /* Implicit quantizer */
116
     0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,
117
    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
118
  },
119
  {  /* Explicit quantizer, pquantizer uniform */
120
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
121
    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
122
  },
123
  {  /* Explicit quantizer, pquantizer non-uniform */
124
     0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
125
    14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
126
  }
127
};
128

    
129
// FIXME move this into the context
130
#define VC9_BFRACTION_VLC_BITS 7
131
static VLC vc9_bfraction_vlc;
132
#define VC9_IMODE_VLC_BITS 4
133
static VLC vc9_imode_vlc;
134
#define VC9_NORM2_VLC_BITS 3
135
static VLC vc9_norm2_vlc;
136
#if TILE_VLC_METHOD == 1
137
#define VC9_NORM6_VLC_BITS 9
138
static VLC vc9_norm6_vlc;
139
#endif
140
#if TILE_VLC_METHOD == 2
141
#define VC9_NORM6_FIRST_BITS 8
142
#define VC9_NORM6_SECOND 8
143
static VLC vc9_norm6_first, vc9_norm6_second;
144
#endif
145
/* Could be optimized, one table only needs 8 bits */
146
#define VC9_TTMB_VLC_BITS 9 //12
147
static VLC vc9_ttmb_vlc[3];
148
#define VC9_MV_DIFF_VLC_BITS 9 //15
149
static VLC vc9_mv_diff_vlc[4];
150
#define VC9_CBPCY_P_VLC_BITS 9 //14
151
static VLC vc9_cbpcy_p_vlc[4];
152
#define VC9_4MV_BLOCK_PATTERN_VLC_BITS 6
153
static VLC vc9_4mv_block_pattern_vlc[4];
154

    
155
//We mainly need data and is_raw, so this struct could be avoided
156
//to save a level of indirection; feel free to modify
157
typedef struct BitPlane {
158
    uint8_t *data;
159
    int width, stride;
160
    int height;
161
    uint8_t is_raw;
162
} BitPlane;
163

    
164
typedef struct VC9Context{
165
  /* No MpegEnc context, might be good to use it */
166
  MpegEncContext s;
167

    
168
  /***************************/
169
  /* Sequence Header         */
170
  /***************************/
171
  /* Simple/Main Profile */
172
  int res_sm; //reserved, 2b
173
  int res_x8; //reserved
174
  int multires; //frame-level RESPIC syntax element present
175
  int res_fasttx; //always 1
176
  int res_transtab; //always 0
177
  int rangered; //RANGEREDFRM (range reduction) syntax element present
178
  int res_rtm_flag; //reserved, set to 1
179
  int reserved; //duh
180

    
181
#if HAS_ADVANCED_PROFILE
182
  /* Advanced Profile */
183
  int level; //3
184
  int chromaformat; //2
185
  int postprocflag; //frame-based processing use
186
  int broadcast; //TFF/RFF present
187
    int interlace; //Progressive/interlaced (RPTFTM syntax element)
188
  int tfcntrflag; //TFCNTR present
189
  int panscanflag; //NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} presents
190
    int extended_dmv;
191
  int color_prim; //8
192
  int transfer_char; //8
193
  int matrix_coef; //8
194
  int hrd_param_flag;
195
#endif
196

    
197
  /* All Profiles */
198
  /* TODO: move all int to flags */
199
  int profile; //2
200
  int frmrtq_postproc; //3
201
  int bitrtq_postproc; //5
202
    int loopfilter;
203
    int fastuvmc; //Rounding of qpel vector to hpel ? (not in Simple)
204
  int extended_mv; //Ext MV in P/B (not in Simple)
205
  int dquant; //How qscale varies with MBs, 2bits (not in Simple)
206
  int vstransform; //variable-size transform46
207
  
208

    
209
  int overlap; //overlapped transforms in use
210
  int quantizer_mode; //2, quantizer mode used for sequence, see QUANT_*
211
  int finterpflag; //INTERPFRM present
212

    
213

    
214
  /*****************************/
215
  /* Frame decoding            */
216
  /*****************************/
217
  /* All profiles */
218
  uint8_t mv_mode, mv_mode2; /* MV coding mode */
219
  uint8_t pq, altpq; /* Quantizers */
220
  uint8_t dquantfrm, dqprofile, dqsbedge, dqbilevel; /* pquant parameters */
221
  int tile; /* 3x2 if (width_mb%3) else 2x3 */
222
  int ac_table_level;
223
  VLC *luma_dc_vlc, *chroma_dc_vlc; /* transac/dcfrm bits are indexes */
224
  uint8_t ttmbf, ttfrm; /* Transform type */
225
  uint8_t lumscale, lumshift; /* Luma compensation parameters */
226
  int16_t bfraction; /* Relative position % anchors=> how to scale MVs */
227
  uint8_t halfpq; /* Uniform quant over image and qp+.5 */
228
  uint8_t respic;
229
  int buffer_fullness; /* For HRD ? */
230
  /* Ranges:
231
   * 0 -> [-64n 63.f] x [-32, 31.f]
232
   * 1 -> [-128, 127.f] x [-64, 63.f]
233
   * 2 -> [-512, 511.f] x [-128, 127.f]
234
   * 3 -> [-1024, 1023.f] x [-256, 255.f]
235
   */
236
  uint8_t mvrange;
237
  uint8_t pquantizer;
238
  uint8_t *previous_line_cbpcy; /* To use for predicted CBPCY */
239
  VLC *cbpcy_vlc /* Current CBPCY VLC table */,
240
    *ttmb_vlc /* Current MB Transform Type VLC table */;
241
  BitPlane mv_type_mb_plane; /* bitplane for mv_type == (4MV) */
242
  BitPlane skip_mb_plane, /* bitplane for skipped MBs */
243
    direct_mb_plane; /* bitplane for "direct" MBs */
244

    
245
  /* S/M only ? */
246
  uint8_t rangeredfrm; /* out_sample = CLIP((in_sample-128)*2+128) */
247
  uint8_t interpfrm;
248

    
249
#if HAS_ADVANCED_PROFILE
250
  /* Advanced */
251
  uint8_t fcm; //0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
252
  uint8_t numpanscanwin;
253
  uint8_t tfcntr;
254
  uint8_t rptfrm, tff, rff;
255
  uint8_t topleftx;
256
  uint8_t toplefty;
257
  uint8_t bottomrightx;
258
  uint8_t bottomrighty;
259
  uint8_t uvsamp;
260
  uint8_t postproc;
261
  int hrd_num_leaky_buckets;
262
  uint8_t bit_rate_exponent;
263
  uint8_t buffer_size_exponent;
264
  BitPlane ac_pred_plane; //AC prediction flags bitplane
265
  BitPlane over_flags_plane; //Overflags bitplane
266
  uint8_t condover;
267
  uint16_t *hrd_rate, *hrd_buffer;
268
  VLC *luma_ac2_vlc, *chroma_ac2_vlc;
269
#endif
270
} VC9Context;
271

    
272
/* FIXME Slow and ugly */
273
static int get_prefix(GetBitContext *gb, int stop, int len)
274
{
275
#if 1
276
  int i = 0, tmp = !stop;
277

    
278
  while (i != len && tmp != stop)
279
  {
280
    tmp = get_bits(gb, 1);
281
    i++;
282
  }
283
  return i;
284
#else
285
  unsigned int buf;
286
  int log;
287

    
288
  OPEN_READER(re, gb);
289
  UPDATE_CACHE(re, gb);
290
  buf=GET_CACHE(re, gb); //Still not sure
291
  if (stop) buf = ~buf;
292
  
293
  log= av_log2(-buf); //FIXME: -?
294
  if (log < limit){
295
    LAST_SKIP_BITS(re, gb, log+1);
296
    CLOSE_READER(re, gb);
297
    return log;
298
  }
299
  
300
  LAST_SKIP_BITS(re, gb, limit);
301
  CLOSE_READER(re, gb);
302
  return limit;
303
#endif
304
}
305

    
306
static int vc9_init_common(VC9Context *v)
307
{
308
    static int done = 0;
309
    int i;
310

    
311
    /* Set the bit planes */
312
    /* FIXME memset better ? (16bytes) */
313
    v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
314
    v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
315
    v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
316
#if HAS_ADVANCED_PROFILE
317
    v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };
318
    v->hrd_rate = v->hrd_buffer = NULL;
319
#endif
320

    
321
    /* VLC tables */
322
#if TILE_VLC_METHOD == 1
323
#  if 0 // spec -> actual tables converter
324
    for(i=0; i<64; i++){
325
        int code= (vc9_norm6_spec[i][1] << vc9_norm6_spec[i][4]) + vc9_norm6_spec[i][3];
326
        av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
327
        if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
328
    }
329
    for(i=0; i<64; i++){
330
        int code= vc9_norm6_spec[i][2] + vc9_norm6_spec[i][4];
331
        av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);
332
        if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
333
    }
334
#  endif
335
#endif
336
    if(!done)
337
    {
338
        done = 1;
339
        INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,
340
                 vc9_bfraction_bits, 1, 1,
341
                 vc9_bfraction_codes, 1, 1, 1);
342
        INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,
343
                 vc9_norm2_bits, 1, 1,
344
                 vc9_norm2_codes, 1, 1, 1);
345
#if TILE_VLC_METHOD == 1
346
        INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,
347
                 vc9_norm6_bits, 1, 1,
348
                 vc9_norm6_codes, 2, 2, 1);
349
#endif
350
#if TILE_VLC_METHOD == 2
351
        INIT_VLC(&vc9_norm6_first, VC9_NORM6_FIRST_BITS, 64,
352
                 &vc9_norm6_first[0][1], 1, 1,
353
                 &vc9_norm6_first[0][0], 1, 1, 1);
354
        INIT_VLC(&vc9_norm6_second, VC9_NORM6_SECOND_BITS, 64,
355
                 vc9_norm6_second[0][1], 1, 1,
356
                 vc9_norm6_second[0][1], 1, 1, 1);
357
#endif
358
        INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,
359
                 vc9_imode_bits, 1, 1,
360
                 vc9_imode_codes, 1, 1, 1);
361
        for (i=0; i<3; i++)
362
        {
363
            INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,
364
                     vc9_ttmb_bits[i], 1, 1,
365
                     vc9_ttmb_codes[i], 2, 2, 1);
366
        }
367
        for(i=0; i<4; i++)
368
        {
369
            INIT_VLC(&vc9_4mv_block_pattern_vlc[i], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,
370
                     vc9_4mv_block_pattern_bits[i], 1, 1,
371
                     vc9_4mv_block_pattern_codes[i], 1, 1, 1);
372
            INIT_VLC(&vc9_cbpcy_p_vlc[i], VC9_CBPCY_P_VLC_BITS, 64,
373
                     vc9_cbpcy_p_bits[i], 1, 1,
374
                     vc9_cbpcy_p_codes[i], 2, 2, 1);
375
            INIT_VLC(&vc9_mv_diff_vlc[i], VC9_MV_DIFF_VLC_BITS, 73,
376
                     vc9_mv_diff_bits[i], 1, 1,
377
                     vc9_mv_diff_codes[i], 2, 2, 1);
378
        }
379
    }
380

    
381
    /* Other defaults */
382
    v->pq = -1;
383
    v->mvrange = 0; /* 7.1.1.18, p80 */
384

    
385
    return 0;
386
}
387

    
388
#if HAS_ADVANCED_PROFILE
389
/* 6.2.1, p32 */
390
static int decode_hrd(VC9Context *v, GetBitContext *gb)
391
{
392
    int i, num;
393

    
394
    num = get_bits(gb, 5);
395

    
396
    if (v->hrd_rate || num != v->hrd_num_leaky_buckets)
397
    {
398
        av_freep(&v->hrd_rate);
399
    }
400
    if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));
401
    if (!v->hrd_rate) return -1;
402

    
403
    if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)
404
    {
405
        av_freep(&v->hrd_buffer);
406
    }
407
    if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));
408
    if (!v->hrd_buffer) return -1;
409

    
410
    v->hrd_num_leaky_buckets = num;
411

    
412
    //exponent in base-2 for rate
413
    v->bit_rate_exponent = get_bits(gb, 4);
414
    //exponent in base-2 for buffer_size
415
    v->buffer_size_exponent = get_bits(gb, 4);
416

    
417
    for (i=0; i<num; i++)
418
    {
419
        //mantissae, ordered (if not, use a function ?
420
        v->hrd_rate[i] = get_bits(gb, 16);
421
        if (i && v->hrd_rate[i-1]>=v->hrd_rate[i])
422
        {
423
            av_log(v->s.avctx, AV_LOG_ERROR, "HDR Rates aren't strictly increasing:"
424
                   "%i vs %i\n", v->hrd_rate[i-1], v->hrd_rate[i]);
425
            return -1;
426
        }
427
        v->hrd_buffer[i] = get_bits(gb, 16);
428
        if (i && v->hrd_buffer[i-1]<v->hrd_buffer[i])
429
        {
430
            av_log(v->s.avctx, AV_LOG_ERROR, "HDR Buffers aren't decreasing:"
431
                   "%i vs %i\n", v->hrd_buffer[i-1], v->hrd_buffer[i]);
432
            return -1;
433
        }
434
    }
435
    return 0;
436
}
437

    
438
/* Table 2, p18 */
439
static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
440
{
441
    VC9Context *v = avctx->priv_data;
442
    int nr, dr, aspect_ratio;
443

    
444
    v->postprocflag = get_bits(gb, 1);
445
    v->broadcast = get_bits(gb, 1);
446
    v->interlace = get_bits(gb, 1);
447

    
448
    v->tfcntrflag = get_bits(gb, 1);
449
    v->finterpflag = get_bits(gb, 1); //common
450
    v->panscanflag = get_bits(gb, 1);
451
    v->reserved = get_bits(gb, 1);
452
    if (v->reserved)
453
    {
454
        av_log(avctx, AV_LOG_ERROR, "RESERVED should be 0 (is %i)\n",
455
               v->reserved);
456
        return -1;
457
    }
458
    if (v->extended_mv)
459
        v->extended_dmv = get_bits(gb, 1);
460

    
461
    /* 6.1.7, p21 */
462
    if (get_bits(gb, 1) /* pic_size_flag */)
463
    {
464
        avctx->coded_width = get_bits(gb, 12);
465
        avctx->coded_height = get_bits(gb, 12);
466
        if ( get_bits(gb, 1) /* disp_size_flag */)
467
        {
468
            avctx->width = get_bits(gb, 14);
469
            avctx->height = get_bits(gb, 14);
470
        }
471

    
472
        /* 6.1.7.4, p22 */
473
        if ( get_bits(gb, 1) /* aspect_ratio_flag */)
474
        {
475
            aspect_ratio = get_bits(gb, 4); //SAR
476
            if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED
477
            {
478
                avctx->sample_aspect_ratio.num = get_bits(gb, 8);
479
                avctx->sample_aspect_ratio.den = get_bits(gb, 8);
480
            }
481
            else if (aspect_ratio == 0x0E)
482
            {
483
                av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");
484
            }
485
            else
486
            {
487
              avctx->sample_aspect_ratio = vc9_pixel_aspect[aspect_ratio];
488
            }
489
        }
490
    }
491
    else
492
    {
493
        avctx->coded_width = avctx->width;
494
        avctx->coded_height = avctx->height;
495
    }
496

    
497
    /* 6.1.8, p23 */
498
    if ( !get_bits(gb, 1) /* framerateflag */)
499
    {
500
        if ( get_bits(gb, 1) /* framerateind */)
501
        {
502
            nr = get_bits(gb, 8);
503
            dr = get_bits(gb, 4);
504
            if (nr<1)
505
            {
506
                av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATENR\n");
507
                return -1;
508
            }
509
            if (nr>5)
510
            {
511
                av_log(avctx, AV_LOG_ERROR,
512
                       "Reserved FRAMERATENR %i not handled\n", nr);
513
           }
514
            if (dr<1)
515
            {
516
                av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");
517
           }
518
            if (dr>2)
519
            {
520
                av_log(avctx, AV_LOG_ERROR,
521
                       "Reserved FRAMERATEDR %i not handled\n", dr);
522
            }
523
            avctx->frame_rate_base = fps_nr[dr];
524
            avctx->frame_rate = fps_nr[nr];
525
        }
526
        else
527
        {
528
            nr = get_bits(gb, 16);
529
            // 0.03125->2048Hz / 0.03125Hz
530
            avctx->frame_rate = 1000000;
531
            avctx->frame_rate_base = 31250*(1+nr);
532
        }
533
    }
534

    
535
    /* 6.1.9, p25 */
536
    if ( get_bits(gb, 1) /* color_format_flag */)
537
    {
538
        //Chromacity coordinates of color primaries
539
        //like ITU-R BT.709-2, BT.470-2, ...
540
        v->color_prim = get_bits(gb, 8);
541
        if (v->color_prim<1)
542
        {
543
            av_log(avctx, AV_LOG_ERROR, "0 for COLOR_PRIM is reserved\n");
544
            return -1;
545
        }
546
        if (v->color_prim == 3 || v->color_prim>6)
547
        {
548
            av_log(avctx, AV_LOG_DEBUG, "Reserved COLOR_PRIM %i found\n",
549
                   v->color_prim);
550
            return -1;
551
        }
552

    
553
        //Opto-electronic transfer characteristics
554
        v->transfer_char = get_bits(gb, 8);
555
        if (v->transfer_char == 3 || v->transfer_char>8)
556
        {
557
            av_log(avctx, AV_LOG_DEBUG, "Reserved TRANSFERT_CHAR %i found\n",
558
                   v->color_prim);
559
            return -1;
560
        }
561

    
562
        //Matrix coefficient for primariev->YCbCr
563
        v->matrix_coef = get_bits(gb, 8);
564
        if (v->matrix_coef < 1) return -1; //forbidden
565
        if ((v->matrix_coef>3 && v->matrix_coef<6) || v->matrix_coef>7)
566
        {
567
            av_log(avctx, AV_LOG_DEBUG, "Reserved MATRIX_COEF %i found\n",
568
                   v->color_prim);
569
            return -1;
570
        }
571
    }
572

    
573
    //Hypothetical reference decoder indicator flag
574
    v->hrd_param_flag = get_bits(gb, 1);
575
    if (v->hrd_param_flag)
576
    {
577
      if (decode_hrd(v, gb) < 0) return -1;
578
    }
579

    
580
    av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");
581
    return -1;
582
}
583
#endif
584

    
585
/* Figure 7-8, p16-17 */
586
static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
587
{
588
    VC9Context *v = avctx->priv_data;
589

    
590
    v->profile = get_bits(gb, 2);
591
    av_log(avctx, AV_LOG_DEBUG, "Profile: %i\n", v->profile);
592

    
593
#if HAS_ADVANCED_PROFILE
594
    if (v->profile > PROFILE_MAIN)
595
    {
596
        v->level = get_bits(gb, 3);
597
        v->chromaformat = get_bits(gb, 2);
598
        if (v->chromaformat != 1)
599
        {
600
            av_log(avctx, AV_LOG_ERROR,
601
                   "Only 4:2:0 chroma format supported\n");
602
            return -1;
603
        }
604
    }
605
    else
606
#endif
607
    {
608
        v->res_sm = get_bits(gb, 2); //reserved
609
        if (v->res_sm)
610
        {
611
            av_log(avctx, AV_LOG_ERROR,
612
                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);
613
            //return -1;
614
        }
615
    }
616

    
617
    // (fps-2)/4 (->30)
618
    v->frmrtq_postproc = get_bits(gb, 3); //common
619
    // (bitrate-32kbps)/64kbps
620
    v->bitrtq_postproc = get_bits(gb, 5); //common
621
    v->s.loop_filter = get_bits(gb, 1); //common
622

    
623
#if HAS_ADVANCED_PROFILE
624
    if (v->profile <= PROFILE_MAIN)
625
#endif
626
    {
627
        v->res_x8 = get_bits(gb, 1); //reserved
628
        if (v->res_x8)
629
        {
630
            av_log(avctx, AV_LOG_ERROR,
631
                   "1 for reserved RES_X8 is forbidden\n");
632
            //return -1;
633
        }
634
        v->multires = get_bits(gb, 1);
635
        v->res_fasttx = get_bits(gb, 1);
636
        if (!v->res_fasttx)
637
        {
638
            av_log(avctx, AV_LOG_ERROR,
639
                   "0 for reserved RES_FASTTX is forbidden\n");
640
            //return -1;
641
        }
642
    }
643

    
644
    v->fastuvmc =  get_bits(gb, 1); //common
645
    if (!v->profile && !v->fastuvmc)
646
    {
647
        av_log(avctx, AV_LOG_ERROR,
648
               "FASTUVMC unavailable in Simple Profile\n");
649
        return -1;
650
    }
651
    v->extended_mv =  get_bits(gb, 1); //common
652
    if (!v->profile && v->extended_mv)
653
    {
654
        av_log(avctx, AV_LOG_ERROR,
655
               "Extended MVs unavailable in Simple Profile\n");
656
        return -1;
657
    }
658
    v->dquant =  get_bits(gb, 2); //common
659
    v->vstransform =  get_bits(gb, 1); //common
660
    
661
#if HAS_ADVANCED_PROFILE
662
    if (v->profile <= PROFILE_MAIN)
663
#endif
664
    {
665
        v->res_transtab = get_bits(gb, 1);
666
        if (v->res_transtab)
667
        {
668
            av_log(avctx, AV_LOG_ERROR,
669
                   "1 for reserved RES_TRANSTAB is forbidden\n");
670
            return -1;
671
        }
672
    }
673

    
674
    v->overlap = get_bits(gb, 1); //common
675

    
676
#if HAS_ADVANCED_PROFILE
677
    if (v->profile <= PROFILE_MAIN)
678
#endif
679
    {
680
        v->s.resync_marker = get_bits(gb, 1);
681
        v->rangered = get_bits(gb, 1);
682
    }
683

    
684
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
685
    v->quantizer_mode = get_bits(gb, 2); //common
686

    
687
#if HAS_ADVANCED_PROFILE
688
    if (v->profile <= PROFILE_MAIN)
689
#endif
690
    {
691
        v->finterpflag = get_bits(gb, 1); //common
692
        v->res_rtm_flag = get_bits(gb, 1); //reserved
693
        if (!v->res_rtm_flag)
694
        {
695
            av_log(avctx, AV_LOG_ERROR,
696
                   "0 for reserved RES_RTM_FLAG is forbidden\n");
697
            //return -1;
698
        }
699
#if TRACE
700
        av_log(avctx, AV_LOG_INFO,
701
               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
702
               "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
703
               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
704
               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
705
               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
706
               v->loopfilter, v->multires, v->fastuvmc, v->extended_mv,
707
               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
708
               v->dquant, v->quantizer_mode, avctx->max_b_frames
709
               );
710
        return 0;
711
#endif
712
    }
713
#if HAS_ADVANCED_PROFILE
714
    else return decode_advanced_sequence_header(avctx, gb);
715
#endif
716
}
717

    
718

    
719
#if HAS_ADVANCED_PROFILE
720
/*****************************************************************************/
721
/* Entry point decoding (Advanced Profile)                                   */
722
/*****************************************************************************/
723
static int advanced_entry_point_process(AVCodecContext *avctx, GetBitContext *gb)
724
{
725
    VC9Context *v = avctx->priv_data;
726
    int range_mapy_flag, range_mapuv_flag, i;
727
    if (v->profile != PROFILE_ADVANCED)
728
    {
729
        av_log(avctx, AV_LOG_ERROR,
730
               "Entry point are only defined in Advanced Profile!\n");
731
        return -1; //Only for advanced profile!
732
    }
733
    if (v->hrd_param_flag)
734
    {
735
        //Update buffer fullness
736
        av_log(avctx, AV_LOG_DEBUG, "Buffer fullness update\n");
737
        for (i=0; i<v->hrd_num_leaky_buckets; i++)
738
            skip_bits(gb, 8);
739
    }
740
    if ((range_mapy_flag = get_bits(gb, 1)))
741
    {
742
        //RANGE_MAPY
743
        av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPY\n");
744
        skip_bits(gb, 3);
745
    }
746
    if ((range_mapuv_flag = get_bits(gb, 1)))
747
    {
748
        //RANGE_MAPUV
749
        av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPUV\n");
750
        skip_bits(gb, 3);
751
    }
752
    if (v->panscanflag)
753
    {
754
        //NUMPANSCANWIN
755
        v->numpanscanwin = get_bits(gb, 3);
756
        av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);
757
    }
758
    return 0;
759
}
760
#endif
761

    
762
/******************************************************************************/
763
/* Bitplane decoding: 8.7, p56                                                */
764
/******************************************************************************/
765
#define IMODE_RAW     0
766
#define IMODE_NORM2   1
767
#define IMODE_DIFF2   2
768
#define IMODE_NORM6   3
769
#define IMODE_DIFF6   4
770
#define IMODE_ROWSKIP 5
771
#define IMODE_COLSKIP 6
772
int alloc_bitplane(BitPlane *bp, int width, int height)
773
{
774
    if (!bp || bp->width<0 || bp->height<0) return -1;
775
    bp->data = (uint8_t*)av_malloc(width*height);
776
    if (!bp->data) return -1;
777
    bp->width = bp->stride = width; //FIXME Needed for aligned data ?
778
    bp->height = height;
779
    return 0;
780
}
781

    
782
void free_bitplane(BitPlane *bp)
783
{
784
    bp->width = bp->stride = bp->height = 0;
785
    if (bp->data) av_freep(&bp->data);
786
}
787

    
788
static void decode_rowskip(uint8_t* plane, int width, int height, int stride, VC9Context *v){
789
    int x, y;
790
    GetBitContext *gb = &v->s.gb;
791

    
792
    for (y=0; y<height; y++){
793
        if (!get_bits(gb, 1)) //rowskip
794
            memset(plane, 0, width);
795
        else
796
            for (x=0; x<width; x++) 
797
                plane[x] = get_bits(gb, 1);
798
        plane += stride;
799
    }
800
}
801

    
802
//FIXME optimize
803
static void decode_colskip(uint8_t* plane, int width, int height, int stride, VC9Context *v){
804
    int x, y;
805
    GetBitContext *gb = &v->s.gb;
806

    
807
    for (x=0; x<width; x++){
808
        if (!get_bits(gb, 1)) //colskip
809
            for (y=0; y<height; y++)
810
                plane[y*stride] = 0;
811
        else
812
            for (y=0; y<height; y++)
813
                plane[y*stride] = get_bits(gb, 1);
814
        plane ++;
815
    }
816
}
817

    
818
//FIXME optimize
819
//FIXME Use BitPlane struct or return if table is raw (no bits read here but
820
//      later on)
821
//Elements must be either 0 or 1
822
static int bitplane_decoding(BitPlane *bp, VC9Context *v)
823
{
824
    GetBitContext *gb = &v->s.gb;
825

    
826
    int imode, x, y, code, use_vertical_tile, tile_w, tile_h;
827
    uint8_t invert, *planep = bp->data;
828

    
829
    invert = get_bits(gb, 1);
830
    imode = get_vlc2(gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);
831

    
832
    bp->is_raw = 0;
833
    switch (imode)
834
    {
835
    case IMODE_RAW:
836
        //Data is actually read in the MB layer (same for all tests == "raw")
837
        bp->is_raw = 1; //invert ignored
838
        return invert;
839
    case IMODE_DIFF2:
840
    case IMODE_NORM2:
841
        if ((bp->height*bp->width) & 1) *(++planep) = get_bits(gb, 1);
842
        for(x=0; x<(bp->height*bp->width)>>1; x++){
843
            code = get_vlc2(gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);
844
            *(++planep) = code&1; //lsb => left
845
            *(++planep) = (code>>1)&1; //msb => right
846
            //FIXME width->stride
847
        }
848
        break;
849
    case IMODE_DIFF6:
850
    case IMODE_NORM6:
851
        use_vertical_tile=  bp->height%3==0 &&  bp->width%3!=0;
852
        tile_w= use_vertical_tile ? 2 : 3;
853
        tile_h= use_vertical_tile ? 3 : 2;
854

    
855
        for(y=  bp->height%tile_h; y< bp->height; y+=tile_h){
856
            for(x=  bp->width%tile_w; x< bp->width; x+=tile_w){
857
#if TILE_VLC_METHOD == 1 //FIXME Too much optimized ?
858
                code = get_vlc2(gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);
859
                if(code<0){
860
                    av_log(v->s.avctx, AV_LOG_DEBUG, "inavlid NORM-6 VLC\n");
861
                    return -1;
862
                }
863
#endif
864
#if TILE_VLC_METHOD == 2 //TODO Optimize VLC decoding
865
                code = get_vlc2(gb, vc9_norm6_first.table, VC9_NORM6_FIRST_BITS, 2);
866
                if (vc9_norm6_mode[code] == 1)
867
                {
868
#  if TRACE
869
                    code = get_bits(gb, 5);
870
                    assert(code>-1 && code<20);
871
                    code = vc9_norm6_flc_val[code];
872
#  else
873
                    code = vc9_norm6_flc_val[get_bits(gb, 5)];
874
#  endif
875
                }
876
                else if (vc9_norm6_mode[code] == 2)
877
                {
878
#  if TRACE
879
                    code = get_vlc2(gb, vc9_norm6_second.table, VC9_NORM6_SECOND_BITS, 2);
880
                    assert(code>-1 && code<22);
881
                    code = vc9_norm6_second_val[code];
882
#  else
883
                    code = vc9_norm6_second_val[get_vlc2(gb, vc9_norm6_second.table, VC9_NORM6_SECOND_BITS, 2)];
884
#  endif
885
#endif //TILE_VLC_METHOD == 2
886
                //FIXME following is a pure guess and probably wrong
887
                //FIXME A bitplane (0 | !0), so could the shifts be avoided ?
888
                planep[x     + 0*bp->stride]= (code>>0)&1;
889
                planep[x + 1 + 0*bp->stride]= (code>>1)&1;
890
                //FIXME Does branch prediction help here?
891
                if(use_vertical_tile){
892
                    planep[x + 0 + 1*bp->stride]= (code>>2)&1;
893
                    planep[x + 1 + 1*bp->stride]= (code>>3)&1;
894
                    planep[x + 0 + 2*bp->stride]= (code>>4)&1;
895
                    planep[x + 1 + 2*bp->stride]= (code>>5)&1;
896
                }else{
897
                    planep[x + 2 + 0*bp->stride]= (code>>2)&1;
898
                    planep[x + 0 + 1*bp->stride]= (code>>3)&1;
899
                    planep[x + 1 + 1*bp->stride]= (code>>4)&1;
900
                    planep[x + 2 + 1*bp->stride]= (code>>5)&1;
901
                }
902
            }
903
        }
904

    
905
        x=  bp->width % tile_w;
906
        decode_colskip(bp->data  ,             x, bp->height         , bp->stride, v);
907
        decode_rowskip(bp->data+x, bp->width - x, bp->height % tile_h, bp->stride, v);
908

    
909
        break;
910
    case IMODE_ROWSKIP:
911
        decode_rowskip(bp->data, bp->width, bp->height, bp->stride, v);
912
        break;
913
    case IMODE_COLSKIP: //Teh ugly
914
        decode_colskip(bp->data, bp->width, bp->height, bp->stride, v);
915
        break;
916
    default: break;
917
    }
918

    
919
    /* Applying diff operator */
920
    if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
921
    {
922
        planep = bp->data;
923
        planep[0] ^= invert;
924
        for (x=1; x<bp->width; x++)
925
            planep[x] ^= planep[x-1];
926
        for (y=1; y<bp->height; y++)
927
        {
928
            planep += bp->stride;
929
            planep[0] ^= planep[-bp->stride];
930
            for (x=1; x<bp->width; x++)
931
            {
932
                if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
933
                else                                     planep[x] ^= planep[x-1];
934
            }
935
        }
936
    }
937
    else if (invert)
938
    {
939
        planep = bp->data;
940
        for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
941
    }
942
    return (imode<<1) + invert;
943
}
944

    
945
/*****************************************************************************/
946
/* VOP Dquant decoding                                                       */
947
/*****************************************************************************/
948
static int vop_dquant_decoding(VC9Context *v)
949
{
950
    GetBitContext *gb = &v->s.gb;
951
    int pqdiff;
952

    
953
    //variable size
954
    if (v->dquant == 2)
955
    {
956
        pqdiff = get_bits(gb, 3);
957
        if (pqdiff == 7) v->altpq = get_bits(gb, 5);
958
        else v->altpq = v->pq + pqdiff + 1;
959
    }
960
    else
961
    {
962
        v->dquantfrm = get_bits(gb, 1);
963
        if ( v->dquantfrm )
964
        {
965
            v->dqprofile = get_bits(gb, 2);
966
            switch (v->dqprofile)
967
            {
968
            case DQPROFILE_SINGLE_EDGE:
969
            case DQPROFILE_DOUBLE_EDGES:
970
                v->dqsbedge = get_bits(gb, 2);
971
                break;
972
            case DQPROFILE_ALL_MBS:
973
                v->dqbilevel = get_bits(gb, 1);
974
            default: break; //Forbidden ?
975
            }
976
            if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
977
            {
978
                pqdiff = get_bits(gb, 3);
979
                if (pqdiff == 7) v->altpq = get_bits(gb, 5);
980
                else v->altpq = v->pq + pqdiff + 1;
981
            }
982
        }
983
    }
984
    return 0;
985
}
986

    
987
/*****************************************************************************/
988
/* All Profiles picture header decoding specific functions                   */
989
/* Only pro/epilog differs between Simple/Main and Advanced => check caller  */
990
/*****************************************************************************/
991

    
992
/* Tables 11+12, p62-65 */
993
static int decode_b_picture_primary_header(VC9Context *v)
994
{
995
    GetBitContext *gb = &v->s.gb;
996
    int pqindex, status;
997

    
998
    /* Prolog common to all frametypes should be done in caller */
999
    if (v->profile == PROFILE_SIMPLE)
1000
    {
1001
        av_log(v->s.avctx, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");
1002
        return FRAME_SKIPED;
1003
    }
1004

    
1005
    v->bfraction = vc9_bfraction_lut[get_vlc2(gb, vc9_bfraction_vlc.table,
1006
                                              VC9_BFRACTION_VLC_BITS, 2)];
1007
    if (v->bfraction < -1)
1008
    {
1009
        av_log(v->s.avctx, AV_LOG_ERROR, "Invalid BFRaction\n");
1010
        return FRAME_SKIPED;
1011
    }
1012
    else if (!v->bfraction)
1013
    {
1014
        /* We actually have a BI frame */
1015
        v->s.pict_type = BI_TYPE;
1016
        v->buffer_fullness = get_bits(gb, 7);
1017
    }
1018

    
1019
    /* Read the quantization stuff */
1020
    pqindex = get_bits(gb, 5);
1021
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1022
        v->pq = pquant_table[0][pqindex];
1023
    else
1024
    {
1025
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1026
    }
1027
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1028
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1029
        v->pquantizer = get_bits(gb, 1);
1030

    
1031
    /* Read the MV type/mode */
1032
    if (v->extended_mv == 1)
1033
        v->mvrange = get_prefix(gb, 0, 3);
1034
    if (v->s.pict_type != BI_TYPE)
1035
    {
1036
        v->mv_mode = get_bits(gb, 1);
1037
        if (v->pq < 13)
1038
        {
1039
            if (!v->mv_mode)
1040
            {
1041
                v->mv_mode = get_bits(gb, 2);
1042
                if (v->mv_mode)
1043
                av_log(v->s.avctx, AV_LOG_ERROR,
1044
                       "mv_mode for lowquant B frame was %i\n", v->mv_mode);
1045
            }
1046
        }
1047
        else
1048
        {
1049
            if (!v->mv_mode)
1050
            {
1051
                if (get_bits(gb, 1))
1052
                     av_log(v->s.avctx, AV_LOG_ERROR,
1053
                            "mv_mode for highquant B frame was %i\n", v->mv_mode);
1054
            }
1055
            v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping
1056
        }
1057
    }
1058

    
1059
    return 0;
1060
}
1061

    
1062
static int decode_b_picture_secondary_header(VC9Context *v)
1063
{
1064
    GetBitContext *gb = &v->s.gb;
1065
    int status;
1066

    
1067
    bitplane_decoding(&v->skip_mb_plane, v);
1068
    if (status < 0) return -1;
1069
#if TRACE
1070
    if (v->mv_mode == MV_PMODE_MIXED_MV)
1071
    {
1072
        status = bitplane_decoding(&v->mv_type_mb_plane, v);
1073
        if (status < 0)
1074
            return -1;
1075
#if TRACE
1076
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1077
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1078
#endif
1079
    }
1080

    
1081
    //bitplane
1082
    status = bitplane_decoding(&v->direct_mb_plane, v);
1083
    if (status < 0) return -1;
1084
#if TRACE
1085
    av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "
1086
           "Imode: %i, Invert: %i\n", status>>1, status&1);
1087
#endif
1088

    
1089
    av_log(v->s.avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "
1090
           "Imode: %i, Invert: %i\n", status>>1, status&1);
1091
#endif
1092

    
1093
    /* FIXME: what is actually chosen for B frames ? */
1094
    v->s.mv_table_index = get_bits(gb, 2); //but using vc9_ tables
1095
    v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(gb, 2)];
1096

    
1097
    if (v->dquant)
1098
    {
1099
        vop_dquant_decoding(v);
1100
    }
1101

    
1102
    if (v->vstransform)
1103
    {
1104
        v->ttmbf = get_bits(gb, 1);
1105
        if (v->ttmbf)
1106
        {
1107
            v->ttfrm = get_bits(gb, 2);
1108
            av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1109
                   (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1110
        }
1111
    }
1112
    /* Epilog (AC/DC syntax) should be done in caller */
1113
    return 0;
1114
}
1115

    
1116
/* Tables 5+7, p53-54 and 55-57 */
1117
static int decode_i_picture_header(VC9Context *v)
1118
{
1119
    GetBitContext *gb = &v->s.gb;
1120
    int pqindex, status = 0;
1121

    
1122
    /* Prolog common to all frametypes should be done in caller */
1123
    //BF = Buffer Fullness
1124
    if (v->profile <= PROFILE_MAIN && get_bits(gb, 7))
1125
    {
1126
        av_log(v->s.avctx, AV_LOG_DEBUG, "I BufferFullness not 0\n");
1127
    }
1128

    
1129
    /* Quantizer stuff */
1130
    pqindex = get_bits(gb, 5);
1131
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1132
        v->pq = pquant_table[0][pqindex];
1133
    else
1134
    {
1135
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1136
    }
1137
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1138
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1139
        v->pquantizer = get_bits(gb, 1);
1140
    av_log(v->s.avctx, AV_LOG_DEBUG, "I frame: QP=%i (+%i/2)\n",
1141
           v->pq, v->halfpq);
1142
#if HAS_ADVANCED_PROFILE
1143
    if (v->profile <= PROFILE_MAIN)
1144
#endif
1145
    {
1146
        if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1147
        if (v->multires) v->respic = get_bits(gb, 2);
1148
    }
1149
#if HAS_ADVANCED_PROFILE
1150
    else
1151
    {
1152
        v->s.ac_pred = get_bits(gb, 1);
1153
        if (v->postprocflag) v->postproc = get_bits(gb, 1);
1154
        /* 7.1.1.34 + 8.5.2 */
1155
        if (v->overlap && v->pq<9)
1156
        {
1157
            v->condover = get_bits(gb, 1);
1158
            if (v->condover)
1159
            {
1160
                v->condover = 2+get_bits(gb, 1);
1161
                if (v->condover == 3)
1162
                {
1163
                    status = bitplane_decoding(&v->over_flags_plane, v);
1164
                    if (status < 0) return -1;
1165
#if TRACE
1166
                    av_log(v->s.avctx, AV_LOG_DEBUG, "Overflags plane encoding: "
1167
                           "Imode: %i, Invert: %i\n", status>>1, status&1);
1168
#endif
1169
                }
1170
            }
1171
        }
1172
    }
1173
#endif
1174

    
1175
    /* Epilog (AC/DC syntax) should be done in caller */
1176
    return status;
1177
}
1178

    
1179
/* Table 9, p58-60 */
1180
static int decode_p_picture_primary_header(VC9Context *v)
1181
{
1182
    /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */
1183
    GetBitContext *gb = &v->s.gb;
1184
    int lowquant, pqindex, status = 0;
1185

    
1186
    pqindex = get_bits(gb, 5);
1187
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1188
        v->pq = pquant_table[0][pqindex];
1189
    else
1190
    {
1191
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1192
    }
1193
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1194
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1195
        v->pquantizer = get_bits(gb, 1);
1196
    av_log(v->s.avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",
1197
           v->pq, v->halfpq);
1198
    if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1199
#if HAS_ADVANCED_PROFILE
1200
    if (v->profile > PROFILE_MAIN)
1201
    {
1202
        if (v->postprocflag) v->postproc = get_bits(gb, 1);
1203
    }
1204
    else
1205
#endif
1206
        if (v->multires) v->respic = get_bits(gb, 2);
1207
    lowquant = (v->pquantizer>12) ? 0 : 1;
1208
    v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1209
    if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1210
    {
1211
        v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
1212
        v->lumscale = get_bits(gb, 6);
1213
        v->lumshift = get_bits(gb, 6);
1214
    }
1215
    return 0;
1216
}
1217

    
1218
static int decode_p_picture_secondary_header(VC9Context *v)
1219
{
1220
    GetBitContext *gb = &v->s.gb;
1221
    int status = 0;
1222
    if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1223
         v->mv_mode2 == MV_PMODE_MIXED_MV)
1224
        || v->mv_mode == MV_PMODE_MIXED_MV)
1225
    {
1226
        status = bitplane_decoding(&v->mv_type_mb_plane, v);
1227
        if (status < 0) return -1;
1228
#if TRACE
1229
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1230
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1231
#endif
1232
    }
1233

    
1234
    status = bitplane_decoding(&v->skip_mb_plane, v);
1235
    if (status < 0) return -1;
1236
#if TRACE
1237
    av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1238
           "Imode: %i, Invert: %i\n", status>>1, status&1);
1239
#endif
1240

    
1241
    /* Hopefully this is correct for P frames */
1242
    v->s.mv_table_index =get_bits(gb, 2); //but using vc9_ tables
1243
    v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(gb, 2)];
1244

    
1245
    if (v->dquant)
1246
    {
1247
        av_log(v->s.avctx, AV_LOG_INFO, "VOP DQuant info\n");
1248
        vop_dquant_decoding(v);
1249
    }
1250

    
1251
    v->ttfrm = 0; //FIXME Is that so ?
1252
    if (v->vstransform)
1253
    {
1254
        v->ttmbf = get_bits(gb, 1);
1255
        if (v->ttmbf)
1256
        {
1257
            v->ttfrm = get_bits(gb, 2);
1258
            av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1259
                   (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1260
        }
1261
    }
1262
    /* Epilog (AC/DC syntax) should be done in caller */
1263
    return 0;
1264
}
1265

    
1266

    
1267
static int standard_decode_picture_primary_header(VC9Context *v)
1268
{
1269
    GetBitContext *gb = &v->s.gb;
1270
    int status = 0;
1271

    
1272
    if (v->finterpflag) v->interpfrm = get_bits(gb, 1);
1273
    skip_bits(gb, 2); //framecnt unused
1274
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1275
    v->s.pict_type = get_bits(gb, 1);
1276
    if (v->s.avctx->max_b_frames)
1277
    {
1278
        if (!v->s.pict_type)
1279
        {
1280
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1281
            else v->s.pict_type = B_TYPE;
1282
        }
1283
        else v->s.pict_type = P_TYPE;
1284
    }
1285
    else v->s.pict_type++;
1286

    
1287
    switch (v->s.pict_type)
1288
    {
1289
    case I_TYPE: status = decode_i_picture_header(v); break;
1290
    case P_TYPE: status = decode_p_picture_primary_header(v); break;
1291
    case BI_TYPE:
1292
    case B_TYPE: status = decode_b_picture_primary_header(v); break;
1293
    }
1294

    
1295
    if (status == FRAME_SKIPED)
1296
    {
1297
      av_log(v->s.avctx, AV_LOG_INFO, "Skipping frame...\n");
1298
      return status;
1299
    }
1300
    return 0;
1301
}
1302

    
1303
static int standard_decode_picture_secondary_header(VC9Context *v)
1304
{
1305
    GetBitContext *gb = &v->s.gb;
1306
    int status = 0, index;
1307

    
1308
    switch (v->s.pict_type)
1309
    {
1310
    case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1311
    case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1312
    }
1313

    
1314
    /* AC Syntax */
1315
    v->ac_table_level = decode012(gb);
1316
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1317
    {
1318
        index = decode012(gb);
1319
        v->luma_ac2_vlc = NULL + index; //FIXME Add AC2 table
1320
        v->chroma_ac2_vlc = NULL + index;
1321
    }
1322
    /* DC Syntax */
1323
    index = decode012(gb);
1324
    v->luma_dc_vlc = &ff_msmp4_dc_luma_vlc[index];
1325
    v->chroma_dc_vlc = &ff_msmp4_dc_chroma_vlc[index];
1326
   
1327
    return 0;
1328
}
1329

    
1330

    
1331
#if HAS_ADVANCED_PROFILE
1332
/******************************************************************************/
1333
/* Advanced Profile picture header decoding specific functions                */
1334
/******************************************************************************/
1335
static int advanced_decode_picture_primary_header(VC9Context *v)
1336
{
1337
    GetBitContext *gb = &v->s.gb;
1338
    static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };
1339
    int type, i;
1340

    
1341
    if (v->interlace)
1342
    {
1343
        v->fcm = get_bits(gb, 1);
1344
        if (v->fcm) v->fcm = 2+get_bits(gb, 1);
1345
    }
1346

    
1347
    type = get_prefix(gb, 0, 4);
1348
    if (type > 4 || type < 0) return FRAME_SKIPED;
1349
    v->s.pict_type = type_table[type];
1350
    av_log(v->s.avctx, AV_LOG_INFO, "AP Frame Type: %i\n", v->s.pict_type);
1351

    
1352
    if (v->tfcntrflag) v->tfcntr = get_bits(gb, 8);
1353
    if (v->broadcast)
1354
    {
1355
        if (!v->interlace) v->rptfrm = get_bits(gb, 2);
1356
        else
1357
        {
1358
            v->tff = get_bits(gb, 1);
1359
            v->rff = get_bits(gb, 1);
1360
        }
1361
    }
1362

    
1363
    if (v->panscanflag)
1364
    {
1365
#if 0
1366
        for (i=0; i<v->numpanscanwin; i++)
1367
        {
1368
            v->topleftx[i] = get_bits(gb, 16);
1369
            v->toplefty[i] = get_bits(gb, 16);
1370
            v->bottomrightx[i] = get_bits(gb, 16);
1371
            v->bottomrighty[i] = get_bits(gb, 16);
1372
        }
1373
#else
1374
        skip_bits(gb, 16*4*v->numpanscanwin);
1375
#endif
1376
    }
1377
    v->s.no_rounding = !get_bits(gb, 1);
1378
    v->uvsamp = get_bits(gb, 1);
1379
    if (v->finterpflag == 1) v->interpfrm = get_bits(gb, 1);
1380

    
1381
    switch(v->s.pict_type)
1382
    {
1383
    case I_TYPE: if (decode_i_picture_header(v) < 0) return -1;
1384
    case P_TYPE: if (decode_p_picture_primary_header(v) < 0) return -1;
1385
    case BI_TYPE:
1386
    case B_TYPE: if (decode_b_picture_primary_header(v) < 0) return FRAME_SKIPED;
1387
    default: break;
1388
    }
1389
    return 0;
1390
}
1391

    
1392
static int advanced_decode_picture_secondary_header(VC9Context *v)
1393
{
1394
    GetBitContext *gb = &v->s.gb;
1395
    int index;
1396

    
1397
    switch(v->s.pict_type)
1398
    {
1399
    case P_TYPE: if (decode_p_picture_secondary_header(v) < 0) return -1;
1400
    case B_TYPE: if (decode_b_picture_secondary_header(v) < 0) return FRAME_SKIPED;
1401
    default: break;
1402
    }
1403

    
1404
    /* AC Syntax */
1405
    v->ac_table_level = decode012(gb);
1406
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1407
    {
1408
        index = decode012(gb); //FIXME
1409
        v->luma_ac2_vlc = NULL + index;
1410
        v->chroma_ac2_vlc = NULL + index;
1411
    }
1412
    /* DC Syntax */
1413
    index = decode012(gb);
1414
    v->luma_dc_vlc = &ff_msmp4_dc_luma_vlc[index];
1415
    v->chroma_dc_vlc = &ff_msmp4_dc_chroma_vlc[index];
1416

    
1417
    return 0;
1418
}
1419
#endif
1420

    
1421
/******************************************************************************/
1422
/* Block decoding functions                                                   */
1423
/******************************************************************************/
1424
/* 7.1.4, p91 and 8.1.1.7, p(1)04 */
1425
/* FIXME proper integration (unusable and lots of parameters to send */
1426
int decode_luma_intra_block(VC9Context *v, int mquant)
1427
{
1428
    GetBitContext *gb = &v->s.gb;
1429
    int dcdiff;
1430

    
1431
    dcdiff = get_vlc2(gb, v->luma_dc_vlc->table,
1432
                      DC_VLC_BITS, 2);
1433
    if (dcdiff)
1434
    {
1435
        if (dcdiff == 119 /* ESC index value */)
1436
        {
1437
            /* TODO: Optimize */
1438
            if (mquant == 1) dcdiff = get_bits(gb, 10);
1439
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
1440
            else dcdiff = get_bits(gb, 8);
1441
        }
1442
        else
1443
        {
1444
            if (mquant == 1)
1445
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1446
            else if (mquant == 2)
1447
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1448
        }
1449
        if (get_bits(gb, 1))
1450
            dcdiff = -dcdiff;
1451
    }
1452
    /* FIXME: 8.1.1.15, p(1)13, coeff scaling for Adv Profile */
1453

    
1454
    return 0;
1455
}
1456

    
1457
/******************************************************************************/
1458
/* MacroBlock decoding functions                                              */
1459
/******************************************************************************/
1460
/* 8.1.1.5, p(1)02-(1)03 */
1461
/* We only need to store 3 flags, but math with 4 is easier */
1462
#define GET_CBPCY(table, bits)                                      \
1463
    predicted_cbpcy = get_vlc2(gb, table, bits, 2);             \
1464
    cbpcy[0] = (p_cbpcy[-1] == p_cbpcy[2])                          \
1465
         ? previous_cbpcy[1] : p_cbpcy[+2];                         \
1466
    cbpcy[0] ^= ((predicted_cbpcy>>5)&0x01);                        \
1467
    cbpcy[1] = (p_cbpcy[2] == p_cbpcy[3]) ? cbpcy[0] : p_cbpcy[3];  \
1468
    cbpcy[1] ^= ((predicted_cbpcy>>4)&0x01);                        \
1469
    cbpcy[2] = (previous_cbpcy[1] == cbpcy[0])                      \
1470
         ? previous_cbpcy[3] : cbpcy[0];                            \
1471
    cbpcy[2] ^= ((predicted_cbpcy>>3)&0x01);                        \
1472
    cbpcy[3] = (cbpcy[1] == cbpcy[0]) ? cbpcy[2] : cbpcy[1];        \
1473
    cbpcy[3] ^= ((predicted_cbpcy>>2)&0x01);
1474
     
1475
/* 8.1, p100 */
1476
static int standard_decode_i_mbs(VC9Context *v)
1477
{
1478
    GetBitContext *gb = &v->s.gb;
1479
    MpegEncContext *s = &v->s;
1480
    int current_mb = 0; /* MB/Block Position info */
1481
    /* FIXME: better to use a pointer than using (x<<4) */
1482
    uint8_t cbpcy[4], previous_cbpcy[4], predicted_cbpcy,
1483
        *p_cbpcy /* Pointer to skip some math */;
1484

    
1485
    /* Reset CBPCY predictors */
1486
    memset(v->previous_line_cbpcy, 0, s->mb_stride<<2);
1487

    
1488
    /* Select ttmb table depending on pq */
1489
    if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];
1490
    else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];
1491
    else v->ttmb_vlc = &vc9_ttmb_vlc[2];
1492

    
1493
    for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
1494
    {
1495
        /* Init CBPCY for line */
1496
        *((uint32_t*)previous_cbpcy) = 0x00000000;
1497
        p_cbpcy = v->previous_line_cbpcy+4;
1498

    
1499
        for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++, p_cbpcy += 4)
1500
        {
1501
            /* Get CBPCY */
1502
            GET_CBPCY(ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS);
1503

    
1504
            s->ac_pred = get_bits(gb, 1);
1505

    
1506
            /* TODO: Decode blocks from that mb wrt cbpcy */
1507

    
1508
            /* Update for next block */
1509
#if TRACE > 2
1510
            av_log(s->avctx, AV_LOG_DEBUG, "Block %4i: p_cbpcy=%i%i%i%i, previous_cbpcy=%i%i%i%i,"
1511
                   " cbpcy=%i%i%i%i\n", current_mb,
1512
                   p_cbpcy[0], p_cbpcy[1], p_cbpcy[2], p_cbpcy[3],
1513
                   previous_cbpcy[0], previous_cbpcy[1], previous_cbpcy[2], previous_cbpcy[3],
1514
                   cbpcy[0], cbpcy[1], cbpcy[2], cbpcy[3]);
1515
#endif
1516
            *((uint32_t*)p_cbpcy) = *((uint32_t*)previous_cbpcy);
1517
            *((uint32_t*)previous_cbpcy) = *((uint32_t*)cbpcy);
1518
            current_mb++;
1519
        }
1520
    }
1521
    return 0;
1522
}
1523

    
1524
#define GET_MQUANT()                                           \
1525
  if (v->dquantfrm)                                            \
1526
  {                                                            \
1527
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1528
    {                                                          \
1529
      if (v->dqbilevel)                                        \
1530
      {                                                        \
1531
        mquant = (get_bits(gb, 1)) ? v->pq : v->altpq;         \
1532
      }                                                        \
1533
      else                                                     \
1534
      {                                                        \
1535
        mqdiff = get_bits(gb, 3);                              \
1536
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1537
        else mquant = get_bits(gb, 5);                         \
1538
      }                                                        \
1539
    }                                                          \
1540
  }
1541

    
1542
/* MVDATA decoding from 8.3.5.2, p(1)20 */
1543
#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1544
  index = 1 + get_vlc2(gb, vc9_mv_diff_vlc[s->mv_table_index].table,\
1545
                       VC9_MV_DIFF_VLC_BITS, 2);                    \
1546
  if (index > 36)                                                   \
1547
  {                                                                 \
1548
    mb_has_coeffs = 1;                                              \
1549
    index -= 37;                                                    \
1550
  }                                                                 \
1551
  else mb_has_coeffs = 0;                                           \
1552
  s->mb_intra = 0;                                                  \
1553
  if (!index) { _dmv_x = _dmv_y = 0; }                              \
1554
  else if (index == 35)                                             \
1555
  {                                                                 \
1556
    _dmv_x = get_bits(gb, k_x);                                 \
1557
    _dmv_y = get_bits(gb, k_y);                                 \
1558
    s->mb_intra = 1;                                                \
1559
  }                                                                 \
1560
  else                                                              \
1561
  {                                                                 \
1562
    index1 = index%6;                                               \
1563
    if (hpel_flag && index1 == 5) val = 1;                          \
1564
    else                          val = 0;                          \
1565
    val = get_bits(gb, size_table[index1] - val);               \
1566
    sign = 0 - (val&1);                                             \
1567
    _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1568
                                                                    \
1569
    index1 = index/6;                                               \
1570
    if (hpel_flag && index1 == 5) val = 1;                          \
1571
    else                          val = 0;                          \
1572
    val = get_bits(gb, size_table[index1] - val);               \
1573
    sign = 0 - (val&1);                                             \
1574
    _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1575
  }
1576

    
1577
/* 8.1, p(1)15 */
1578
static int decode_p_mbs(VC9Context *v)
1579
{
1580
    MpegEncContext *s = &v->s;
1581
    GetBitContext *gb = &v->s.gb;
1582
    int current_mb = 0, i; /* MB/Block Position info */
1583
    uint8_t cbpcy[4], previous_cbpcy[4], predicted_cbpcy,
1584
        *p_cbpcy /* Pointer to skip some math */;
1585
    int hybrid_pred; /* Prediction types */
1586
    int mv_mode_bit = 0; 
1587
    int mqdiff, mquant; /* MB quantization */
1588
    int ttmb; /* MB Transform type */
1589

    
1590
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
1591
        offset_table[6] = { 0, 1, 3, 7, 15, 31 };
1592
        int mb_has_coeffs = 1; /* last_flag */
1593
    int dmv_x, dmv_y; /* Differential MV components */
1594
    int k_x, k_y; /* Long MV fixed bitlength */
1595
    int hpel_flag; /* Some MB properties */
1596
    int index, index1; /* LUT indices */
1597
    int val, sign; /* MVDATA temp values */
1598

    
1599
    /* Select ttmb table depending on pq */
1600
    if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];
1601
    else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];
1602
    else v->ttmb_vlc = &vc9_ttmb_vlc[2];
1603

    
1604
    /* Select proper long MV range */
1605
    switch (v->mvrange)
1606
    {
1607
    case 1: k_x = 10; k_y = 9; break;
1608
    case 2: k_x = 12; k_y = 10; break;
1609
    case 3: k_x = 13; k_y = 11; break;
1610
    default: /*case 0 too */ k_x = 9; k_y = 8; break;
1611
    }
1612

    
1613
    hpel_flag = v->mv_mode & 1; //MV_PMODE is HPEL
1614
    k_x -= hpel_flag;
1615
    k_y -= hpel_flag;
1616

    
1617
    /* Reset CBPCY predictors */
1618
    memset(v->previous_line_cbpcy, 0, s->mb_stride<<2);
1619

    
1620
    for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
1621
    {
1622
        /* Init CBPCY for line */
1623
        *((uint32_t*)previous_cbpcy) = 0x00000000;
1624
        p_cbpcy = v->previous_line_cbpcy+4;
1625

    
1626
        for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++, p_cbpcy += 4)
1627
        {
1628
            if (v->mv_type_mb_plane.is_raw)
1629
                v->mv_type_mb_plane.data[current_mb] = get_bits(gb, 1);
1630
            if (v->skip_mb_plane.is_raw)
1631
                v->skip_mb_plane.data[current_mb] = get_bits(gb, 1);
1632
            if (!mv_mode_bit) /* 1MV mode */
1633
            {
1634
                if (!v->skip_mb_plane.data[current_mb])
1635
                {
1636
                    GET_MVDATA(dmv_x, dmv_y);
1637

    
1638
                    /* hybrid mv pred, 8.3.5.3.4 */
1639
                    if (v->mv_mode == MV_PMODE_1MV ||
1640
                        v->mv_mode == MV_PMODE_MIXED_MV)
1641
                        hybrid_pred = get_bits(gb, 1);
1642
                    if (s->mb_intra && !mb_has_coeffs)
1643
                    {
1644
                        GET_MQUANT();
1645
                        s->ac_pred = get_bits(gb, 1);
1646
                    }
1647
                    else if (mb_has_coeffs)
1648
                    {
1649
                        if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
1650
                        predicted_cbpcy = get_vlc2(gb, v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS, 2);
1651
                        cbpcy[0] = (p_cbpcy[-1] == p_cbpcy[2]) ? previous_cbpcy[1] : p_cbpcy[2];
1652
                        cbpcy[0] ^= ((predicted_cbpcy>>5)&0x01);
1653
                        cbpcy[1] = (p_cbpcy[2] == p_cbpcy[3]) ? cbpcy[0] : p_cbpcy[3];
1654
                        cbpcy[1] ^= ((predicted_cbpcy>>4)&0x01);
1655
                        cbpcy[2] = (previous_cbpcy[1] == cbpcy[0]) ? previous_cbpcy[3] : cbpcy[0];
1656
                        cbpcy[2] ^= ((predicted_cbpcy>>3)&0x01);
1657
                        cbpcy[3] = (cbpcy[1] == cbpcy[0]) ? cbpcy[2] : cbpcy[1];
1658
                        cbpcy[3] ^= ((predicted_cbpcy>>2)&0x01);
1659
                        //GET_CBPCY(v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS);
1660

    
1661
                        GET_MQUANT();
1662
                    }
1663
                    if (!v->ttmbf)
1664
                        ttmb = get_vlc2(gb, v->ttmb_vlc->table,
1665
                                            VC9_TTMB_VLC_BITS, 12);
1666
                    /* TODO: decode blocks from that mb wrt cbpcy */
1667
                }
1668
                else //Skipped
1669
                {
1670
                    /* hybrid mv pred, 8.3.5.3.4 */
1671
                    if (v->mv_mode == MV_PMODE_1MV ||
1672
                        v->mv_mode == MV_PMODE_MIXED_MV)
1673
                        hybrid_pred = get_bits(gb, 1);
1674
                }
1675
            } //1MV mode
1676
            else //4MV mode
1677
            {
1678
              if (!v->skip_mb_plane.data[current_mb] /* unskipped MB */)
1679
                {
1680
                    /* Get CBPCY */
1681
                    GET_CBPCY(v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS);
1682
                    for (i=0; i<4; i++) //For all 4 Y blocks
1683
                    {
1684
                        if (cbpcy[i] /* cbpcy set for this block */)
1685
                        {
1686
                            GET_MVDATA(dmv_x, dmv_y);
1687
                        }
1688
                        if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
1689
                            hybrid_pred = get_bits(gb, 1);
1690
                        GET_MQUANT();
1691
                        if (s->mb_intra /* One of the 4 blocks is intra */ &&
1692
                            index /* non-zero pred for that block */)
1693
                            s->ac_pred = get_bits(gb, 1);
1694
                        if (!v->ttmbf)
1695
                            ttmb = get_vlc2(gb, v->ttmb_vlc->table,
1696
                                            VC9_TTMB_VLC_BITS, 12);
1697
            
1698
                        /* TODO: Process blocks wrt cbpcy */
1699
            
1700
                    }
1701
                }
1702
                else //Skipped MB
1703
                {
1704
                    for (i=0; i<4; i++) //All 4 Y blocks
1705
                    {
1706
                        if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
1707
                            hybrid_pred = get_bits(gb, 1);
1708
                        
1709
                        /* TODO: do something */
1710
                    }
1711
                }
1712
            }
1713

    
1714
            /* Update for next block */
1715
#if TRACE > 2
1716
            av_log(s->avctx, AV_LOG_DEBUG, "Block %4i: p_cbpcy=%i%i%i%i, previous_cbpcy=%i%i%i%i,"
1717
                   " cbpcy=%i%i%i%i\n", current_mb,
1718
                   p_cbpcy[0], p_cbpcy[1], p_cbpcy[2], p_cbpcy[3],
1719
                   previous_cbpcy[0], previous_cbpcy[1], previous_cbpcy[2], previous_cbpcy[3],
1720
                   cbpcy[0], cbpcy[1], cbpcy[2], cbpcy[3]);
1721
#endif
1722
            *((uint32_t*)p_cbpcy) = *((uint32_t*)previous_cbpcy);
1723
            *((uint32_t*)previous_cbpcy) = *((uint32_t*)cbpcy);
1724
            current_mb++;
1725
        }
1726
    }
1727
    return 0;
1728
}
1729

    
1730
static int decode_b_mbs(VC9Context *v)
1731
{
1732
    MpegEncContext *s = &v->s;
1733
    GetBitContext *gb = &v->s.gb;
1734
    int current_mb = 0, i /* MB / B postion information */;
1735
    int b_mv_type = BMV_TYPE_BACKWARD;
1736
    int mquant, mqdiff; /* MB quant stuff */
1737
    int ttmb; /* MacroBlock transform type */
1738
    
1739
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
1740
        offset_table[6] = { 0, 1, 3, 7, 15, 31 };
1741
    int mb_has_coeffs = 1; /* last_flag */
1742
    int dmv1_x, dmv1_y, dmv2_x, dmv2_y; /* Differential MV components */
1743
    int k_x, k_y; /* Long MV fixed bitlength */
1744
    int hpel_flag; /* Some MB properties */
1745
    int index, index1; /* LUT indices */
1746
    int val, sign; /* MVDATA temp values */
1747
    
1748
    /* Select proper long MV range */
1749
    switch (v->mvrange)
1750
    {
1751
    case 1: k_x = 10; k_y = 9; break;
1752
    case 2: k_x = 12; k_y = 10; break;
1753
    case 3: k_x = 13; k_y = 11; break;
1754
    default: /*case 0 too */ k_x = 9; k_y = 8; break;
1755
    }
1756
    hpel_flag = v->mv_mode & 1; //MV_PMODE is HPEL
1757
    k_x -= hpel_flag;
1758
    k_y -= hpel_flag;
1759

    
1760
    /* Select ttmb table depending on pq */
1761
    if (v->pq < 5) v->ttmb_vlc = &vc9_ttmb_vlc[0];
1762
    else if (v->pq < 13) v->ttmb_vlc = &vc9_ttmb_vlc[1];
1763
    else v->ttmb_vlc = &vc9_ttmb_vlc[2];
1764

    
1765
    for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
1766
    {
1767
        for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
1768
        {
1769
            if (v->direct_mb_plane.is_raw)
1770
                v->direct_mb_plane.data[current_mb] = get_bits(gb, 1);
1771
            if (v->skip_mb_plane.is_raw)
1772
                v->skip_mb_plane.data[current_mb] = get_bits(gb, 1);
1773
            
1774
            if (!v->direct_mb_plane.data[current_mb])
1775
            {
1776
                if (v->skip_mb_plane.data[current_mb])
1777
                {
1778
                    b_mv_type = decode012(gb);
1779
                    if (v->bfraction > 420 /*1/2*/ &&
1780
                        b_mv_type < 3) b_mv_type = 1-b_mv_type;
1781
                }
1782
                else
1783
                { 
1784
                    /* FIXME getting tired commenting */
1785
                    GET_MVDATA(dmv1_x, dmv1_y);
1786
                    if (!s->mb_intra /* b_mv1 tells not intra */)
1787
                    {
1788
                        /* FIXME: actually read it */
1789
                        b_mv_type = decode012(gb);
1790
                        if (v->bfraction > 420 /*1/2*/ &&
1791
                            b_mv_type < 3) b_mv_type = 1-b_mv_type;
1792
                    }
1793
                }
1794
            }
1795
            if (!v->skip_mb_plane.data[current_mb])
1796
            {
1797
                if (mb_has_coeffs /* BMV1 == "last" */)
1798
                {
1799
                    GET_MQUANT();
1800
                    if (s->mb_intra /* intra mb */)
1801
                        s->ac_pred = get_bits(gb, 1);
1802
                }
1803
                else
1804
                {
1805
                    /* if bmv1 tells MVs are interpolated */
1806
                    if (b_mv_type == BMV_TYPE_INTERPOLATED)
1807
                    {
1808
                        GET_MVDATA(dmv2_x, dmv2_y);
1809
                    }
1810
                    /* GET_MVDATA has reset some stuff */
1811
                    if (mb_has_coeffs /* b_mv2 == "last" */)
1812
                    {
1813
                        if (s->mb_intra /* intra_mb */)
1814
                            s->ac_pred = get_bits(gb, 1);
1815
                        GET_MQUANT();
1816
                    }
1817
                }
1818
            }
1819
            //End1
1820
            if (v->ttmbf)
1821
                ttmb = get_vlc2(gb, v->ttmb_vlc->table,
1822
                                   VC9_TTMB_VLC_BITS, 12);
1823

    
1824
            //End2
1825
            for (i=0; i<6; i++)
1826
            {
1827
                /* FIXME: process the block */
1828
            }
1829

    
1830
            current_mb++;
1831
        }
1832
    }
1833
    return 0;
1834
}
1835

    
1836
#if HAS_ADVANCED_PROFILE
1837
static int advanced_decode_i_mbs(VC9Context *v)
1838
{
1839
    MpegEncContext *s = &v->s;
1840
    GetBitContext *gb = &v->s.gb;
1841
    int mqdiff, mquant, current_mb = 0, over_flags_mb = 0;
1842

    
1843
    for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
1844
    {
1845
        for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
1846
        {
1847
            if (v->ac_pred_plane.is_raw)
1848
                s->ac_pred = get_bits(gb, 1);
1849
            else
1850
                s->ac_pred = v->ac_pred_plane.data[current_mb];
1851
            if (v->condover == 3 && v->over_flags_plane.is_raw)
1852
                over_flags_mb = get_bits(gb, 1);
1853
            GET_MQUANT();
1854

    
1855
            /* TODO: lots */
1856
        }
1857
        current_mb++;
1858
    }
1859
    return 0;
1860
}
1861
#endif
1862

    
1863
static int vc9_decode_init(AVCodecContext *avctx)
1864
{
1865
    VC9Context *v = avctx->priv_data;
1866
    MpegEncContext *s = &v->s;
1867
    GetBitContext gb;
1868

    
1869
    if (!avctx->extradata_size || !avctx->extradata) return -1;
1870
    avctx->pix_fmt = PIX_FMT_YUV420P;
1871
    v->s.avctx = avctx;
1872

    
1873
    if(ff_h263_decode_init(avctx) < 0)
1874
        return -1;
1875
    if (vc9_init_common(v) < 0) return -1;
1876

    
1877
    avctx->coded_width = avctx->width;
1878
    avctx->coded_height = avctx->height;
1879
    if (avctx->codec_id == CODEC_ID_WMV3)
1880
    {
1881
        int count = 0;
1882

    
1883
        // looks like WMV3 has a sequence header stored in the extradata
1884
        // advanced sequence header may be before the first frame
1885
        // the last byte of the extradata is a version number, 1 for the
1886
        // samples we can decode
1887

    
1888
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
1889
        
1890
        decode_sequence_header(avctx, &gb);
1891

    
1892
        count = avctx->extradata_size*8 - get_bits_count(&gb);
1893
        if (count>0)
1894
        {
1895
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
1896
                   count, get_bits(&gb, count));
1897
        }
1898
        else
1899
        {
1900
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
1901
        }
1902
    }
1903
    avctx->has_b_frames= !!(avctx->max_b_frames);
1904

    
1905
    s->mb_width = (avctx->coded_width+15)>>4;
1906
    s->mb_height = (avctx->coded_height+15)>>4;
1907

    
1908
    /* Allocate mb bitplanes */
1909
    if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
1910
        return -1;
1911
    if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
1912
        return -1;
1913
    if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
1914
        return -1;
1915
    if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
1916
        return -1;
1917

    
1918
    /* For predictors */
1919
    v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
1920
    if (!v->previous_line_cbpcy) return -1;
1921

    
1922
#if HAS_ADVANCED_PROFILE
1923
    if (v->profile > PROFILE_MAIN)
1924
    {
1925
        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
1926
            return -1;
1927
        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
1928
            return -1;
1929
    }
1930
#endif
1931

    
1932
    return 0;
1933
    }
1934

    
1935
static int vc9_decode_frame(AVCodecContext *avctx,
1936
                            void *data, int *data_size,
1937
                            uint8_t *buf, int buf_size)
1938
{
1939
    VC9Context *v = avctx->priv_data;
1940
    MpegEncContext *s = &v->s;
1941
    int ret = FRAME_SKIPED, len, start_code;
1942
    AVFrame *pict = data;
1943
    uint8_t *tmp_buf;
1944
    v->s.avctx = avctx;
1945

    
1946
    //buf_size = 0 -> last frame
1947
    if (!buf_size) return 0;
1948

    
1949
    len = avpicture_get_size(avctx->pix_fmt, avctx->width,
1950
                             avctx->height);
1951
    tmp_buf = (uint8_t *)av_mallocz(len);
1952
    avpicture_fill((AVPicture *)pict, tmp_buf, avctx->pix_fmt,
1953
                   avctx->width, avctx->height);
1954

    
1955
    if (avctx->codec_id == CODEC_ID_VC9)
1956
    {
1957
#if 0
1958
        // search for IDU's
1959
        // FIXME
1960
        uint32_t scp = 0;
1961
        int scs = 0, i = 0;
1962

1963
        while (i < buf_size)
1964
        {
1965
            for (; i < buf_size && scp != 0x000001; i++)
1966
                scp = ((scp<<8)|buf[i])&0xffffff;
1967

1968
            if (scp != 0x000001)
1969
                break; // eof ?
1970
        
1971
            scs = buf[i++];        
1972

1973
            init_get_bits(gb, buf+i, (buf_size-i)*8);
1974
        
1975
            switch(scs)
1976
            {
1977
            case 0x0A: //Sequence End Code
1978
                return 0;
1979
            case 0x0B: //Slice Start Code
1980
                av_log(avctx, AV_LOG_ERROR, "Slice coding not supported\n");
1981
                return -1;
1982
            case 0x0C: //Field start code
1983
                av_log(avctx, AV_LOG_ERROR, "Interlaced coding not supported\n");
1984
                return -1;
1985
            case 0x0D: //Frame start code
1986
                break;
1987
            case 0x0E: //Entry point Start Code
1988
                if (v->profile <= MAIN_PROFILE)
1989
                    av_log(avctx, AV_LOG_ERROR,
1990
                           "Found an entry point in profile %i\n", v->profile);
1991
                advanced_entry_point_process(avctx, gb);
1992
                break;
1993
            case 0x0F: //Sequence header Start Code
1994
                decode_sequence_header(avctx, gb);
1995
                break;
1996
            default:
1997
                av_log(avctx, AV_LOG_ERROR,
1998
                       "Unsupported IDU suffix %lX\n", scs);
1999
            }
2000
            
2001
            i += get_bits_count(gb)*8;
2002
        }
2003
#else
2004
        av_abort();
2005
#endif
2006
    }
2007
    else
2008
        init_get_bits(&v->s.gb, buf, buf_size*8);
2009

    
2010
    s->flags= avctx->flags;
2011
    s->flags2= avctx->flags2;
2012

    
2013
    /* no supplementary picture */
2014
    if (buf_size == 0) {
2015
        /* special case for last picture */
2016
        if (s->low_delay==0 && s->next_picture_ptr) {
2017
            *pict= *(AVFrame*)s->next_picture_ptr;
2018
            s->next_picture_ptr= NULL;
2019

    
2020
            *data_size = sizeof(AVFrame);
2021
        }
2022

    
2023
        return 0;
2024
    }
2025

    
2026
    //No IDU - we mimic ff_h263_decode_frame
2027
    s->bitstream_buffer_size=0;
2028
        
2029
    if (!s->context_initialized) {
2030
        if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
2031
            return -1;
2032
    }
2033
    
2034
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2035
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2036
        s->current_picture_ptr= &s->picture[ff_find_unused_picture(s, 0)];
2037
    }
2038
#if HAS_ADVANCED_PROFILE
2039
    if (v->profile > PROFILE_MAIN)
2040
        ret= advanced_decode_picture_primary_header(v);
2041
    else
2042
#endif
2043
        ret= standard_decode_picture_primary_header(v);
2044
    if (ret == FRAME_SKIPED) return buf_size;
2045
    /* skip if the header was thrashed */
2046
    if (ret < 0){
2047
        av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
2048
        return -1;
2049
    }
2050

    
2051
    //No bug workaround yet, no DCT conformance
2052

    
2053
    //WMV9 does have resized images
2054
    if (v->profile <= PROFILE_MAIN && v->multires){
2055
        //Parse context stuff in here, don't know how appliable it is
2056
    }
2057
    //Not sure about context initialization
2058

    
2059
    // for hurry_up==5
2060
    s->current_picture.pict_type= s->pict_type;
2061
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2062

    
2063
    /* skip b frames if we dont have reference frames */
2064
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable))
2065
        return buf_size; //FIXME simulating all buffer consumed
2066
    /* skip b frames if we are in a hurry */
2067
    if(avctx->hurry_up && s->pict_type==B_TYPE)
2068
        return buf_size; //FIXME simulating all buffer consumed
2069
    /* skip everything if we are in a hurry>=5 */
2070
    if(avctx->hurry_up>=5)
2071
        return buf_size; //FIXME simulating all buffer consumed
2072
    
2073
    if(s->next_p_frame_damaged){
2074
        if(s->pict_type==B_TYPE)
2075
            return buf_size; //FIXME simulating all buffer consumed
2076
        else
2077
            s->next_p_frame_damaged=0;
2078
    }
2079

    
2080
    if(MPV_frame_start(s, avctx) < 0)
2081
        return -1;
2082

    
2083
    ff_er_frame_start(s);
2084

    
2085
    //wmv9 may or may not have skip bits
2086
#if HAS_ADVANCED_PROFILE
2087
    if (v->profile > PROFILE_MAIN)
2088
        ret= advanced_decode_picture_secondary_header(v);
2089
    else
2090
#endif
2091
        ret = standard_decode_picture_secondary_header(v);
2092
    if (ret<0) return FRAME_SKIPED; //FIXME Non fatal for now
2093

    
2094
    //We consider the image coded in only one slice
2095
#if HAS_ADVANCED_PROFILE
2096
    if (v->profile > PROFILE_MAIN)
2097
    {
2098
        switch(s->pict_type)
2099
        {
2100
            case I_TYPE: ret = advanced_decode_i_mbs(v); break;
2101
            case P_TYPE: ret = decode_p_mbs(v); break;
2102
            case B_TYPE:
2103
            case BI_TYPE: ret = decode_b_mbs(v); break;
2104
            default: ret = FRAME_SKIPED;
2105
        }
2106
        if (ret == FRAME_SKIPED) return buf_size; //We ignore for now failures
2107
    }
2108
    else
2109
#endif
2110
    {
2111
        switch(s->pict_type)
2112
        {
2113
            case I_TYPE: ret = standard_decode_i_mbs(v); break;
2114
            case P_TYPE: ret = decode_p_mbs(v); break;
2115
            case B_TYPE:
2116
            case BI_TYPE: ret = decode_b_mbs(v); break;
2117
            default: ret = FRAME_SKIPED;
2118
        }
2119
        if (ret == FRAME_SKIPED) return buf_size;
2120
    }
2121

    
2122
    ff_er_frame_end(s);
2123

    
2124
    MPV_frame_end(s);
2125

    
2126
    assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2127
    assert(s->current_picture.pict_type == s->pict_type);
2128
    if(s->pict_type==B_TYPE || s->low_delay){
2129
        *pict= *(AVFrame*)&s->current_picture;
2130
        ff_print_debug_info(s, pict);
2131
    } else {
2132
        *pict= *(AVFrame*)&s->last_picture;
2133
        if(pict)
2134
            ff_print_debug_info(s, pict);
2135
    }
2136

    
2137
    /* Return the Picture timestamp as the frame number */
2138
    /* we substract 1 because it is added on utils.c    */
2139
    avctx->frame_number = s->picture_number - 1;
2140

    
2141
    /* dont output the last pic after seeking */
2142
    if(s->last_picture_ptr || s->low_delay)
2143
        *data_size = sizeof(AVFrame);
2144

    
2145
    av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",
2146
           get_bits_count(&s->gb), buf_size*8);
2147

    
2148
    /* Fake consumption of all data */
2149
    *data_size = len;
2150
    return buf_size; //Number of bytes consumed
2151
}
2152

    
2153
static int vc9_decode_end(AVCodecContext *avctx)
2154
{
2155
    VC9Context *v = avctx->priv_data;
2156

    
2157
#if HAS_ADVANCED_PROFILE
2158
    av_freep(&v->hrd_rate);
2159
    av_freep(&v->hrd_buffer);
2160
#endif
2161
    MPV_common_end(&v->s);
2162
    free_bitplane(&v->mv_type_mb_plane);
2163
    free_bitplane(&v->skip_mb_plane);
2164
    free_bitplane(&v->direct_mb_plane);
2165
    return 0;
2166
}
2167

    
2168
AVCodec vc9_decoder = {
2169
    "vc9",
2170
    CODEC_TYPE_VIDEO,
2171
    CODEC_ID_VC9,
2172
    sizeof(VC9Context),
2173
    vc9_decode_init,
2174
    NULL,
2175
    vc9_decode_end,
2176
    vc9_decode_frame,
2177
    CODEC_CAP_DELAY,
2178
    NULL
2179
};
2180

    
2181
AVCodec wmv3_decoder = {
2182
    "wmv3",
2183
    CODEC_TYPE_VIDEO,
2184
    CODEC_ID_WMV3,
2185
    sizeof(VC9Context),
2186
    vc9_decode_init,
2187
    NULL,
2188
    vc9_decode_end,
2189
    vc9_decode_frame,
2190
    CODEC_CAP_DELAY,
2191
    NULL
2192
};