← Back to branch summary

~siretart/xine-lib/ubuntu

« back to all changes in this revision

Viewing changes to src/libffmpeg/libavcodec/h261.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2005-12-15 13:13:45 UTC
  • mfrom: (0.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051215131345-8n4osv1j7fy9c1s1
* SECURITY UPDATE: Fix arbitrary code execution with crafted PNG images in
  embedded ffmpeg copy.
* src/libffmpeg/libavcodec/utils.c, avcodec_default_get_buffer(): Apply
  upstream patch to fix buffer overflow on decoding of small PIX_FMT_PAL8
  PNG files.
* References:
  CVE-2005-4048
  http://mplayerhq.hu/pipermail/ffmpeg-devel/2005-November/005333.html
  http://www1.mplayerhq.hu/cgi-bin/cvsweb.cgi/ffmpeg/libavcodec/
  utils.c.diff?r1=1.161&r2=1.162&cvsroot=FFMpeg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libffmpeg/libavcodec/h261.c
 
1
/*
 
2
 * H261 decoder
 
3
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 
4
 * Copyright (c) 2004 Maarten Daniels
 
5
 *
 
6
 * This library is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Lesser General Public
 
8
 * License as published by the Free Software Foundation; either
 
9
 * version 2 of the License, or (at your option) any later version.
 
10
 *
 
11
 * This library is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * Lesser General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU Lesser General Public
 
17
 * License along with this library; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 */
 
20
 
 
21
/**
 
22
 * @file h261.c
 
23
 * h261codec.
 
24
 */
 
25
 
 
26
#include "common.h"
 
27
#include "dsputil.h"
 
28
#include "avcodec.h"
 
29
#include "mpegvideo.h"
 
30
#include "h261data.h"
 
31
 
 
32
 
 
33
#define H261_MBA_VLC_BITS 9
 
34
#define H261_MTYPE_VLC_BITS 6
 
35
#define H261_MV_VLC_BITS 7
 
36
#define H261_CBP_VLC_BITS 9
 
37
#define TCOEFF_VLC_BITS 9
 
38
 
 
39
#define MBA_STUFFING 33
 
40
#define MBA_STARTCODE 34
 
41
#define IS_FIL(a)    ((a)&MB_TYPE_H261_FIL)
 
42
 
 
43
/**
 
44
 * H261Context
 
45
 */
 
46
typedef struct H261Context{
 
47
    MpegEncContext s;
 
48
 
 
49
    int current_mba;
 
50
    int previous_mba;
 
51
    int mba_diff;
 
52
    int mtype;
 
53
    int current_mv_x;
 
54
    int current_mv_y;
 
55
    int gob_number;
 
56
    int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
 
57
}H261Context;
 
58
 
 
59
void ff_h261_loop_filter(MpegEncContext *s){
 
60
    H261Context * h= (H261Context*)s;
 
61
    const int linesize  = s->linesize;
 
62
    const int uvlinesize= s->uvlinesize;
 
63
    uint8_t *dest_y = s->dest[0];
 
64
    uint8_t *dest_cb= s->dest[1];
 
65
    uint8_t *dest_cr= s->dest[2];
 
66
 
 
67
    if(!(IS_FIL (h->mtype)))
 
68
        return;
 
69
 
 
70
    s->dsp.h261_loop_filter(dest_y                   , linesize);
 
71
    s->dsp.h261_loop_filter(dest_y                + 8, linesize);
 
72
    s->dsp.h261_loop_filter(dest_y + 8 * linesize    , linesize);
 
73
    s->dsp.h261_loop_filter(dest_y + 8 * linesize + 8, linesize);
 
74
    s->dsp.h261_loop_filter(dest_cb, uvlinesize);
 
75
    s->dsp.h261_loop_filter(dest_cr, uvlinesize);
 
76
}
 
77
 
 
78
static int ff_h261_get_picture_format(int width, int height){
 
79
    // QCIF
 
80
    if (width == 176 && height == 144)
 
81
        return 0;
 
82
    // CIF
 
83
    else if (width == 352 && height == 288)
 
84
        return 1;
 
85
    // ERROR
 
86
    else
 
87
        return -1;
 
88
}
 
89
 
 
90
static void h261_encode_block(H261Context * h, DCTELEM * block,
 
91
                              int n);
 
92
static int h261_decode_block(H261Context *h, DCTELEM *block,
 
93
                             int n, int coded);
 
94
 
 
95
void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
 
96
    H261Context * h = (H261Context *) s;
 
97
    int format, temp_ref;
 
98
 
 
99
    align_put_bits(&s->pb);
 
100
 
 
101
    /* Update the pointer to last GOB */
 
102
    s->ptr_lastgob = pbBufPtr(&s->pb);
 
103
 
 
104
    put_bits(&s->pb, 20, 0x10); /* PSC */
 
105
 
 
106
    temp_ref= s->picture_number * (int64_t)30000 * s->avctx->time_base.num / 
 
107
                         (1001 * (int64_t)s->avctx->time_base.den); //FIXME maybe this should use a timestamp
 
108
    put_bits(&s->pb, 5, temp_ref & 0x1f); /* TemporalReference */
 
109
 
 
110
    put_bits(&s->pb, 1, 0); /* split screen off */
 
111
    put_bits(&s->pb, 1, 0); /* camera  off */
 
112
    put_bits(&s->pb, 1, 0); /* freeze picture release off */
 
113
    
 
114
    format = ff_h261_get_picture_format(s->width, s->height);
 
115
    
 
116
    put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
 
117
 
 
118
    put_bits(&s->pb, 1, 0); /* still image mode */
 
119
    put_bits(&s->pb, 1, 0); /* reserved */
 
120
 
 
121
    put_bits(&s->pb, 1, 0); /* no PEI */    
 
122
    if(format == 0)
 
123
        h->gob_number = -1;
 
124
    else
 
125
        h->gob_number = 0;
 
126
    h->current_mba = 0;
 
127
}
 
128
 
 
129
/**
 
130
 * Encodes a group of blocks header.
 
131
 */
 
132
static void h261_encode_gob_header(MpegEncContext * s, int mb_line){
 
133
    H261Context * h = (H261Context *)s;
 
134
    if(ff_h261_get_picture_format(s->width, s->height) == 0){
 
135
        h->gob_number+=2; // QCIF
 
136
    }
 
137
    else{
 
138
        h->gob_number++; // CIF
 
139
    }
 
140
    put_bits(&s->pb, 16, 1); /* GBSC */
 
141
    put_bits(&s->pb, 4, h->gob_number); /* GN */
 
142
    put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 
143
    put_bits(&s->pb, 1, 0); /* no GEI */
 
144
    h->current_mba = 0;
 
145
    h->previous_mba = 0;
 
146
    h->current_mv_x=0;
 
147
    h->current_mv_y=0;
 
148
}
 
149
 
 
150
void ff_h261_reorder_mb_index(MpegEncContext* s){
 
151
    int index= s->mb_x + s->mb_y*s->mb_width;
 
152
 
 
153
    if(index % 33 == 0)
 
154
        h261_encode_gob_header(s,0);
 
155
 
 
156
    /* for CIF the GOB's are fragmented in the middle of a scanline
 
157
       that's why we need to adjust the x and y index of the macroblocks */
 
158
    if(ff_h261_get_picture_format(s->width,s->height) == 1){ // CIF
 
159
        s->mb_x =     index % 11 ; index /= 11;
 
160
        s->mb_y =     index %  3 ; index /=  3;
 
161
        s->mb_x+= 11*(index %  2); index /=  2;
 
162
        s->mb_y+=  3*index;
 
163
        
 
164
        ff_init_block_index(s);
 
165
        ff_update_block_index(s);
 
166
    }
 
167
}
 
168
 
 
169
static void h261_encode_motion(H261Context * h, int val){
 
170
    MpegEncContext * const s = &h->s;
 
171
    int sign, code;
 
172
    if(val==0){
 
173
        code = 0;
 
174
        put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
 
175
    } 
 
176
    else{
 
177
        if(val > 15)
 
178
            val -=32;
 
179
        if(val < -16)
 
180
            val+=32;
 
181
        sign = val < 0;
 
182
        code = sign ? -val : val; 
 
183
        put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
 
184
        put_bits(&s->pb,1,sign);
 
185
    }
 
186
}
 
187
 
 
188
static inline int get_cbp(MpegEncContext * s,
 
189
                      DCTELEM block[6][64])
 
190
{
 
191
    int i, cbp;
 
192
    cbp= 0;
 
193
    for (i = 0; i < 6; i++) {
 
194
        if (s->block_last_index[i] >= 0)
 
195
            cbp |= 1 << (5 - i);
 
196
    }
 
197
    return cbp;
 
198
}
 
199
void ff_h261_encode_mb(MpegEncContext * s,
 
200
         DCTELEM block[6][64],
 
201
         int motion_x, int motion_y)
 
202
{
 
203
    H261Context * h = (H261Context *)s;
 
204
    int mvd, mv_diff_x, mv_diff_y, i, cbp;
 
205
    cbp = 63; // avoid warning
 
206
    mvd = 0;
 
207
 
 
208
    h->current_mba++;
 
209
    h->mtype = 0;
 
210
 
 
211
    if (!s->mb_intra){
 
212
        /* compute cbp */
 
213
        cbp= get_cbp(s, block);
 
214
   
 
215
        /* mvd indicates if this block is motion compensated */
 
216
        mvd = motion_x | motion_y;
 
217
 
 
218
        if((cbp | mvd | s->dquant ) == 0) {
 
219
            /* skip macroblock */
 
220
            s->skip_count++;
 
221
            h->current_mv_x=0;
 
222
            h->current_mv_y=0;
 
223
            return;
 
224
        }
 
225
    }
 
226
 
 
227
    /* MB is not skipped, encode MBA */
 
228
    put_bits(&s->pb, h261_mba_bits[(h->current_mba-h->previous_mba)-1], h261_mba_code[(h->current_mba-h->previous_mba)-1]);
 
229
 
 
230
    /* calculate MTYPE */
 
231
    if(!s->mb_intra){
 
232
        h->mtype++;
 
233
        
 
234
        if(mvd || s->loop_filter)
 
235
            h->mtype+=3;
 
236
        if(s->loop_filter)
 
237
            h->mtype+=3;
 
238
        if(cbp || s->dquant)
 
239
            h->mtype++;
 
240
        assert(h->mtype > 1);
 
241
    }
 
242
 
 
243
    if(s->dquant) 
 
244
        h->mtype++;
 
245
 
 
246
    put_bits(&s->pb, h261_mtype_bits[h->mtype], h261_mtype_code[h->mtype]);
 
247
 
 
248
    h->mtype = h261_mtype_map[h->mtype];
 
249
 
 
250
    if(IS_QUANT(h->mtype)){
 
251
        ff_set_qscale(s,s->qscale+s->dquant);
 
252
        put_bits(&s->pb, 5, s->qscale);
 
253
    }
 
254
 
 
255
    if(IS_16X16(h->mtype)){
 
256
        mv_diff_x = (motion_x >> 1) - h->current_mv_x;
 
257
        mv_diff_y = (motion_y >> 1) - h->current_mv_y;
 
258
        h->current_mv_x = (motion_x >> 1);
 
259
        h->current_mv_y = (motion_y >> 1);
 
260
        h261_encode_motion(h,mv_diff_x);
 
261
        h261_encode_motion(h,mv_diff_y);
 
262
    }
 
263
 
 
264
    h->previous_mba = h->current_mba;
 
265
 
 
266
    if(HAS_CBP(h->mtype)){
 
267
        put_bits(&s->pb,h261_cbp_tab[cbp-1][1],h261_cbp_tab[cbp-1][0]); 
 
268
    }
 
269
    for(i=0; i<6; i++) {
 
270
        /* encode each block */
 
271
        h261_encode_block(h, block[i], i);
 
272
    }
 
273
 
 
274
    if ( ( h->current_mba == 11 ) || ( h->current_mba == 22 ) || ( h->current_mba == 33 ) || ( !IS_16X16 ( h->mtype ) )){
 
275
        h->current_mv_x=0;
 
276
        h->current_mv_y=0;
 
277
    }
 
278
}
 
279
 
 
280
void ff_h261_encode_init(MpegEncContext *s){
 
281
    static int done = 0;
 
282
    
 
283
    if (!done) {
 
284
        done = 1;
 
285
        init_rl(&h261_rl_tcoeff, 1);
 
286
    }
 
287
 
 
288
    s->min_qcoeff= -127;
 
289
    s->max_qcoeff=  127;
 
290
    s->y_dc_scale_table=
 
291
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 
292
}
 
293
 
 
294
 
 
295
/**
 
296
 * encodes a 8x8 block.
 
297
 * @param block the 8x8 block
 
298
 * @param n block index (0-3 are luma, 4-5 are chroma)
 
299
 */
 
300
static void h261_encode_block(H261Context * h, DCTELEM * block, int n){
 
301
    MpegEncContext * const s = &h->s;
 
302
    int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
 
303
    RLTable *rl;
 
304
 
 
305
    rl = &h261_rl_tcoeff;
 
306
    if (s->mb_intra) {
 
307
        /* DC coef */
 
308
        level = block[0];
 
309
        /* 255 cannot be represented, so we clamp */
 
310
        if (level > 254) {
 
311
            level = 254;
 
312
            block[0] = 254;
 
313
        }
 
314
        /* 0 cannot be represented also */
 
315
        else if (level < 1) {
 
316
            level = 1;
 
317
            block[0] = 1;
 
318
        }
 
319
        if (level == 128)
 
320
            put_bits(&s->pb, 8, 0xff);
 
321
        else
 
322
            put_bits(&s->pb, 8, level);
 
323
        i = 1;
 
324
    } else if((block[0]==1 || block[0] == -1) && (s->block_last_index[n] > -1)){
 
325
        //special case
 
326
        put_bits(&s->pb,2,block[0]>0 ? 2 : 3 );
 
327
        i = 1;
 
328
    } else {
 
329
        i = 0;
 
330
    }
 
331
   
 
332
    /* AC coefs */
 
333
    last_index = s->block_last_index[n];
 
334
    last_non_zero = i - 1;
 
335
    for (; i <= last_index; i++) {
 
336
        j = s->intra_scantable.permutated[i];
 
337
        level = block[j];
 
338
        if (level) {
 
339
            run = i - last_non_zero - 1;
 
340
            last = (i == last_index);
 
341
            sign = 0;
 
342
            slevel = level;
 
343
            if (level < 0) {
 
344
                sign = 1;
 
345
                level = -level;
 
346
            }
 
347
            code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/, run, level);
 
348
            if(run==0 && level < 16)
 
349
            code+=1;
 
350
            put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 
351
            if (code == rl->n) {
 
352
                put_bits(&s->pb, 6, run);
 
353
                assert(slevel != 0);
 
354
                assert(level <= 127);
 
355
                put_bits(&s->pb, 8, slevel & 0xff);
 
356
            } else {
 
357
                put_bits(&s->pb, 1, sign);
 
358
            }
 
359
            last_non_zero = i;
 
360
        }
 
361
    }
 
362
    if(last_index > -1){
 
363
        put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]);// END OF BLOCK
 
364
    }
 
365
}
 
366
 
 
367
/***********************************************/
 
368
/* decoding */
 
369
 
 
370
static VLC h261_mba_vlc;
 
371
static VLC h261_mtype_vlc;
 
372
static VLC h261_mv_vlc;
 
373
static VLC h261_cbp_vlc;
 
374
 
 
375
void init_vlc_rl(RLTable *rl, int use_static);
 
376
 
 
377
static void h261_decode_init_vlc(H261Context *h){
 
378
    static int done = 0;
 
379
 
 
380
    if(!done){
 
381
        done = 1;
 
382
        init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
 
383
                 h261_mba_bits, 1, 1,
 
384
                 h261_mba_code, 1, 1, 1);
 
385
        init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
 
386
                 h261_mtype_bits, 1, 1,
 
387
                 h261_mtype_code, 1, 1, 1);
 
388
        init_vlc(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
 
389
                 &h261_mv_tab[0][1], 2, 1,
 
390
                 &h261_mv_tab[0][0], 2, 1, 1);
 
391
        init_vlc(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
 
392
                 &h261_cbp_tab[0][1], 2, 1,
 
393
                 &h261_cbp_tab[0][0], 2, 1, 1);
 
394
        init_rl(&h261_rl_tcoeff, 1);
 
395
        init_vlc_rl(&h261_rl_tcoeff, 1);
 
396
    }
 
397
}
 
398
 
 
399
static int h261_decode_init(AVCodecContext *avctx){
 
400
    H261Context *h= avctx->priv_data;
 
401
    MpegEncContext * const s = &h->s;
 
402
 
 
403
    // set defaults
 
404
    MPV_decode_defaults(s);
 
405
    s->avctx = avctx;
 
406
 
 
407
    s->width  = s->avctx->coded_width;
 
408
    s->height = s->avctx->coded_height;
 
409
    s->codec_id = s->avctx->codec->id;
 
410
 
 
411
    s->out_format = FMT_H261;
 
412
    s->low_delay= 1;
 
413
    avctx->pix_fmt= PIX_FMT_YUV420P;
 
414
 
 
415
    s->codec_id= avctx->codec->id;
 
416
 
 
417
    h261_decode_init_vlc(h);
 
418
 
 
419
    h->gob_start_code_skipped = 0;
 
420
    
 
421
    return 0;
 
422
}
 
423
 
 
424
/**
 
425
 * decodes the group of blocks header or slice header.
 
426
 * @return <0 if an error occured
 
427
 */
 
428
static int h261_decode_gob_header(H261Context *h){
 
429
    unsigned int val;
 
430
    MpegEncContext * const s = &h->s;
 
431
    
 
432
    if ( !h->gob_start_code_skipped ){
 
433
        /* Check for GOB Start Code */
 
434
        val = show_bits(&s->gb, 15);
 
435
        if(val)
 
436
            return -1;
 
437
 
 
438
        /* We have a GBSC */
 
439
        skip_bits(&s->gb, 16);
 
440
    }
 
441
 
 
442
    h->gob_start_code_skipped = 0;
 
443
 
 
444
    h->gob_number = get_bits(&s->gb, 4); /* GN */
 
445
    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
 
446
 
 
447
    /* Check if gob_number is valid */
 
448
    if (s->mb_height==18){ //cif
 
449
        if ((h->gob_number<=0) || (h->gob_number>12))
 
450
            return -1;
 
451
    }
 
452
    else{ //qcif
 
453
        if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5))
 
454
            return -1;
 
455
    }
 
456
 
 
457
    /* GEI */
 
458
    while (get_bits1(&s->gb) != 0) {
 
459
        skip_bits(&s->gb, 8);
 
460
    }
 
461
 
 
462
    if(s->qscale==0)
 
463
        return -1;
 
464
 
 
465
    // For the first transmitted macroblock in a GOB, MBA is the absolute address. For
 
466
    // subsequent macroblocks, MBA is the difference between the absolute addresses of
 
467
    // the macroblock and the last transmitted macroblock.
 
468
    h->current_mba = 0;
 
469
    h->mba_diff = 0;
 
470
 
 
471
    return 0;
 
472
}
 
473
 
 
474
/**
 
475
 * decodes the group of blocks / video packet header.
 
476
 * @return <0 if no resync found
 
477
 */
 
478
static int ff_h261_resync(H261Context *h){
 
479
    MpegEncContext * const s = &h->s;
 
480
    int left, ret;
 
481
 
 
482
    if ( h->gob_start_code_skipped ){
 
483
        ret= h261_decode_gob_header(h);
 
484
        if(ret>=0)
 
485
            return 0;
 
486
    }
 
487
    else{
 
488
        if(show_bits(&s->gb, 15)==0){
 
489
            ret= h261_decode_gob_header(h);
 
490
            if(ret>=0)
 
491
                return 0;
 
492
        }
 
493
        //ok, its not where its supposed to be ...
 
494
        s->gb= s->last_resync_gb;
 
495
        align_get_bits(&s->gb);
 
496
        left= s->gb.size_in_bits - get_bits_count(&s->gb);
 
497
 
 
498
        for(;left>15+1+4+5; left-=8){
 
499
            if(show_bits(&s->gb, 15)==0){
 
500
                GetBitContext bak= s->gb;
 
501
 
 
502
                ret= h261_decode_gob_header(h);
 
503
                if(ret>=0)
 
504
                    return 0;
 
505
 
 
506
                s->gb= bak;
 
507
            }
 
508
            skip_bits(&s->gb, 8);
 
509
        }
 
510
    }
 
511
 
 
512
    return -1;
 
513
}
 
514
 
 
515
/**
 
516
 * decodes skipped macroblocks
 
517
 * @return 0
 
518
 */
 
519
static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
 
520
{
 
521
    MpegEncContext * const s = &h->s;
 
522
    int i;
 
523
    
 
524
    s->mb_intra = 0;
 
525
 
 
526
    for(i=mba1; i<mba2; i++){
 
527
        int j, xy;
 
528
 
 
529
        s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
 
530
        s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
 
531
        xy = s->mb_x + s->mb_y * s->mb_stride;
 
532
        ff_init_block_index(s);
 
533
        ff_update_block_index(s);
 
534
 
 
535
        for(j=0;j<6;j++)
 
536
            s->block_last_index[j] = -1;
 
537
 
 
538
        s->mv_dir = MV_DIR_FORWARD;
 
539
        s->mv_type = MV_TYPE_16X16;
 
540
        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
 
541
        s->mv[0][0][0] = 0;
 
542
        s->mv[0][0][1] = 0;
 
543
        s->mb_skipped = 1;
 
544
        h->mtype &= ~MB_TYPE_H261_FIL;
 
545
 
 
546
        MPV_decode_mb(s, s->block);
 
547
    }
 
548
 
 
549
    return 0;
 
550
}
 
551
 
 
552
static int decode_mv_component(GetBitContext *gb, int v){
 
553
    int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
 
554
 
 
555
    /* check if mv_diff is valid */
 
556
    if ( mv_diff < 0 )
 
557
        return v;
 
558
 
 
559
    mv_diff = mvmap[mv_diff];
 
560
 
 
561
    if(mv_diff && !get_bits1(gb))
 
562
        mv_diff= -mv_diff;
 
563
    
 
564
    v += mv_diff;
 
565
    if     (v <=-16) v+= 32;
 
566
    else if(v >= 16) v-= 32;
 
567
 
 
568
    return v;
 
569
}
 
570
 
 
571
static int h261_decode_mb(H261Context *h){
 
572
    MpegEncContext * const s = &h->s;
 
573
    int i, cbp, xy;
 
574
 
 
575
    cbp = 63;
 
576
    // Read mba
 
577
    do{
 
578
        h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
 
579
 
 
580
        /* Check for slice end */
 
581
        /* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
 
582
        if (h->mba_diff == MBA_STARTCODE){ // start code
 
583
            h->gob_start_code_skipped = 1;
 
584
            return SLICE_END;
 
585
        }
 
586
    }
 
587
    while( h->mba_diff == MBA_STUFFING ); // stuffing
 
588
 
 
589
    if ( h->mba_diff < 0 ){
 
590
        if ( get_bits_count(&s->gb) + 7 >= s->gb.size_in_bits )
 
591
            return SLICE_END;
 
592
 
 
593
        av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
 
594
        return SLICE_ERROR;
 
595
    }
 
596
 
 
597
    h->mba_diff += 1;
 
598
    h->current_mba += h->mba_diff;
 
599
 
 
600
    if ( h->current_mba > MBA_STUFFING )
 
601
        return SLICE_ERROR;
 
602
    
 
603
    s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
 
604
    s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
 
605
    xy = s->mb_x + s->mb_y * s->mb_stride;
 
606
    ff_init_block_index(s);
 
607
    ff_update_block_index(s);
 
608
 
 
609
    // Read mtype
 
610
    h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
 
611
    h->mtype = h261_mtype_map[h->mtype];
 
612
 
 
613
    // Read mquant
 
614
    if ( IS_QUANT ( h->mtype ) ){
 
615
        ff_set_qscale(s, get_bits(&s->gb, 5));
 
616
    }
 
617
 
 
618
    s->mb_intra = IS_INTRA4x4(h->mtype);
 
619
 
 
620
    // Read mv
 
621
    if ( IS_16X16 ( h->mtype ) ){
 
622
        // Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the
 
623
        // vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the
 
624
        // following three situations:
 
625
        // 1) evaluating MVD for macroblocks 1, 12 and 23;
 
626
        // 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
 
627
        // 3) MTYPE of the previous macroblock was not MC.
 
628
        if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
 
629
             ( h->mba_diff != 1))
 
630
        {
 
631
            h->current_mv_x = 0;
 
632
            h->current_mv_y = 0;
 
633
        }
 
634
 
 
635
        h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
 
636
        h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
 
637
    }else{
 
638
        h->current_mv_x = 0;
 
639
        h->current_mv_y = 0;
 
640
    }
 
641
 
 
642
    // Read cbp
 
643
    if ( HAS_CBP( h->mtype ) ){
 
644
        cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
 
645
    }
 
646
 
 
647
    if(s->mb_intra){
 
648
        s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
 
649
        goto intra;
 
650
    }
 
651
 
 
652
    //set motion vectors
 
653
    s->mv_dir = MV_DIR_FORWARD;
 
654
    s->mv_type = MV_TYPE_16X16;
 
655
    s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
 
656
    s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
 
657
    s->mv[0][0][1] = h->current_mv_y * 2;
 
658
 
 
659
intra:
 
660
    /* decode each block */
 
661
    if(s->mb_intra || HAS_CBP(h->mtype)){
 
662
        s->dsp.clear_blocks(s->block[0]);
 
663
        for (i = 0; i < 6; i++) {
 
664
            if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
 
665
                return SLICE_ERROR;
 
666
            }
 
667
            cbp+=cbp;
 
668
        }
 
669
    }else{
 
670
        for (i = 0; i < 6; i++)
 
671
            s->block_last_index[i]= -1;
 
672
    }
 
673
 
 
674
    MPV_decode_mb(s, s->block);
 
675
 
 
676
    return SLICE_OK;
 
677
}
 
678
 
 
679
/**
 
680
 * decodes a macroblock
 
681
 * @return <0 if an error occured
 
682
 */
 
683
static int h261_decode_block(H261Context * h, DCTELEM * block,
 
684
                             int n, int coded)
 
685
{
 
686
    MpegEncContext * const s = &h->s;
 
687
    int code, level, i, j, run;
 
688
    RLTable *rl = &h261_rl_tcoeff;
 
689
    const uint8_t *scan_table;
 
690
    
 
691
    // For the variable length encoding there are two code tables, one being used for
 
692
    // the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second
 
693
    // for all other LEVELs except the first one in INTRA blocks which is fixed length
 
694
    // coded with 8 bits.
 
695
    // NOTE: the two code tables only differ in one VLC so we handle that manually.
 
696
    scan_table = s->intra_scantable.permutated;
 
697
    if (s->mb_intra){
 
698
        /* DC coef */
 
699
        level = get_bits(&s->gb, 8);
 
700
        // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
 
701
        if((level&0x7F) == 0){
 
702
            av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
 
703
            return -1;
 
704
        }
 
705
        // The code 1000 0000 is not used, the reconstruction level of 1024 being coded as 1111 1111.
 
706
        if (level == 255)
 
707
            level = 128;
 
708
        block[0] = level;
 
709
        i = 1;
 
710
    }else if(coded){
 
711
        // Run  Level   Code
 
712
        // EOB                  Not possible for first level when cbp is available (that's why the table is different)
 
713
        // 0    1               1s
 
714
        // *    *               0*
 
715
        int check = show_bits(&s->gb, 2);
 
716
        i = 0;
 
717
        if ( check & 0x2 ){
 
718
            skip_bits(&s->gb, 2);
 
719
            block[0] = ( check & 0x1 ) ? -1 : 1;
 
720
            i = 1;
 
721
        }
 
722
    }else{
 
723
        i = 0;
 
724
    }
 
725
    if(!coded){
 
726
        s->block_last_index[n] = i - 1;
 
727
        return 0;
 
728
    }
 
729
    for(;;){
 
730
        code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
 
731
        if (code < 0){
 
732
            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
 
733
            return -1;
 
734
        }
 
735
        if (code == rl->n) {
 
736
            /* escape */
 
737
            // The remaining combinations of (run, level) are encoded with a 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits level.
 
738
            run = get_bits(&s->gb, 6);
 
739
            level = get_sbits(&s->gb, 8);
 
740
        }else if(code == 0){
 
741
            break;
 
742
        }else{
 
743
            run = rl->table_run[code];
 
744
            level = rl->table_level[code];
 
745
            if (get_bits1(&s->gb))
 
746
                level = -level;
 
747
        }
 
748
        i += run;
 
749
        if (i >= 64){
 
750
            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
 
751
            return -1;
 
752
        }
 
753
        j = scan_table[i];
 
754
        block[j] = level;
 
755
        i++;
 
756
    }
 
757
    s->block_last_index[n] = i-1;
 
758
    return 0;
 
759
}
 
760
 
 
761
/**
 
762
 * decodes the H261 picture header.
 
763
 * @return <0 if no startcode found
 
764
 */
 
765
int h261_decode_picture_header(H261Context *h){
 
766
    MpegEncContext * const s = &h->s;
 
767
    int format, i;
 
768
    uint32_t startcode= 0;
 
769
 
 
770
    for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=1){
 
771
        startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
 
772
 
 
773
        if(startcode == 0x10)
 
774
            break;
 
775
    }
 
776
 
 
777
    if (startcode != 0x10){
 
778
        av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
 
779
        return -1;
 
780
    }
 
781
 
 
782
    /* temporal reference */
 
783
    s->picture_number = get_bits(&s->gb, 5); /* picture timestamp */
 
784
 
 
785
    /* PTYPE starts here */
 
786
    skip_bits1(&s->gb); /* split screen off */
 
787
    skip_bits1(&s->gb); /* camera  off */
 
788
    skip_bits1(&s->gb); /* freeze picture release off */
 
789
 
 
790
    format = get_bits1(&s->gb);
 
791
 
 
792
    //only 2 formats possible
 
793
    if (format == 0){//QCIF
 
794
        s->width = 176;
 
795
        s->height = 144;
 
796
        s->mb_width = 11;
 
797
        s->mb_height = 9;
 
798
    }else{//CIF
 
799
        s->width = 352;
 
800
        s->height = 288;
 
801
        s->mb_width = 22;
 
802
        s->mb_height = 18;
 
803
    }
 
804
 
 
805
    s->mb_num = s->mb_width * s->mb_height;
 
806
 
 
807
    skip_bits1(&s->gb); /* still image mode off */
 
808
    skip_bits1(&s->gb); /* Reserved */
 
809
 
 
810
    /* PEI */
 
811
    while (get_bits1(&s->gb) != 0){
 
812
        skip_bits(&s->gb, 8);
 
813
    }
 
814
 
 
815
    // h261 has no I-FRAMES, but if we pass I_TYPE for the first frame, the codec crashes if it does 
 
816
    // not contain all I-blocks (e.g. when a packet is lost)
 
817
    s->pict_type = P_TYPE;
 
818
 
 
819
    h->gob_number = 0;
 
820
    return 0;
 
821
}
 
822
 
 
823
static int h261_decode_gob(H261Context *h){
 
824
    MpegEncContext * const s = &h->s;
 
825
    
 
826
    ff_set_qscale(s, s->qscale);
 
827
 
 
828
    /* decode mb's */
 
829
    while(h->current_mba <= MBA_STUFFING)
 
830
    {
 
831
        int ret;
 
832
        /* DCT & quantize */
 
833
        ret= h261_decode_mb(h);
 
834
        if(ret<0){
 
835
            if(ret==SLICE_END){
 
836
                h261_decode_mb_skipped(h, h->current_mba, 33);                
 
837
                return 0;
 
838
            }
 
839
            av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
 
840
            return -1;
 
841
        }
 
842
        
 
843
        h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
 
844
    }
 
845
    
 
846
    return -1;
 
847
}
 
848
 
 
849
static int h261_find_frame_end(ParseContext *pc, AVCodecContext* avctx, const uint8_t *buf, int buf_size){
 
850
    int vop_found, i, j;
 
851
    uint32_t state;
 
852
 
 
853
    vop_found= pc->frame_start_found;
 
854
    state= pc->state;
 
855
   
 
856
    for(i=0; i<buf_size && !vop_found; i++){
 
857
        state= (state<<8) | buf[i];
 
858
        for(j=0; j<8; j++){
 
859
            if(((state>>j)&0xFFFFF) == 0x00010){
 
860
                i++;
 
861
                vop_found=1;
 
862
                break;
 
863
            }
 
864
        }
 
865
    }
 
866
    if(vop_found){
 
867
        for(; i<buf_size; i++){
 
868
            state= (state<<8) | buf[i];
 
869
            for(j=0; j<8; j++){
 
870
                if(((state>>j)&0xFFFFF) == 0x00010){
 
871
                    pc->frame_start_found=0;
 
872
                    pc->state= state>>(2*8);
 
873
                    return i-1;
 
874
                }
 
875
            }
 
876
        }
 
877
    }
 
878
 
 
879
    pc->frame_start_found= vop_found;
 
880
    pc->state= state;
 
881
    return END_NOT_FOUND;
 
882
}
 
883
 
 
884
static int h261_parse(AVCodecParserContext *s,
 
885
                      AVCodecContext *avctx,
 
886
                      uint8_t **poutbuf, int *poutbuf_size, 
 
887
                      const uint8_t *buf, int buf_size)
 
888
{
 
889
    ParseContext *pc = s->priv_data;
 
890
    int next;
 
891
    
 
892
    next= h261_find_frame_end(pc,avctx, buf, buf_size);
 
893
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 
894
        *poutbuf = NULL;
 
895
        *poutbuf_size = 0;
 
896
        return buf_size;
 
897
    }
 
898
    *poutbuf = (uint8_t *)buf;
 
899
    *poutbuf_size = buf_size;
 
900
    return next;
 
901
}
 
902
 
 
903
/**
 
904
 * returns the number of bytes consumed for building the current frame
 
905
 */
 
906
static int get_consumed_bytes(MpegEncContext *s, int buf_size){
 
907
    int pos= get_bits_count(&s->gb)>>3;
 
908
    if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
 
909
    if(pos+10>buf_size) pos=buf_size; // oops ;)
 
910
 
 
911
    return pos;
 
912
}
 
913
 
 
914
static int h261_decode_frame(AVCodecContext *avctx,
 
915
                             void *data, int *data_size,
 
916
                             uint8_t *buf, int buf_size)
 
917
{
 
918
    H261Context *h= avctx->priv_data;
 
919
    MpegEncContext *s = &h->s;
 
920
    int ret;
 
921
    AVFrame *pict = data;
 
922
 
 
923
#ifdef DEBUG
 
924
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 
925
    printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
 
926
#endif
 
927
    s->flags= avctx->flags;
 
928
    s->flags2= avctx->flags2;
 
929
 
 
930
    h->gob_start_code_skipped=0;
 
931
 
 
932
retry:
 
933
 
 
934
    init_get_bits(&s->gb, buf, buf_size*8);
 
935
 
 
936
    if(!s->context_initialized){
 
937
        if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
 
938
            return -1;
 
939
    }
 
940
 
 
941
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
 
942
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
 
943
        int i= ff_find_unused_picture(s, 0);
 
944
        s->current_picture_ptr= &s->picture[i];
 
945
    }
 
946
 
 
947
    ret = h261_decode_picture_header(h);
 
948
 
 
949
    /* skip if the header was thrashed */
 
950
    if (ret < 0){
 
951
        av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
 
952
        return -1;
 
953
    }
 
954
 
 
955
    if (s->width != avctx->coded_width || s->height != avctx->coded_height){
 
956
        ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
 
957
        s->parse_context.buffer=0;
 
958
        MPV_common_end(s);
 
959
        s->parse_context= pc;
 
960
    }
 
961
    if (!s->context_initialized) {
 
962
        avcodec_set_dimensions(avctx, s->width, s->height);
 
963
 
 
964
        goto retry;
 
965
    }
 
966
 
 
967
    // for hurry_up==5
 
968
    s->current_picture.pict_type= s->pict_type;
 
969
    s->current_picture.key_frame= s->pict_type == I_TYPE;
 
970
 
 
971
    /* skip everything if we are in a hurry>=5 */
 
972
    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
 
973
    if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
 
974
       ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
 
975
       || avctx->skip_frame >= AVDISCARD_ALL)
 
976
        return get_consumed_bytes(s, buf_size);
 
977
 
 
978
    if(MPV_frame_start(s, avctx) < 0)
 
979
        return -1;
 
980
 
 
981
    ff_er_frame_start(s);
 
982
 
 
983
    /* decode each macroblock */
 
984
    s->mb_x=0;
 
985
    s->mb_y=0;
 
986
 
 
987
    while(h->gob_number < (s->mb_height==18 ? 12 : 5)){
 
988
        if(ff_h261_resync(h)<0)
 
989
            break;
 
990
        h261_decode_gob(h);
 
991
    }
 
992
    MPV_frame_end(s);
 
993
 
 
994
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
 
995
assert(s->current_picture.pict_type == s->pict_type);
 
996
    *pict= *(AVFrame*)s->current_picture_ptr;
 
997
    ff_print_debug_info(s, pict);
 
998
 
 
999
    /* Return the Picture timestamp as the frame number */
 
1000
    /* we substract 1 because it is added on utils.c    */
 
1001
    avctx->frame_number = s->picture_number - 1;
 
1002
 
 
1003
    *data_size = sizeof(AVFrame);
 
1004
 
 
1005
    return get_consumed_bytes(s, buf_size);
 
1006
}
 
1007
 
 
1008
static int h261_decode_end(AVCodecContext *avctx)
 
1009
{
 
1010
    H261Context *h= avctx->priv_data;
 
1011
    MpegEncContext *s = &h->s;
 
1012
 
 
1013
    MPV_common_end(s);
 
1014
    return 0;
 
1015
}
 
1016
 
 
1017
#ifdef CONFIG_ENCODERS
 
1018
AVCodec h261_encoder = {
 
1019
    "h261",
 
1020
    CODEC_TYPE_VIDEO,
 
1021
    CODEC_ID_H261,
 
1022
    sizeof(H261Context),
 
1023
    MPV_encode_init,
 
1024
    MPV_encode_picture,
 
1025
    MPV_encode_end,
 
1026
};
 
1027
#endif
 
1028
 
 
1029
AVCodec h261_decoder = {
 
1030
    "h261",
 
1031
    CODEC_TYPE_VIDEO,
 
1032
    CODEC_ID_H261,
 
1033
    sizeof(H261Context),
 
1034
    h261_decode_init,
 
1035
    NULL,
 
1036
    h261_decode_end,
 
1037
    h261_decode_frame,
 
1038
    CODEC_CAP_DR1,
 
1039
};
 
1040
 
 
1041
AVCodecParser h261_parser = {
 
1042
    { CODEC_ID_H261 },
 
1043
    sizeof(ParseContext),
 
1044
    NULL,
 
1045
    h261_parse,
 
1046
    ff_parse_close,
 
1047
};