Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ituh263dec.c @ 2912e87a

History | View | Annotate | Download (35.6 KB)

1
/*
2
 * ITU H263 bitstream decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * H263+ support.
5
 * Copyright (c) 2001 Juan J. Sierralta P
6
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This file is part of Libav.
9
 *
10
 * Libav is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * Libav is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with Libav; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24

    
25
/**
26
 * @file
27
 * h263 decoder.
28
 */
29

    
30
//#define DEBUG
31
#include <limits.h>
32

    
33
#include "dsputil.h"
34
#include "avcodec.h"
35
#include "mpegvideo.h"
36
#include "h263.h"
37
#include "mathops.h"
38
#include "unary.h"
39
#include "flv.h"
40
#include "mpeg4video.h"
41

    
42
//#undef NDEBUG
43
//#include <assert.h>
44

    
45
// The defines below define the number of bits that are read at once for
46
// reading vlc values. Changing these may improve speed and data cache needs
47
// be aware though that decreasing them may need the number of stages that is
48
// passed to get_vlc* to be increased.
49
#define MV_VLC_BITS 9
50
#define H263_MBTYPE_B_VLC_BITS 6
51
#define CBPC_B_VLC_BITS 3
52

    
53
static const int h263_mb_type_b_map[15]= {
54
    MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
55
    MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP,
56
    MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT,
57
                      MB_TYPE_L0                                 | MB_TYPE_16x16,
58
                      MB_TYPE_L0   | MB_TYPE_CBP                 | MB_TYPE_16x16,
59
                      MB_TYPE_L0   | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
60
                      MB_TYPE_L1                                 | MB_TYPE_16x16,
61
                      MB_TYPE_L1   | MB_TYPE_CBP                 | MB_TYPE_16x16,
62
                      MB_TYPE_L1   | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
63
                      MB_TYPE_L0L1                               | MB_TYPE_16x16,
64
                      MB_TYPE_L0L1 | MB_TYPE_CBP                 | MB_TYPE_16x16,
65
                      MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
66
    0, //stuffing
67
    MB_TYPE_INTRA4x4                | MB_TYPE_CBP,
68
    MB_TYPE_INTRA4x4                | MB_TYPE_CBP | MB_TYPE_QUANT,
69
};
70

    
71
void ff_h263_show_pict_info(MpegEncContext *s){
72
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
73
    av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
74
         s->qscale, av_get_pict_type_char(s->pict_type),
75
         s->gb.size_in_bits, 1-s->no_rounding,
76
         s->obmc ? " AP" : "",
77
         s->umvplus ? " UMV" : "",
78
         s->h263_long_vectors ? " LONG" : "",
79
         s->h263_plus ? " +" : "",
80
         s->h263_aic ? " AIC" : "",
81
         s->alt_inter_vlc ? " AIV" : "",
82
         s->modified_quant ? " MQ" : "",
83
         s->loop_filter ? " LOOP" : "",
84
         s->h263_slice_structured ? " SS" : "",
85
         s->avctx->time_base.den, s->avctx->time_base.num
86
    );
87
    }
88
}
89

    
90
/***********************************************/
91
/* decoding */
92

    
93
VLC ff_h263_intra_MCBPC_vlc;
94
VLC ff_h263_inter_MCBPC_vlc;
95
VLC ff_h263_cbpy_vlc;
96
static VLC mv_vlc;
97
static VLC h263_mbtype_b_vlc;
98
static VLC cbpc_b_vlc;
99

    
100
/* init vlcs */
101

    
102
/* XXX: find a better solution to handle static init */
103
void h263_decode_init_vlc(MpegEncContext *s)
104
{
105
    static int done = 0;
106

    
107
    if (!done) {
108
        done = 1;
109

    
110
        INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
111
                 ff_h263_intra_MCBPC_bits, 1, 1,
112
                 ff_h263_intra_MCBPC_code, 1, 1, 72);
113
        INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
114
                 ff_h263_inter_MCBPC_bits, 1, 1,
115
                 ff_h263_inter_MCBPC_code, 1, 1, 198);
116
        INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16,
117
                 &ff_h263_cbpy_tab[0][1], 2, 1,
118
                 &ff_h263_cbpy_tab[0][0], 2, 1, 64);
119
        INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
120
                 &mvtab[0][1], 2, 1,
121
                 &mvtab[0][0], 2, 1, 538);
122
        init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
123
        init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]);
124
        INIT_VLC_RL(ff_h263_rl_inter, 554);
125
        INIT_VLC_RL(rl_intra_aic, 554);
126
        INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
127
                 &h263_mbtype_b_tab[0][1], 2, 1,
128
                 &h263_mbtype_b_tab[0][0], 2, 1, 80);
129
        INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
130
                 &cbpc_b_tab[0][1], 2, 1,
131
                 &cbpc_b_tab[0][0], 2, 1, 8);
132
    }
133
}
134

    
135
int ff_h263_decode_mba(MpegEncContext *s)
136
{
137
    int i, mb_pos;
138

    
139
    for(i=0; i<6; i++){
140
        if(s->mb_num-1 <= ff_mba_max[i]) break;
141
    }
142
    mb_pos= get_bits(&s->gb, ff_mba_length[i]);
143
    s->mb_x= mb_pos % s->mb_width;
144
    s->mb_y= mb_pos / s->mb_width;
145

    
146
    return mb_pos;
147
}
148

    
149
/**
150
 * decodes the group of blocks header or slice header.
151
 * @return <0 if an error occurred
152
 */
153
static int h263_decode_gob_header(MpegEncContext *s)
154
{
155
    unsigned int val, gfid, gob_number;
156
    int left;
157

    
158
    /* Check for GOB Start Code */
159
    val = show_bits(&s->gb, 16);
160
    if(val)
161
        return -1;
162

    
163
        /* We have a GBSC probably with GSTUFF */
164
    skip_bits(&s->gb, 16); /* Drop the zeros */
165
    left= get_bits_left(&s->gb);
166
    //MN: we must check the bits left or we might end in a infinite loop (or segfault)
167
    for(;left>13; left--){
168
        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
169
    }
170
    if(left<=13)
171
        return -1;
172

    
173
    if(s->h263_slice_structured){
174
        if(get_bits1(&s->gb)==0)
175
            return -1;
176

    
177
        ff_h263_decode_mba(s);
178

    
179
        if(s->mb_num > 1583)
180
            if(get_bits1(&s->gb)==0)
181
                return -1;
182

    
183
        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
184
        if(get_bits1(&s->gb)==0)
185
            return -1;
186
        gfid = get_bits(&s->gb, 2); /* GFID */
187
    }else{
188
        gob_number = get_bits(&s->gb, 5); /* GN */
189
        s->mb_x= 0;
190
        s->mb_y= s->gob_index* gob_number;
191
        gfid = get_bits(&s->gb, 2); /* GFID */
192
        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
193
    }
194

    
195
    if(s->mb_y >= s->mb_height)
196
        return -1;
197

    
198
    if(s->qscale==0)
199
        return -1;
200

    
201
    return 0;
202
}
203

    
204
/**
205
 * finds the next resync_marker
206
 * @param p pointer to buffer to scan
207
 * @param end pointer to the end of the buffer
208
 * @return pointer to the next resync_marker, or end if none was found
209
 */
210
const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end)
211
{
212
    assert(p < end);
213

    
214
    end-=2;
215
    p++;
216
    for(;p<end; p+=2){
217
        if(!*p){
218
            if     (!p[-1] && p[1]) return p - 1;
219
            else if(!p[ 1] && p[2]) return p;
220
        }
221
    }
222
    return end+2;
223
}
224

    
225
/**
226
 * decodes the group of blocks / video packet header.
227
 * @return bit position of the resync_marker, or <0 if none was found
228
 */
229
int ff_h263_resync(MpegEncContext *s){
230
    int left, pos, ret;
231

    
232
    if(s->codec_id==CODEC_ID_MPEG4){
233
        skip_bits1(&s->gb);
234
        align_get_bits(&s->gb);
235
    }
236

    
237
    if(show_bits(&s->gb, 16)==0){
238
        pos= get_bits_count(&s->gb);
239
        if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
240
            ret= mpeg4_decode_video_packet_header(s);
241
        else
242
            ret= h263_decode_gob_header(s);
243
        if(ret>=0)
244
            return pos;
245
    }
246
    //OK, it's not where it is supposed to be ...
247
    s->gb= s->last_resync_gb;
248
    align_get_bits(&s->gb);
249
    left= get_bits_left(&s->gb);
250

    
251
    for(;left>16+1+5+5; left-=8){
252
        if(show_bits(&s->gb, 16)==0){
253
            GetBitContext bak= s->gb;
254

    
255
            pos= get_bits_count(&s->gb);
256
            if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
257
                ret= mpeg4_decode_video_packet_header(s);
258
            else
259
                ret= h263_decode_gob_header(s);
260
            if(ret>=0)
261
                return pos;
262

    
263
            s->gb= bak;
264
        }
265
        skip_bits(&s->gb, 8);
266
    }
267

    
268
    return -1;
269
}
270

    
271
int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
272
{
273
    int code, val, sign, shift, l;
274
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
275

    
276
    if (code == 0)
277
        return pred;
278
    if (code < 0)
279
        return 0xffff;
280

    
281
    sign = get_bits1(&s->gb);
282
    shift = f_code - 1;
283
    val = code;
284
    if (shift) {
285
        val = (val - 1) << shift;
286
        val |= get_bits(&s->gb, shift);
287
        val++;
288
    }
289
    if (sign)
290
        val = -val;
291
    val += pred;
292

    
293
    /* modulo decoding */
294
    if (!s->h263_long_vectors) {
295
        l = INT_BIT - 5 - f_code;
296
        val = (val<<l)>>l;
297
    } else {
298
        /* horrible h263 long vector mode */
299
        if (pred < -31 && val < -63)
300
            val += 64;
301
        if (pred > 32 && val > 63)
302
            val -= 64;
303

    
304
    }
305
    return val;
306
}
307

    
308

    
309
/* Decodes RVLC of H.263+ UMV */
310
static int h263p_decode_umotion(MpegEncContext * s, int pred)
311
{
312
   int code = 0, sign;
313

    
314
   if (get_bits1(&s->gb)) /* Motion difference = 0 */
315
      return pred;
316

    
317
   code = 2 + get_bits1(&s->gb);
318

    
319
   while (get_bits1(&s->gb))
320
   {
321
      code <<= 1;
322
      code += get_bits1(&s->gb);
323
   }
324
   sign = code & 1;
325
   code >>= 1;
326

    
327
   code = (sign) ? (pred - code) : (pred + code);
328
   av_dlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
329
   return code;
330

    
331
}
332

    
333
/**
334
 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
335
 */
336
static void preview_obmc(MpegEncContext *s){
337
    GetBitContext gb= s->gb;
338

    
339
    int cbpc, i, pred_x, pred_y, mx, my;
340
    int16_t *mot_val;
341
    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
342
    const int stride= s->b8_stride*2;
343

    
344
    for(i=0; i<4; i++)
345
        s->block_index[i]+= 2;
346
    for(i=4; i<6; i++)
347
        s->block_index[i]+= 1;
348
    s->mb_x++;
349

    
350
    assert(s->pict_type == FF_P_TYPE);
351

    
352
    do{
353
        if (get_bits1(&s->gb)) {
354
            /* skip mb */
355
            mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
356
            mot_val[0       ]= mot_val[2       ]=
357
            mot_val[0+stride]= mot_val[2+stride]= 0;
358
            mot_val[1       ]= mot_val[3       ]=
359
            mot_val[1+stride]= mot_val[3+stride]= 0;
360

    
361
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
362
            goto end;
363
        }
364
        cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
365
    }while(cbpc == 20);
366

    
367
    if(cbpc & 4){
368
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
369
    }else{
370
        get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
371
        if (cbpc & 8) {
372
            if(s->modified_quant){
373
                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
374
                else                  skip_bits(&s->gb, 5);
375
            }else
376
                skip_bits(&s->gb, 2);
377
        }
378

    
379
        if ((cbpc & 16) == 0) {
380
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
381
                /* 16x16 motion prediction */
382
                mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
383
                if (s->umvplus)
384
                   mx = h263p_decode_umotion(s, pred_x);
385
                else
386
                   mx = h263_decode_motion(s, pred_x, 1);
387

    
388
                if (s->umvplus)
389
                   my = h263p_decode_umotion(s, pred_y);
390
                else
391
                   my = h263_decode_motion(s, pred_y, 1);
392

    
393
                mot_val[0       ]= mot_val[2       ]=
394
                mot_val[0+stride]= mot_val[2+stride]= mx;
395
                mot_val[1       ]= mot_val[3       ]=
396
                mot_val[1+stride]= mot_val[3+stride]= my;
397
        } else {
398
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
399
            for(i=0;i<4;i++) {
400
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
401
                if (s->umvplus)
402
                  mx = h263p_decode_umotion(s, pred_x);
403
                else
404
                  mx = h263_decode_motion(s, pred_x, 1);
405

    
406
                if (s->umvplus)
407
                  my = h263p_decode_umotion(s, pred_y);
408
                else
409
                  my = h263_decode_motion(s, pred_y, 1);
410
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
411
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
412
                mot_val[0] = mx;
413
                mot_val[1] = my;
414
            }
415
        }
416
    }
417
end:
418

    
419
    for(i=0; i<4; i++)
420
        s->block_index[i]-= 2;
421
    for(i=4; i<6; i++)
422
        s->block_index[i]-= 1;
423
    s->mb_x--;
424

    
425
    s->gb= gb;
426
}
427

    
428
static void h263_decode_dquant(MpegEncContext *s){
429
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
430

    
431
    if(s->modified_quant){
432
        if(get_bits1(&s->gb))
433
            s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
434
        else
435
            s->qscale= get_bits(&s->gb, 5);
436
    }else
437
        s->qscale += quant_tab[get_bits(&s->gb, 2)];
438
    ff_set_qscale(s, s->qscale);
439
}
440

    
441
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
442
                             int n, int coded)
443
{
444
    int code, level, i, j, last, run;
445
    RLTable *rl = &ff_h263_rl_inter;
446
    const uint8_t *scan_table;
447
    GetBitContext gb= s->gb;
448

    
449
    scan_table = s->intra_scantable.permutated;
450
    if (s->h263_aic && s->mb_intra) {
451
        rl = &rl_intra_aic;
452
        i = 0;
453
        if (s->ac_pred) {
454
            if (s->h263_aic_dir)
455
                scan_table = s->intra_v_scantable.permutated; /* left */
456
            else
457
                scan_table = s->intra_h_scantable.permutated; /* top */
458
        }
459
    } else if (s->mb_intra) {
460
        /* DC coef */
461
        if(s->codec_id == CODEC_ID_RV10){
462
#if CONFIG_RV10_DECODER
463
          if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) {
464
            int component, diff;
465
            component = (n <= 3 ? 0 : n - 4 + 1);
466
            level = s->last_dc[component];
467
            if (s->rv10_first_dc_coded[component]) {
468
                diff = rv_decode_dc(s, n);
469
                if (diff == 0xffff)
470
                    return -1;
471
                level += diff;
472
                level = level & 0xff; /* handle wrap round */
473
                s->last_dc[component] = level;
474
            } else {
475
                s->rv10_first_dc_coded[component] = 1;
476
            }
477
          } else {
478
                level = get_bits(&s->gb, 8);
479
                if (level == 255)
480
                    level = 128;
481
          }
482
#endif
483
        }else{
484
            level = get_bits(&s->gb, 8);
485
            if((level&0x7F) == 0){
486
                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
487
                if(s->error_recognition >= FF_ER_COMPLIANT)
488
                    return -1;
489
            }
490
            if (level == 255)
491
                level = 128;
492
        }
493
        block[0] = level;
494
        i = 1;
495
    } else {
496
        i = 0;
497
    }
498
    if (!coded) {
499
        if (s->mb_intra && s->h263_aic)
500
            goto not_coded;
501
        s->block_last_index[n] = i - 1;
502
        return 0;
503
    }
504
retry:
505
    for(;;) {
506
        code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
507
        if (code < 0){
508
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
509
            return -1;
510
        }
511
        if (code == rl->n) {
512
            /* escape */
513
            if (CONFIG_FLV_DECODER && s->h263_flv > 1) {
514
                ff_flv2_decode_ac_esc(&s->gb, &level, &run, &last);
515
            } else {
516
                last = get_bits1(&s->gb);
517
                run = get_bits(&s->gb, 6);
518
                level = (int8_t)get_bits(&s->gb, 8);
519
                if(level == -128){
520
                    if (s->codec_id == CODEC_ID_RV10) {
521
                        /* XXX: should patch encoder too */
522
                        level = get_sbits(&s->gb, 12);
523
                    }else{
524
                        level = get_bits(&s->gb, 5);
525
                        level |= get_sbits(&s->gb, 6)<<5;
526
                    }
527
                }
528
            }
529
        } else {
530
            run = rl->table_run[code];
531
            level = rl->table_level[code];
532
            last = code >= rl->last;
533
            if (get_bits1(&s->gb))
534
                level = -level;
535
        }
536
        i += run;
537
        if (i >= 64){
538
            if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){
539
                //Looks like a hack but no, it's the way it is supposed to work ...
540
                rl = &rl_intra_aic;
541
                i = 0;
542
                s->gb= gb;
543
                s->dsp.clear_block(block);
544
                goto retry;
545
            }
546
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
547
            return -1;
548
        }
549
        j = scan_table[i];
550
        block[j] = level;
551
        if (last)
552
            break;
553
        i++;
554
    }
555
not_coded:
556
    if (s->mb_intra && s->h263_aic) {
557
        h263_pred_acdc(s, block, n);
558
        i = 63;
559
    }
560
    s->block_last_index[n] = i;
561
    return 0;
562
}
563

    
564
static int h263_skip_b_part(MpegEncContext *s, int cbp)
565
{
566
    LOCAL_ALIGNED_16(DCTELEM, dblock, [64]);
567
    int i, mbi;
568

    
569
    /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
570
     * but real value should be restored in order to be used later (in OBMC condition)
571
     */
572
    mbi = s->mb_intra;
573
    s->mb_intra = 0;
574
    for (i = 0; i < 6; i++) {
575
        if (h263_decode_block(s, dblock, i, cbp&32) < 0)
576
            return -1;
577
        cbp+=cbp;
578
    }
579
    s->mb_intra = mbi;
580
    return 0;
581
}
582

    
583
static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
584
{
585
    int c, mv = 1;
586

    
587
    if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame
588
        c = get_bits1(gb);
589
        if (pb_frame == 2 && c)
590
            mv = !get_bits1(gb);
591
    } else { // h.263 Annex M improved PB-frame
592
        mv = get_unary(gb, 0, 4) + 1;
593
        c = mv & 1;
594
        mv = !!(mv & 2);
595
    }
596
    if(c)
597
        *cbpb = get_bits(gb, 6);
598
    return mv;
599
}
600

    
601
int ff_h263_decode_mb(MpegEncContext *s,
602
                      DCTELEM block[6][64])
603
{
604
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
605
    int16_t *mot_val;
606
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
607
    int cbpb = 0, pb_mv_count = 0;
608

    
609
    assert(!s->h263_pred);
610

    
611
    if (s->pict_type == FF_P_TYPE) {
612
        do{
613
            if (get_bits1(&s->gb)) {
614
                /* skip mb */
615
                s->mb_intra = 0;
616
                for(i=0;i<6;i++)
617
                    s->block_last_index[i] = -1;
618
                s->mv_dir = MV_DIR_FORWARD;
619
                s->mv_type = MV_TYPE_16X16;
620
                s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
621
                s->mv[0][0][0] = 0;
622
                s->mv[0][0][1] = 0;
623
                s->mb_skipped = !(s->obmc | s->loop_filter);
624
                goto end;
625
            }
626
            cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
627
            if (cbpc < 0){
628
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
629
                return -1;
630
            }
631
        }while(cbpc == 20);
632

    
633
        s->dsp.clear_blocks(s->block[0]);
634

    
635
        dquant = cbpc & 8;
636
        s->mb_intra = ((cbpc & 4) != 0);
637
        if (s->mb_intra) goto intra;
638

    
639
        if(s->pb_frame && get_bits1(&s->gb))
640
            pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
641
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
642

    
643
        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
644
            cbpy ^= 0xF;
645

    
646
        cbp = (cbpc & 3) | (cbpy << 2);
647
        if (dquant) {
648
            h263_decode_dquant(s);
649
        }
650

    
651
        s->mv_dir = MV_DIR_FORWARD;
652
        if ((cbpc & 16) == 0) {
653
            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
654
            /* 16x16 motion prediction */
655
            s->mv_type = MV_TYPE_16X16;
656
            h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
657
            if (s->umvplus)
658
               mx = h263p_decode_umotion(s, pred_x);
659
            else
660
               mx = h263_decode_motion(s, pred_x, 1);
661

    
662
            if (mx >= 0xffff)
663
                return -1;
664

    
665
            if (s->umvplus)
666
               my = h263p_decode_umotion(s, pred_y);
667
            else
668
               my = h263_decode_motion(s, pred_y, 1);
669

    
670
            if (my >= 0xffff)
671
                return -1;
672
            s->mv[0][0][0] = mx;
673
            s->mv[0][0][1] = my;
674

    
675
            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
676
               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
677
        } else {
678
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
679
            s->mv_type = MV_TYPE_8X8;
680
            for(i=0;i<4;i++) {
681
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
682
                if (s->umvplus)
683
                  mx = h263p_decode_umotion(s, pred_x);
684
                else
685
                  mx = h263_decode_motion(s, pred_x, 1);
686
                if (mx >= 0xffff)
687
                    return -1;
688

    
689
                if (s->umvplus)
690
                  my = h263p_decode_umotion(s, pred_y);
691
                else
692
                  my = h263_decode_motion(s, pred_y, 1);
693
                if (my >= 0xffff)
694
                    return -1;
695
                s->mv[0][i][0] = mx;
696
                s->mv[0][i][1] = my;
697
                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
698
                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
699
                mot_val[0] = mx;
700
                mot_val[1] = my;
701
            }
702
        }
703
    } else if(s->pict_type==FF_B_TYPE) {
704
        int mb_type;
705
        const int stride= s->b8_stride;
706
        int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
707
        int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
708
//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
709

    
710
        //FIXME ugly
711
        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
712
        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
713
        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
714
        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
715

    
716
        do{
717
            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
718
            if (mb_type < 0){
719
                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
720
                return -1;
721
            }
722

    
723
            mb_type= h263_mb_type_b_map[ mb_type ];
724
        }while(!mb_type);
725

    
726
        s->mb_intra = IS_INTRA(mb_type);
727
        if(HAS_CBP(mb_type)){
728
            s->dsp.clear_blocks(s->block[0]);
729
            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
730
            if(s->mb_intra){
731
                dquant = IS_QUANT(mb_type);
732
                goto intra;
733
            }
734

    
735
            cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
736

    
737
            if (cbpy < 0){
738
                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
739
                return -1;
740
            }
741

    
742
            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
743
                cbpy ^= 0xF;
744

    
745
            cbp = (cbpc & 3) | (cbpy << 2);
746
        }else
747
            cbp=0;
748

    
749
        assert(!s->mb_intra);
750

    
751
        if(IS_QUANT(mb_type)){
752
            h263_decode_dquant(s);
753
        }
754

    
755
        if(IS_DIRECT(mb_type)){
756
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
757
            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
758
        }else{
759
            s->mv_dir = 0;
760
            s->mv_type= MV_TYPE_16X16;
761
//FIXME UMV
762

    
763
            if(USES_LIST(mb_type, 0)){
764
                int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
765
                s->mv_dir = MV_DIR_FORWARD;
766

    
767
                mx = h263_decode_motion(s, mx, 1);
768
                my = h263_decode_motion(s, my, 1);
769

    
770
                s->mv[0][0][0] = mx;
771
                s->mv[0][0][1] = my;
772
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
773
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
774
            }
775

    
776
            if(USES_LIST(mb_type, 1)){
777
                int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
778
                s->mv_dir |= MV_DIR_BACKWARD;
779

    
780
                mx = h263_decode_motion(s, mx, 1);
781
                my = h263_decode_motion(s, my, 1);
782

    
783
                s->mv[1][0][0] = mx;
784
                s->mv[1][0][1] = my;
785
                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
786
                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
787
            }
788
        }
789

    
790
        s->current_picture.mb_type[xy]= mb_type;
791
    } else { /* I-Frame */
792
        do{
793
            cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
794
            if (cbpc < 0){
795
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
796
                return -1;
797
            }
798
        }while(cbpc == 8);
799

    
800
        s->dsp.clear_blocks(s->block[0]);
801

    
802
        dquant = cbpc & 4;
803
        s->mb_intra = 1;
804
intra:
805
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
806
        if (s->h263_aic) {
807
            s->ac_pred = get_bits1(&s->gb);
808
            if(s->ac_pred){
809
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
810

    
811
                s->h263_aic_dir = get_bits1(&s->gb);
812
            }
813
        }else
814
            s->ac_pred = 0;
815

    
816
        if(s->pb_frame && get_bits1(&s->gb))
817
            pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
818
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
819
        if(cbpy<0){
820
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
821
            return -1;
822
        }
823
        cbp = (cbpc & 3) | (cbpy << 2);
824
        if (dquant) {
825
            h263_decode_dquant(s);
826
        }
827

    
828
        pb_mv_count += !!s->pb_frame;
829
    }
830

    
831
    while(pb_mv_count--){
832
        h263_decode_motion(s, 0, 1);
833
        h263_decode_motion(s, 0, 1);
834
    }
835

    
836
    /* decode each block */
837
    for (i = 0; i < 6; i++) {
838
        if (h263_decode_block(s, block[i], i, cbp&32) < 0)
839
            return -1;
840
        cbp+=cbp;
841
    }
842

    
843
    if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
844
        return -1;
845
    if(s->obmc && !s->mb_intra){
846
        if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
847
            preview_obmc(s);
848
    }
849
end:
850

    
851
        /* per-MB end of slice check */
852
    {
853
        int v= show_bits(&s->gb, 16);
854

    
855
        if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
856
            v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
857
        }
858

    
859
        if(v==0)
860
            return SLICE_END;
861
    }
862

    
863
    return SLICE_OK;
864
}
865

    
866
/* most is hardcoded. should extend to handle all h263 streams */
867
int h263_decode_picture_header(MpegEncContext *s)
868
{
869
    int format, width, height, i;
870
    uint32_t startcode;
871

    
872
    align_get_bits(&s->gb);
873

    
874
    startcode= get_bits(&s->gb, 22-8);
875

    
876
    for(i= get_bits_left(&s->gb); i>24; i-=8) {
877
        startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
878

    
879
        if(startcode == 0x20)
880
            break;
881
    }
882

    
883
    if (startcode != 0x20) {
884
        av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
885
        return -1;
886
    }
887
    /* temporal reference */
888
    i = get_bits(&s->gb, 8); /* picture timestamp */
889
    if( (s->picture_number&~0xFF)+i < s->picture_number)
890
        i+= 256;
891
    s->current_picture_ptr->pts=
892
    s->picture_number= (s->picture_number&~0xFF) + i;
893

    
894
    /* PTYPE starts here */
895
    if (get_bits1(&s->gb) != 1) {
896
        /* marker */
897
        av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
898
        return -1;
899
    }
900
    if (get_bits1(&s->gb) != 0) {
901
        av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
902
        return -1;      /* h263 id */
903
    }
904
    skip_bits1(&s->gb);         /* split screen off */
905
    skip_bits1(&s->gb);         /* camera  off */
906
    skip_bits1(&s->gb);         /* freeze picture release off */
907

    
908
    format = get_bits(&s->gb, 3);
909
    /*
910
        0    forbidden
911
        1    sub-QCIF
912
        10   QCIF
913
        7       extended PTYPE (PLUSPTYPE)
914
    */
915

    
916
    if (format != 7 && format != 6) {
917
        s->h263_plus = 0;
918
        /* H.263v1 */
919
        width = h263_format[format][0];
920
        height = h263_format[format][1];
921
        if (!width)
922
            return -1;
923

    
924
        s->pict_type = FF_I_TYPE + get_bits1(&s->gb);
925

    
926
        s->h263_long_vectors = get_bits1(&s->gb);
927

    
928
        if (get_bits1(&s->gb) != 0) {
929
            av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
930
            return -1; /* SAC: off */
931
        }
932
        s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
933
        s->unrestricted_mv = s->h263_long_vectors || s->obmc;
934

    
935
        s->pb_frame = get_bits1(&s->gb);
936
        s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
937
        skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
938

    
939
        s->width = width;
940
        s->height = height;
941
        s->avctx->sample_aspect_ratio= (AVRational){12,11};
942
        s->avctx->time_base= (AVRational){1001, 30000};
943
    } else {
944
        int ufep;
945

    
946
        /* H.263v2 */
947
        s->h263_plus = 1;
948
        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
949

    
950
        /* ufep other than 0 and 1 are reserved */
951
        if (ufep == 1) {
952
            /* OPPTYPE */
953
            format = get_bits(&s->gb, 3);
954
            av_dlog(s->avctx, "ufep=1, format: %d\n", format);
955
            s->custom_pcf= get_bits1(&s->gb);
956
            s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
957
            if (get_bits1(&s->gb) != 0) {
958
                av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
959
            }
960
            s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
961
            s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
962
            s->loop_filter= get_bits1(&s->gb);
963
            s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
964

    
965
            s->h263_slice_structured= get_bits1(&s->gb);
966
            if (get_bits1(&s->gb) != 0) {
967
                av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
968
            }
969
            if (get_bits1(&s->gb) != 0) {
970
                av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
971
            }
972
            s->alt_inter_vlc= get_bits1(&s->gb);
973
            s->modified_quant= get_bits1(&s->gb);
974
            if(s->modified_quant)
975
                s->chroma_qscale_table= ff_h263_chroma_qscale_table;
976

    
977
            skip_bits(&s->gb, 1); /* Prevent start code emulation */
978

    
979
            skip_bits(&s->gb, 3); /* Reserved */
980
        } else if (ufep != 0) {
981
            av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
982
            return -1;
983
        }
984

    
985
        /* MPPTYPE */
986
        s->pict_type = get_bits(&s->gb, 3);
987
        switch(s->pict_type){
988
        case 0: s->pict_type= FF_I_TYPE;break;
989
        case 1: s->pict_type= FF_P_TYPE;break;
990
        case 2: s->pict_type= FF_P_TYPE;s->pb_frame = 3;break;
991
        case 3: s->pict_type= FF_B_TYPE;break;
992
        case 7: s->pict_type= FF_I_TYPE;break; //ZYGO
993
        default:
994
            return -1;
995
        }
996
        skip_bits(&s->gb, 2);
997
        s->no_rounding = get_bits1(&s->gb);
998
        skip_bits(&s->gb, 4);
999

    
1000
        /* Get the picture dimensions */
1001
        if (ufep) {
1002
            if (format == 6) {
1003
                /* Custom Picture Format (CPFMT) */
1004
                s->aspect_ratio_info = get_bits(&s->gb, 4);
1005
                av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
1006
                /* aspect ratios:
1007
                0 - forbidden
1008
                1 - 1:1
1009
                2 - 12:11 (CIF 4:3)
1010
                3 - 10:11 (525-type 4:3)
1011
                4 - 16:11 (CIF 16:9)
1012
                5 - 40:33 (525-type 16:9)
1013
                6-14 - reserved
1014
                */
1015
                width = (get_bits(&s->gb, 9) + 1) * 4;
1016
                skip_bits1(&s->gb);
1017
                height = get_bits(&s->gb, 9) * 4;
1018
                av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
1019
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
1020
                    /* aspected dimensions */
1021
                    s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
1022
                    s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
1023
                }else{
1024
                    s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info];
1025
                }
1026
            } else {
1027
                width = h263_format[format][0];
1028
                height = h263_format[format][1];
1029
                s->avctx->sample_aspect_ratio= (AVRational){12,11};
1030
            }
1031
            if ((width == 0) || (height == 0))
1032
                return -1;
1033
            s->width = width;
1034
            s->height = height;
1035

    
1036
            if(s->custom_pcf){
1037
                int gcd;
1038
                s->avctx->time_base.den= 1800000;
1039
                s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
1040
                s->avctx->time_base.num*= get_bits(&s->gb, 7);
1041
                if(s->avctx->time_base.num == 0){
1042
                    av_log(s, AV_LOG_ERROR, "zero framerate\n");
1043
                    return -1;
1044
                }
1045
                gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
1046
                s->avctx->time_base.den /= gcd;
1047
                s->avctx->time_base.num /= gcd;
1048
            }else{
1049
                s->avctx->time_base= (AVRational){1001, 30000};
1050
            }
1051
        }
1052

    
1053
        if(s->custom_pcf){
1054
            skip_bits(&s->gb, 2); //extended Temporal reference
1055
        }
1056

    
1057
        if (ufep) {
1058
            if (s->umvplus) {
1059
                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1060
                    skip_bits1(&s->gb);
1061
            }
1062
            if(s->h263_slice_structured){
1063
                if (get_bits1(&s->gb) != 0) {
1064
                    av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
1065
                }
1066
                if (get_bits1(&s->gb) != 0) {
1067
                    av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
1068
                }
1069
            }
1070
        }
1071

    
1072
        s->qscale = get_bits(&s->gb, 5);
1073
    }
1074

    
1075
    s->mb_width = (s->width  + 15) / 16;
1076
    s->mb_height = (s->height  + 15) / 16;
1077
    s->mb_num = s->mb_width * s->mb_height;
1078

    
1079
    if (s->pb_frame) {
1080
        skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */
1081
        if (s->custom_pcf)
1082
            skip_bits(&s->gb, 2); //extended Temporal reference
1083
        skip_bits(&s->gb, 2); /* Quantization information for B-pictures */
1084
    }
1085

    
1086
    /* PEI */
1087
    while (get_bits1(&s->gb) != 0) {
1088
        skip_bits(&s->gb, 8);
1089
    }
1090

    
1091
    if(s->h263_slice_structured){
1092
        if (get_bits1(&s->gb) != 1) {
1093
            av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
1094
            return -1;
1095
        }
1096

    
1097
        ff_h263_decode_mba(s);
1098

    
1099
        if (get_bits1(&s->gb) != 1) {
1100
            av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
1101
            return -1;
1102
        }
1103
    }
1104
    s->f_code = 1;
1105

    
1106
    if(s->h263_aic){
1107
         s->y_dc_scale_table=
1108
         s->c_dc_scale_table= ff_aic_dc_scale_table;
1109
    }else{
1110
        s->y_dc_scale_table=
1111
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1112
    }
1113

    
1114
        ff_h263_show_pict_info(s);
1115
    if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){
1116
        int i,j;
1117
        for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1118
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
1119
        for(i=0; i<13; i++){
1120
            for(j=0; j<3; j++){
1121
                int v= get_bits(&s->gb, 8);
1122
                v |= get_sbits(&s->gb, 8)<<8;
1123
                av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
1124
            }
1125
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1126
        }
1127
        for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1128
    }
1129

    
1130
    return 0;
1131
}