← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mplayer2/oneiric-proposed

« back to all changes in this revision

Viewing changes to ffmpeg-mt/libavcodec/mpeg4videodec.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 22:48:03 UTC
  • Revision ID: james.westby@ubuntu.com-20110320224803-kc2nlrxz6pcphmf1
Tags: upstream-2.0~rc2
Import upstream version 2.0~rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg-mt/libavcodec/mpeg4videodec.c
 
1
/*
 
2
 * MPEG4 decoder.
 
3
 * Copyright (c) 2000,2001 Fabrice Bellard
 
4
 * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
 
5
 *
 
6
 * This file is part of FFmpeg.
 
7
 *
 
8
 * FFmpeg is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU Lesser General Public
 
10
 * License as published by the Free Software Foundation; either
 
11
 * version 2.1 of the License, or (at your option) any later version.
 
12
 *
 
13
 * FFmpeg is distributed in the hope that it will be useful,
 
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
16
 * Lesser General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU Lesser General Public
 
19
 * License along with FFmpeg; if not, write to the Free Software
 
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
21
 */
 
22
 
 
23
#include "mpegvideo.h"
 
24
#include "mpeg4video.h"
 
25
#include "h263.h"
 
26
#include "thread.h"
 
27
 
 
28
// The defines below define the number of bits that are read at once for
 
29
// reading vlc values. Changing these may improve speed and data cache needs
 
30
// be aware though that decreasing them may need the number of stages that is
 
31
// passed to get_vlc* to be increased.
 
32
#define SPRITE_TRAJ_VLC_BITS 6
 
33
#define DC_VLC_BITS 9
 
34
#define MB_TYPE_B_VLC_BITS 4
 
35
 
 
36
 
 
37
static VLC dc_lum, dc_chrom;
 
38
static VLC sprite_trajectory;
 
39
static VLC mb_type_b_vlc;
 
40
 
 
41
static const int mb_type_b_map[4]= {
 
42
    MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
 
43
    MB_TYPE_L0L1 | MB_TYPE_16x16,
 
44
    MB_TYPE_L1 | MB_TYPE_16x16,
 
45
    MB_TYPE_L0 | MB_TYPE_16x16,
 
46
};
 
47
 
 
48
/**
 
49
 * predicts the ac.
 
50
 * @param n block index (0-3 are luma, 4-5 are chroma)
 
51
 * @param dir the ac prediction direction
 
52
 */
 
53
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
 
54
                   int dir)
 
55
{
 
56
    int i;
 
57
    int16_t *ac_val, *ac_val1;
 
58
    int8_t * const qscale_table= s->current_picture.qscale_table;
 
59
 
 
60
    /* find prediction */
 
61
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 
62
    ac_val1 = ac_val;
 
63
    if (s->ac_pred) {
 
64
        if (dir == 0) {
 
65
            const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
 
66
            /* left prediction */
 
67
            ac_val -= 16;
 
68
 
 
69
            if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
 
70
                /* same qscale */
 
71
                for(i=1;i<8;i++) {
 
72
                    block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
 
73
                }
 
74
            }else{
 
75
                /* different qscale, we must rescale */
 
76
                for(i=1;i<8;i++) {
 
77
                    block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
 
78
                }
 
79
            }
 
80
        } else {
 
81
            const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
 
82
            /* top prediction */
 
83
            ac_val -= 16 * s->block_wrap[n];
 
84
 
 
85
            if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
 
86
                /* same qscale */
 
87
                for(i=1;i<8;i++) {
 
88
                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
 
89
                }
 
90
            }else{
 
91
                /* different qscale, we must rescale */
 
92
                for(i=1;i<8;i++) {
 
93
                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
 
94
                }
 
95
            }
 
96
        }
 
97
    }
 
98
    /* left copy */
 
99
    for(i=1;i<8;i++)
 
100
        ac_val1[i    ] = block[s->dsp.idct_permutation[i<<3]];
 
101
 
 
102
    /* top copy */
 
103
    for(i=1;i<8;i++)
 
104
        ac_val1[8 + i] = block[s->dsp.idct_permutation[i   ]];
 
105
 
 
106
}
 
107
 
 
108
/**
 
109
 * check if the next stuff is a resync marker or the end.
 
110
 * @return 0 if not
 
111
 */
 
112
static inline int mpeg4_is_resync(MpegEncContext *s){
 
113
    int bits_count= get_bits_count(&s->gb);
 
114
    int v= show_bits(&s->gb, 16);
 
115
 
 
116
    if(s->workaround_bugs&FF_BUG_NO_PADDING){
 
117
        return 0;
 
118
    }
 
119
 
 
120
    while(v<=0xFF){
 
121
        if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
 
122
            break;
 
123
        skip_bits(&s->gb, 8+s->pict_type);
 
124
        bits_count+= 8+s->pict_type;
 
125
        v= show_bits(&s->gb, 16);
 
126
    }
 
127
 
 
128
    if(bits_count + 8 >= s->gb.size_in_bits){
 
129
        v>>=8;
 
130
        v|= 0x7F >> (7-(bits_count&7));
 
131
 
 
132
        if(v==0x7F)
 
133
            return 1;
 
134
    }else{
 
135
        if(v == ff_mpeg4_resync_prefix[bits_count&7]){
 
136
            int len;
 
137
            GetBitContext gb= s->gb;
 
138
 
 
139
            skip_bits(&s->gb, 1);
 
140
            align_get_bits(&s->gb);
 
141
 
 
142
            for(len=0; len<32; len++){
 
143
                if(get_bits1(&s->gb)) break;
 
144
            }
 
145
 
 
146
            s->gb= gb;
 
147
 
 
148
            if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
 
149
                return 1;
 
150
        }
 
151
    }
 
152
    return 0;
 
153
}
 
154
 
 
155
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
 
156
{
 
157
    int i;
 
158
    int a= 2<<s->sprite_warping_accuracy;
 
159
    int rho= 3-s->sprite_warping_accuracy;
 
160
    int r=16/a;
 
161
    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
 
162
    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
 
163
    int sprite_ref[4][2];
 
164
    int virtual_ref[2][2];
 
165
    int w2, h2, w3, h3;
 
166
    int alpha=0, beta=0;
 
167
    int w= s->width;
 
168
    int h= s->height;
 
169
    int min_ab;
 
170
 
 
171
    for(i=0; i<s->num_sprite_warping_points; i++){
 
172
        int length;
 
173
        int x=0, y=0;
 
174
 
 
175
        length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
 
176
        if(length){
 
177
            x= get_xbits(gb, length);
 
178
        }
 
179
        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
 
180
 
 
181
        length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
 
182
        if(length){
 
183
            y=get_xbits(gb, length);
 
184
        }
 
185
        skip_bits1(gb); /* marker bit */
 
186
        s->sprite_traj[i][0]= d[i][0]= x;
 
187
        s->sprite_traj[i][1]= d[i][1]= y;
 
188
    }
 
189
    for(; i<4; i++)
 
190
        s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0;
 
191
 
 
192
    while((1<<alpha)<w) alpha++;
 
193
    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
 
194
    w2= 1<<alpha;
 
195
    h2= 1<<beta;
 
196
 
 
197
// Note, the 4th point isn't used for GMC
 
198
    if(s->divx_version==500 && s->divx_build==413){
 
199
        sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
 
200
        sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
 
201
        sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
 
202
        sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
 
203
        sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
 
204
        sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
 
205
    } else {
 
206
        sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
 
207
        sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
 
208
        sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
 
209
        sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
 
210
        sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
 
211
        sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
 
212
    }
 
213
/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
 
214
    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
 
215
 
 
216
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
 
217
// perhaps it should be reordered to be more readable ...
 
218
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
 
219
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
 
220
    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
 
221
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
 
222
    virtual_ref[0][1]= 16*vop_ref[0][1]
 
223
        + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
 
224
    virtual_ref[1][0]= 16*vop_ref[0][0]
 
225
        + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
 
226
    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
 
227
        + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
 
228
 
 
229
    switch(s->num_sprite_warping_points)
 
230
    {
 
231
        case 0:
 
232
            s->sprite_offset[0][0]= 0;
 
233
            s->sprite_offset[0][1]= 0;
 
234
            s->sprite_offset[1][0]= 0;
 
235
            s->sprite_offset[1][1]= 0;
 
236
            s->sprite_delta[0][0]= a;
 
237
            s->sprite_delta[0][1]= 0;
 
238
            s->sprite_delta[1][0]= 0;
 
239
            s->sprite_delta[1][1]= a;
 
240
            s->sprite_shift[0]= 0;
 
241
            s->sprite_shift[1]= 0;
 
242
            break;
 
243
        case 1: //GMC only
 
244
            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
 
245
            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
 
246
            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
 
247
            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
 
248
            s->sprite_delta[0][0]= a;
 
249
            s->sprite_delta[0][1]= 0;
 
250
            s->sprite_delta[1][0]= 0;
 
251
            s->sprite_delta[1][1]= a;
 
252
            s->sprite_shift[0]= 0;
 
253
            s->sprite_shift[1]= 0;
 
254
            break;
 
255
        case 2:
 
256
            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
 
257
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
 
258
                                                  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
 
259
                                                  + (1<<(alpha+rho-1));
 
260
            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
 
261
                                                  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
 
262
                                                  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
 
263
                                                  + (1<<(alpha+rho-1));
 
264
            s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
 
265
                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
 
266
                                     +2*w2*r*sprite_ref[0][0]
 
267
                                     - 16*w2
 
268
                                     + (1<<(alpha+rho+1)));
 
269
            s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
 
270
                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
 
271
                                     +2*w2*r*sprite_ref[0][1]
 
272
                                     - 16*w2
 
273
                                     + (1<<(alpha+rho+1)));
 
274
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
 
275
            s->sprite_delta[0][1]=   (+r*sprite_ref[0][1] - virtual_ref[0][1]);
 
276
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
 
277
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
 
278
 
 
279
            s->sprite_shift[0]= alpha+rho;
 
280
            s->sprite_shift[1]= alpha+rho+2;
 
281
            break;
 
282
        case 3:
 
283
            min_ab= FFMIN(alpha, beta);
 
284
            w3= w2>>min_ab;
 
285
            h3= h2>>min_ab;
 
286
            s->sprite_offset[0][0]=  (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
 
287
                                   + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
 
288
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
 
289
                                   + (1<<(alpha+beta+rho-min_ab-1));
 
290
            s->sprite_offset[0][1]=  (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
 
291
                                   + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
 
292
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
 
293
                                   + (1<<(alpha+beta+rho-min_ab-1));
 
294
            s->sprite_offset[1][0]=  (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
 
295
                                   + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
 
296
                                   + 2*w2*h3*r*sprite_ref[0][0]
 
297
                                   - 16*w2*h3
 
298
                                   + (1<<(alpha+beta+rho-min_ab+1));
 
299
            s->sprite_offset[1][1]=  (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
 
300
                                   + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
 
301
                                   + 2*w2*h3*r*sprite_ref[0][1]
 
302
                                   - 16*w2*h3
 
303
                                   + (1<<(alpha+beta+rho-min_ab+1));
 
304
            s->sprite_delta[0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
 
305
            s->sprite_delta[0][1]=   (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
 
306
            s->sprite_delta[1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
 
307
            s->sprite_delta[1][1]=   (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
 
308
 
 
309
            s->sprite_shift[0]= alpha + beta + rho - min_ab;
 
310
            s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
 
311
            break;
 
312
    }
 
313
    /* try to simplify the situation */
 
314
    if(   s->sprite_delta[0][0] == a<<s->sprite_shift[0]
 
315
       && s->sprite_delta[0][1] == 0
 
316
       && s->sprite_delta[1][0] == 0
 
317
       && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
 
318
    {
 
319
        s->sprite_offset[0][0]>>=s->sprite_shift[0];
 
320
        s->sprite_offset[0][1]>>=s->sprite_shift[0];
 
321
        s->sprite_offset[1][0]>>=s->sprite_shift[1];
 
322
        s->sprite_offset[1][1]>>=s->sprite_shift[1];
 
323
        s->sprite_delta[0][0]= a;
 
324
        s->sprite_delta[0][1]= 0;
 
325
        s->sprite_delta[1][0]= 0;
 
326
        s->sprite_delta[1][1]= a;
 
327
        s->sprite_shift[0]= 0;
 
328
        s->sprite_shift[1]= 0;
 
329
        s->real_sprite_warping_points=1;
 
330
    }
 
331
    else{
 
332
        int shift_y= 16 - s->sprite_shift[0];
 
333
        int shift_c= 16 - s->sprite_shift[1];
 
334
        for(i=0; i<2; i++){
 
335
            s->sprite_offset[0][i]<<= shift_y;
 
336
            s->sprite_offset[1][i]<<= shift_c;
 
337
            s->sprite_delta[0][i]<<= shift_y;
 
338
            s->sprite_delta[1][i]<<= shift_y;
 
339
            s->sprite_shift[i]= 16;
 
340
        }
 
341
        s->real_sprite_warping_points= s->num_sprite_warping_points;
 
342
    }
 
343
}
 
344
 
 
345
/**
 
346
 * decodes the next video packet.
 
347
 * @return <0 if something went wrong
 
348
 */
 
349
int mpeg4_decode_video_packet_header(MpegEncContext *s)
 
350
{
 
351
    int mb_num_bits= av_log2(s->mb_num - 1) + 1;
 
352
    int header_extension=0, mb_num, len;
 
353
 
 
354
    /* is there enough space left for a video packet + header */
 
355
    if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
 
356
 
 
357
    for(len=0; len<32; len++){
 
358
        if(get_bits1(&s->gb)) break;
 
359
    }
 
360
 
 
361
    if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
 
362
        av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
 
363
        return -1;
 
364
    }
 
365
 
 
366
    if(s->shape != RECT_SHAPE){
 
367
        header_extension= get_bits1(&s->gb);
 
368
        //FIXME more stuff here
 
369
    }
 
370
 
 
371
    mb_num= get_bits(&s->gb, mb_num_bits);
 
372
    if(mb_num>=s->mb_num){
 
373
        av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
 
374
        return -1;
 
375
    }
 
376
    if(s->pict_type == FF_B_TYPE){
 
377
        int mb_x = 0, mb_y = 0;
 
378
 
 
379
        while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) {
 
380
            if (!mb_x) ff_thread_await_progress((AVFrame*)s->next_picture_ptr, mb_y++, 0);
 
381
            mb_num++;
 
382
            if (++mb_x == s->mb_width) mb_x = 0;
 
383
        }
 
384
        if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
 
385
    }
 
386
 
 
387
    s->mb_x= mb_num % s->mb_width;
 
388
    s->mb_y= mb_num / s->mb_width;
 
389
 
 
390
    if(s->shape != BIN_ONLY_SHAPE){
 
391
        int qscale= get_bits(&s->gb, s->quant_precision);
 
392
        if(qscale)
 
393
            s->chroma_qscale=s->qscale= qscale;
 
394
    }
 
395
 
 
396
    if(s->shape == RECT_SHAPE){
 
397
        header_extension= get_bits1(&s->gb);
 
398
    }
 
399
    if(header_extension){
 
400
        int time_increment;
 
401
        int time_incr=0;
 
402
 
 
403
        while (get_bits1(&s->gb) != 0)
 
404
            time_incr++;
 
405
 
 
406
        check_marker(&s->gb, "before time_increment in video packed header");
 
407
        time_increment= get_bits(&s->gb, s->time_increment_bits);
 
408
        check_marker(&s->gb, "before vop_coding_type in video packed header");
 
409
 
 
410
        skip_bits(&s->gb, 2); /* vop coding type */
 
411
        //FIXME not rect stuff here
 
412
 
 
413
        if(s->shape != BIN_ONLY_SHAPE){
 
414
            skip_bits(&s->gb, 3); /* intra dc vlc threshold */
 
415
//FIXME don't just ignore everything
 
416
            if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
 
417
                mpeg4_decode_sprite_trajectory(s, &s->gb);
 
418
                av_log(s->avctx, AV_LOG_ERROR, "untested\n");
 
419
            }
 
420
 
 
421
            //FIXME reduced res stuff here
 
422
 
 
423
            if (s->pict_type != FF_I_TYPE) {
 
424
                int f_code = get_bits(&s->gb, 3);       /* fcode_for */
 
425
                if(f_code==0){
 
426
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
 
427
                }
 
428
            }
 
429
            if (s->pict_type == FF_B_TYPE) {
 
430
                int b_code = get_bits(&s->gb, 3);
 
431
                if(b_code==0){
 
432
                    av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
 
433
                }
 
434
            }
 
435
        }
 
436
    }
 
437
    //FIXME new-pred stuff
 
438
 
 
439
    return 0;
 
440
}
 
441
 
 
442
/**
 
443
 * gets the average motion vector for a GMC MB.
 
444
 * @param n either 0 for the x component or 1 for y
 
445
 * @return the average MV for a GMC MB
 
446
 */
 
447
static inline int get_amv(MpegEncContext *s, int n){
 
448
    int x, y, mb_v, sum, dx, dy, shift;
 
449
    int len = 1 << (s->f_code + 4);
 
450
    const int a= s->sprite_warping_accuracy;
 
451
 
 
452
    if(s->workaround_bugs & FF_BUG_AMV)
 
453
        len >>= s->quarter_sample;
 
454
 
 
455
    if(s->real_sprite_warping_points==1){
 
456
        if(s->divx_version==500 && s->divx_build==413)
 
457
            sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
 
458
        else
 
459
            sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
 
460
    }else{
 
461
        dx= s->sprite_delta[n][0];
 
462
        dy= s->sprite_delta[n][1];
 
463
        shift= s->sprite_shift[0];
 
464
        if(n) dy -= 1<<(shift + a + 1);
 
465
        else  dx -= 1<<(shift + a + 1);
 
466
        mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
 
467
 
 
468
        sum=0;
 
469
        for(y=0; y<16; y++){
 
470
            int v;
 
471
 
 
472
            v= mb_v + dy*y;
 
473
            //XXX FIXME optimize
 
474
            for(x=0; x<16; x++){
 
475
                sum+= v>>shift;
 
476
                v+= dx;
 
477
            }
 
478
        }
 
479
        sum= RSHIFT(sum, a+8-s->quarter_sample);
 
480
    }
 
481
 
 
482
    if      (sum < -len) sum= -len;
 
483
    else if (sum >= len) sum= len-1;
 
484
 
 
485
    return sum;
 
486
}
 
487
 
 
488
/**
 
489
 * decodes the dc value.
 
490
 * @param n block index (0-3 are luma, 4-5 are chroma)
 
491
 * @param dir_ptr the prediction direction will be stored here
 
492
 * @return the quantized dc
 
493
 */
 
494
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
 
495
{
 
496
    int level, code;
 
497
 
 
498
    if (n < 4)
 
499
        code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
 
500
    else
 
501
        code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
 
502
    if (code < 0 || code > 9 /* && s->nbit<9 */){
 
503
        av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
 
504
        return -1;
 
505
    }
 
506
    if (code == 0) {
 
507
        level = 0;
 
508
    } else {
 
509
        if(IS_3IV1){
 
510
            if(code==1)
 
511
                level= 2*get_bits1(&s->gb)-1;
 
512
            else{
 
513
                if(get_bits1(&s->gb))
 
514
                    level = get_bits(&s->gb, code-1) + (1<<(code-1));
 
515
                else
 
516
                    level = -get_bits(&s->gb, code-1) - (1<<(code-1));
 
517
            }
 
518
        }else{
 
519
            level = get_xbits(&s->gb, code);
 
520
        }
 
521
 
 
522
        if (code > 8){
 
523
            if(get_bits1(&s->gb)==0){ /* marker */
 
524
                if(s->error_recognition>=2){
 
525
                    av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
 
526
                    return -1;
 
527
                }
 
528
            }
 
529
        }
 
530
    }
 
531
 
 
532
    return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
 
533
}
 
534
 
 
535
/**
 
536
 * decodes first partition.
 
537
 * @return number of MBs decoded or <0 if an error occurred
 
538
 */
 
539
static int mpeg4_decode_partition_a(MpegEncContext *s){
 
540
    int mb_num;
 
541
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 
542
 
 
543
    /* decode first partition */
 
544
    mb_num=0;
 
545
    s->first_slice_line=1;
 
546
    for(; s->mb_y<s->mb_height; s->mb_y++){
 
547
        ff_init_block_index(s);
 
548
        for(; s->mb_x<s->mb_width; s->mb_x++){
 
549
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
 
550
            int cbpc;
 
551
            int dir=0;
 
552
 
 
553
            mb_num++;
 
554
            ff_update_block_index(s);
 
555
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
 
556
                s->first_slice_line=0;
 
557
 
 
558
            if(s->pict_type==FF_I_TYPE){
 
559
                int i;
 
560
 
 
561
                do{
 
562
                    if(show_bits_long(&s->gb, 19)==DC_MARKER){
 
563
                        return mb_num-1;
 
564
                    }
 
565
 
 
566
                    cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
 
567
                    if (cbpc < 0){
 
568
                        av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
 
569
                        return -1;
 
570
                    }
 
571
                }while(cbpc == 8);
 
572
 
 
573
                s->cbp_table[xy]= cbpc & 3;
 
574
                s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
 
575
                s->mb_intra = 1;
 
576
 
 
577
                if(cbpc & 4) {
 
578
                    ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 
579
                }
 
580
                s->current_picture.qscale_table[xy]= s->qscale;
 
581
 
 
582
                s->mbintra_table[xy]= 1;
 
583
                for(i=0; i<6; i++){
 
584
                    int dc_pred_dir;
 
585
                    int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
 
586
                    if(dc < 0){
 
587
                        av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
 
588
                        return -1;
 
589
                    }
 
590
                    dir<<=1;
 
591
                    if(dc_pred_dir) dir|=1;
 
592
                }
 
593
                s->pred_dir_table[xy]= dir;
 
594
            }else{ /* P/S_TYPE */
 
595
                int mx, my, pred_x, pred_y, bits;
 
596
                int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
 
597
                const int stride= s->b8_stride*2;
 
598
 
 
599
try_again:
 
600
                bits= show_bits(&s->gb, 17);
 
601
                if(bits==MOTION_MARKER){
 
602
                    return mb_num-1;
 
603
                }
 
604
                skip_bits1(&s->gb);
 
605
                if(bits&0x10000){
 
606
                    /* skip mb */
 
607
                    if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
 
608
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
 
609
                        mx= get_amv(s, 0);
 
610
                        my= get_amv(s, 1);
 
611
                    }else{
 
612
                        s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
 
613
                        mx=my=0;
 
614
                    }
 
615
                    mot_val[0       ]= mot_val[2       ]=
 
616
                    mot_val[0+stride]= mot_val[2+stride]= mx;
 
617
                    mot_val[1       ]= mot_val[3       ]=
 
618
                    mot_val[1+stride]= mot_val[3+stride]= my;
 
619
 
 
620
                    if(s->mbintra_table[xy])
 
621
                        ff_clean_intra_table_entries(s);
 
622
                    continue;
 
623
                }
 
624
 
 
625
                cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 
626
                if (cbpc < 0){
 
627
                    av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
 
628
                    return -1;
 
629
                }
 
630
                if(cbpc == 20)
 
631
                    goto try_again;
 
632
 
 
633
                s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
 
634
 
 
635
                s->mb_intra = ((cbpc & 4) != 0);
 
636
 
 
637
                if(s->mb_intra){
 
638
                    s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
 
639
                    s->mbintra_table[xy]= 1;
 
640
                    mot_val[0       ]= mot_val[2       ]=
 
641
                    mot_val[0+stride]= mot_val[2+stride]= 0;
 
642
                    mot_val[1       ]= mot_val[3       ]=
 
643
                    mot_val[1+stride]= mot_val[3+stride]= 0;
 
644
                }else{
 
645
                    if(s->mbintra_table[xy])
 
646
                        ff_clean_intra_table_entries(s);
 
647
 
 
648
                    if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
 
649
                        s->mcsel= get_bits1(&s->gb);
 
650
                    else s->mcsel= 0;
 
651
 
 
652
                    if ((cbpc & 16) == 0) {
 
653
                        /* 16x16 motion prediction */
 
654
 
 
655
                        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 
656
                        if(!s->mcsel){
 
657
                            mx = h263_decode_motion(s, pred_x, s->f_code);
 
658
                            if (mx >= 0xffff)
 
659
                                return -1;
 
660
 
 
661
                            my = h263_decode_motion(s, pred_y, s->f_code);
 
662
                            if (my >= 0xffff)
 
663
                                return -1;
 
664
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
 
665
                        } else {
 
666
                            mx = get_amv(s, 0);
 
667
                            my = get_amv(s, 1);
 
668
                            s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
 
669
                        }
 
670
 
 
671
                        mot_val[0       ]= mot_val[2       ] =
 
672
                        mot_val[0+stride]= mot_val[2+stride]= mx;
 
673
                        mot_val[1       ]= mot_val[3       ]=
 
674
                        mot_val[1+stride]= mot_val[3+stride]= my;
 
675
                    } else {
 
676
                        int i;
 
677
                        s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
 
678
                        for(i=0;i<4;i++) {
 
679
                            int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 
680
                            mx = h263_decode_motion(s, pred_x, s->f_code);
 
681
                            if (mx >= 0xffff)
 
682
                                return -1;
 
683
 
 
684
                            my = h263_decode_motion(s, pred_y, s->f_code);
 
685
                            if (my >= 0xffff)
 
686
                                return -1;
 
687
                            mot_val[0] = mx;
 
688
                            mot_val[1] = my;
 
689
                        }
 
690
                    }
 
691
                }
 
692
            }
 
693
        }
 
694
        s->mb_x= 0;
 
695
    }
 
696
 
 
697
    return mb_num;
 
698
}
 
699
 
 
700
/**
 
701
 * decode second partition.
 
702
 * @return <0 if an error occurred
 
703
 */
 
704
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
 
705
    int mb_num=0;
 
706
    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 
707
 
 
708
    s->mb_x= s->resync_mb_x;
 
709
    s->first_slice_line=1;
 
710
    for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
 
711
        ff_init_block_index(s);
 
712
        for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
 
713
            const int xy= s->mb_x + s->mb_y*s->mb_stride;
 
714
 
 
715
            mb_num++;
 
716
            ff_update_block_index(s);
 
717
            if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
 
718
                s->first_slice_line=0;
 
719
 
 
720
            if(s->pict_type==FF_I_TYPE){
 
721
                int ac_pred= get_bits1(&s->gb);
 
722
                int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 
723
                if(cbpy<0){
 
724
                    av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 
725
                    return -1;
 
726
                }
 
727
 
 
728
                s->cbp_table[xy]|= cbpy<<2;
 
729
                s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
 
730
            }else{ /* P || S_TYPE */
 
731
                if(IS_INTRA(s->current_picture.mb_type[xy])){
 
732
                    int dir=0,i;
 
733
                    int ac_pred = get_bits1(&s->gb);
 
734
                    int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 
735
 
 
736
                    if(cbpy<0){
 
737
                        av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 
738
                        return -1;
 
739
                    }
 
740
 
 
741
                    if(s->cbp_table[xy] & 8) {
 
742
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 
743
                    }
 
744
                    s->current_picture.qscale_table[xy]= s->qscale;
 
745
 
 
746
                    for(i=0; i<6; i++){
 
747
                        int dc_pred_dir;
 
748
                        int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
 
749
                        if(dc < 0){
 
750
                            av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
 
751
                            return -1;
 
752
                        }
 
753
                        dir<<=1;
 
754
                        if(dc_pred_dir) dir|=1;
 
755
                    }
 
756
                    s->cbp_table[xy]&= 3; //remove dquant
 
757
                    s->cbp_table[xy]|= cbpy<<2;
 
758
                    s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
 
759
                    s->pred_dir_table[xy]= dir;
 
760
                }else if(IS_SKIP(s->current_picture.mb_type[xy])){
 
761
                    s->current_picture.qscale_table[xy]= s->qscale;
 
762
                    s->cbp_table[xy]= 0;
 
763
                }else{
 
764
                    int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 
765
 
 
766
                    if(cbpy<0){
 
767
                        av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
 
768
                        return -1;
 
769
                    }
 
770
 
 
771
                    if(s->cbp_table[xy] & 8) {
 
772
                        ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 
773
                    }
 
774
                    s->current_picture.qscale_table[xy]= s->qscale;
 
775
 
 
776
                    s->cbp_table[xy]&= 3; //remove dquant
 
777
                    s->cbp_table[xy]|= (cbpy^0xf)<<2;
 
778
                }
 
779
            }
 
780
        }
 
781
        if(mb_num >= mb_count) return 0;
 
782
        s->mb_x= 0;
 
783
    }
 
784
    return 0;
 
785
}
 
786
 
 
787
/**
 
788
 * decodes the first & second partition
 
789
 * @return <0 if error (and sets error type in the error_status_table)
 
790
 */
 
791
int ff_mpeg4_decode_partitions(MpegEncContext *s)
 
792
{
 
793
    int mb_num;
 
794
    const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
 
795
    const int part_a_end  = s->pict_type==FF_I_TYPE ? (DC_END  |MV_END)   : MV_END;
 
796
 
 
797
    mb_num= mpeg4_decode_partition_a(s);
 
798
    if(mb_num<0){
 
799
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
 
800
        return -1;
 
801
    }
 
802
 
 
803
    if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
 
804
        av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
 
805
        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
 
806
        return -1;
 
807
    }
 
808
 
 
809
    s->mb_num_left= mb_num;
 
810
 
 
811
    if(s->pict_type==FF_I_TYPE){
 
812
        while(show_bits(&s->gb, 9) == 1)
 
813
            skip_bits(&s->gb, 9);
 
814
        if(get_bits_long(&s->gb, 19)!=DC_MARKER){
 
815
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
 
816
            return -1;
 
817
        }
 
818
    }else{
 
819
        while(show_bits(&s->gb, 10) == 1)
 
820
            skip_bits(&s->gb, 10);
 
821
        if(get_bits(&s->gb, 17)!=MOTION_MARKER){
 
822
            av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
 
823
            return -1;
 
824
        }
 
825
    }
 
826
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
 
827
 
 
828
    if( mpeg4_decode_partition_b(s, mb_num) < 0){
 
829
        if(s->pict_type==FF_P_TYPE)
 
830
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
 
831
        return -1;
 
832
    }else{
 
833
        if(s->pict_type==FF_P_TYPE)
 
834
            ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
 
835
    }
 
836
 
 
837
    return 0;
 
838
}
 
839
 
 
840
/**
 
841
 * decodes a block.
 
842
 * @return <0 if an error occurred
 
843
 */
 
844
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
 
845
                              int n, int coded, int intra, int rvlc)
 
846
{
 
847
    int level, i, last, run;
 
848
    int dc_pred_dir;
 
849
    RLTable * rl;
 
850
    RL_VLC_ELEM * rl_vlc;
 
851
    const uint8_t * scan_table;
 
852
    int qmul, qadd;
 
853
 
 
854
    //Note intra & rvlc should be optimized away if this is inlined
 
855
 
 
856
    if(intra) {
 
857
      if(s->use_intra_dc_vlc){
 
858
        /* DC coef */
 
859
        if(s->partitioned_frame){
 
860
            level = s->dc_val[0][ s->block_index[n] ];
 
861
            if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
 
862
            else    level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
 
863
            dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
 
864
        }else{
 
865
            level = mpeg4_decode_dc(s, n, &dc_pred_dir);
 
866
            if (level < 0)
 
867
                return -1;
 
868
        }
 
869
        block[0] = level;
 
870
        i = 0;
 
871
      }else{
 
872
            i = -1;
 
873
            ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
 
874
      }
 
875
      if (!coded)
 
876
          goto not_coded;
 
877
 
 
878
      if(rvlc){
 
879
          rl = &rvlc_rl_intra;
 
880
          rl_vlc = rvlc_rl_intra.rl_vlc[0];
 
881
      }else{
 
882
          rl = &ff_mpeg4_rl_intra;
 
883
          rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
 
884
      }
 
885
      if (s->ac_pred) {
 
886
          if (dc_pred_dir == 0)
 
887
              scan_table = s->intra_v_scantable.permutated; /* left */
 
888
          else
 
889
              scan_table = s->intra_h_scantable.permutated; /* top */
 
890
      } else {
 
891
            scan_table = s->intra_scantable.permutated;
 
892
      }
 
893
      qmul=1;
 
894
      qadd=0;
 
895
    } else {
 
896
        i = -1;
 
897
        if (!coded) {
 
898
            s->block_last_index[n] = i;
 
899
            return 0;
 
900
        }
 
901
        if(rvlc) rl = &rvlc_rl_inter;
 
902
        else     rl = &ff_h263_rl_inter;
 
903
 
 
904
        scan_table = s->intra_scantable.permutated;
 
905
 
 
906
        if(s->mpeg_quant){
 
907
            qmul=1;
 
908
            qadd=0;
 
909
            if(rvlc){
 
910
                rl_vlc = rvlc_rl_inter.rl_vlc[0];
 
911
            }else{
 
912
                rl_vlc = ff_h263_rl_inter.rl_vlc[0];
 
913
            }
 
914
        }else{
 
915
            qmul = s->qscale << 1;
 
916
            qadd = (s->qscale - 1) | 1;
 
917
            if(rvlc){
 
918
                rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
 
919
            }else{
 
920
                rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
 
921
            }
 
922
        }
 
923
    }
 
924
  {
 
925
    OPEN_READER(re, &s->gb);
 
926
    for(;;) {
 
927
        UPDATE_CACHE(re, &s->gb);
 
928
        GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
 
929
        if (level==0) {
 
930
          /* escape */
 
931
          if(rvlc){
 
932
                if(SHOW_UBITS(re, &s->gb, 1)==0){
 
933
                    av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
 
934
                    return -1;
 
935
                }; SKIP_CACHE(re, &s->gb, 1);
 
936
 
 
937
                last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
 
938
                run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
 
939
                SKIP_COUNTER(re, &s->gb, 1+1+6);
 
940
                UPDATE_CACHE(re, &s->gb);
 
941
 
 
942
                if(SHOW_UBITS(re, &s->gb, 1)==0){
 
943
                    av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
 
944
                    return -1;
 
945
                }; SKIP_CACHE(re, &s->gb, 1);
 
946
 
 
947
                level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
 
948
 
 
949
                if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
 
950
                    av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
 
951
                    return -1;
 
952
                }; SKIP_CACHE(re, &s->gb, 5);
 
953
 
 
954
                level=  level * qmul + qadd;
 
955
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
 
956
                SKIP_COUNTER(re, &s->gb, 1+11+5+1);
 
957
 
 
958
                i+= run + 1;
 
959
                if(last) i+=192;
 
960
          }else{
 
961
            int cache;
 
962
            cache= GET_CACHE(re, &s->gb);
 
963
 
 
964
            if(IS_3IV1)
 
965
                cache ^= 0xC0000000;
 
966
 
 
967
            if (cache&0x80000000) {
 
968
                if (cache&0x40000000) {
 
969
                    /* third escape */
 
970
                    SKIP_CACHE(re, &s->gb, 2);
 
971
                    last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
 
972
                    run=   SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
 
973
                    SKIP_COUNTER(re, &s->gb, 2+1+6);
 
974
                    UPDATE_CACHE(re, &s->gb);
 
975
 
 
976
                    if(IS_3IV1){
 
977
                        level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
 
978
                    }else{
 
979
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
 
980
                            av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
 
981
                            return -1;
 
982
                        }; SKIP_CACHE(re, &s->gb, 1);
 
983
 
 
984
                        level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
 
985
 
 
986
                        if(SHOW_UBITS(re, &s->gb, 1)==0){
 
987
                            av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
 
988
                            return -1;
 
989
                        }; LAST_SKIP_CACHE(re, &s->gb, 1);
 
990
 
 
991
                        SKIP_COUNTER(re, &s->gb, 1+12+1);
 
992
                    }
 
993
 
 
994
#if 0
 
995
                    if(s->error_recognition >= FF_ER_COMPLIANT){
 
996
                        const int abs_level= FFABS(level);
 
997
                        if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
 
998
                            const int run1= run - rl->max_run[last][abs_level] - 1;
 
999
                            if(abs_level <= rl->max_level[last][run]){
 
1000
                                av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
 
1001
                                return -1;
 
1002
                            }
 
1003
                            if(s->error_recognition > FF_ER_COMPLIANT){
 
1004
                                if(abs_level <= rl->max_level[last][run]*2){
 
1005
                                    av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
 
1006
                                    return -1;
 
1007
                                }
 
1008
                                if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
 
1009
                                    av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
 
1010
                                    return -1;
 
1011
                                }
 
1012
                            }
 
1013
                        }
 
1014
                    }
 
1015
#endif
 
1016
                    if (level>0) level= level * qmul + qadd;
 
1017
                    else         level= level * qmul - qadd;
 
1018
 
 
1019
                    if((unsigned)(level + 2048) > 4095){
 
1020
                        if(s->error_recognition > FF_ER_COMPLIANT){
 
1021
                            if(level > 2560 || level<-2560){
 
1022
                                av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
 
1023
                                return -1;
 
1024
                            }
 
1025
                        }
 
1026
                        level= level<0 ? -2048 : 2047;
 
1027
                    }
 
1028
 
 
1029
                    i+= run + 1;
 
1030
                    if(last) i+=192;
 
1031
                } else {
 
1032
                    /* second escape */
 
1033
#if MIN_CACHE_BITS < 20
 
1034
                    LAST_SKIP_BITS(re, &s->gb, 2);
 
1035
                    UPDATE_CACHE(re, &s->gb);
 
1036
#else
 
1037
                    SKIP_BITS(re, &s->gb, 2);
 
1038
#endif
 
1039
                    GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
 
1040
                    i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
 
1041
                    level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 
1042
                    LAST_SKIP_BITS(re, &s->gb, 1);
 
1043
                }
 
1044
            } else {
 
1045
                /* first escape */
 
1046
#if MIN_CACHE_BITS < 19
 
1047
                LAST_SKIP_BITS(re, &s->gb, 1);
 
1048
                UPDATE_CACHE(re, &s->gb);
 
1049
#else
 
1050
                SKIP_BITS(re, &s->gb, 1);
 
1051
#endif
 
1052
                GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
 
1053
                i+= run;
 
1054
                level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
 
1055
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 
1056
                LAST_SKIP_BITS(re, &s->gb, 1);
 
1057
            }
 
1058
          }
 
1059
        } else {
 
1060
            i+= run;
 
1061
            level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 
1062
            LAST_SKIP_BITS(re, &s->gb, 1);
 
1063
        }
 
1064
        if (i > 62){
 
1065
            i-= 192;
 
1066
            if(i&(~63)){
 
1067
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
 
1068
                return -1;
 
1069
            }
 
1070
 
 
1071
            block[scan_table[i]] = level;
 
1072
            break;
 
1073
        }
 
1074
 
 
1075
        block[scan_table[i]] = level;
 
1076
    }
 
1077
    CLOSE_READER(re, &s->gb);
 
1078
  }
 
1079
 not_coded:
 
1080
    if (intra) {
 
1081
        if(!s->use_intra_dc_vlc){
 
1082
            block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
 
1083
 
 
1084
            i -= i>>31; //if(i == -1) i=0;
 
1085
        }
 
1086
 
 
1087
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
 
1088
        if (s->ac_pred) {
 
1089
            i = 63; /* XXX: not optimal */
 
1090
        }
 
1091
    }
 
1092
    s->block_last_index[n] = i;
 
1093
    return 0;
 
1094
}
 
1095
 
 
1096
/**
 
1097
 * decode partition C of one MB.
 
1098
 * @return <0 if an error occurred
 
1099
 */
 
1100
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
 
1101
{
 
1102
    int cbp, mb_type;
 
1103
    const int xy= s->mb_x + s->mb_y*s->mb_stride;
 
1104
 
 
1105
    mb_type= s->current_picture.mb_type[xy];
 
1106
    cbp = s->cbp_table[xy];
 
1107
 
 
1108
    s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
 
1109
 
 
1110
    if(s->current_picture.qscale_table[xy] != s->qscale){
 
1111
        ff_set_qscale(s, s->current_picture.qscale_table[xy] );
 
1112
    }
 
1113
 
 
1114
    if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
 
1115
        int i;
 
1116
        for(i=0; i<4; i++){
 
1117
            s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
 
1118
            s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
 
1119
        }
 
1120
        s->mb_intra = IS_INTRA(mb_type);
 
1121
 
 
1122
        if (IS_SKIP(mb_type)) {
 
1123
            /* skip mb */
 
1124
            for(i=0;i<6;i++)
 
1125
                s->block_last_index[i] = -1;
 
1126
            s->mv_dir = MV_DIR_FORWARD;
 
1127
            s->mv_type = MV_TYPE_16X16;
 
1128
            if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
 
1129
                s->mcsel=1;
 
1130
                s->mb_skipped = 0;
 
1131
            }else{
 
1132
                s->mcsel=0;
 
1133
                s->mb_skipped = 1;
 
1134
            }
 
1135
        }else if(s->mb_intra){
 
1136
            s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
 
1137
        }else if(!s->mb_intra){
 
1138
//            s->mcsel= 0; //FIXME do we need to init that
 
1139
 
 
1140
            s->mv_dir = MV_DIR_FORWARD;
 
1141
            if (IS_8X8(mb_type)) {
 
1142
                s->mv_type = MV_TYPE_8X8;
 
1143
            } else {
 
1144
                s->mv_type = MV_TYPE_16X16;
 
1145
            }
 
1146
        }
 
1147
    } else { /* I-Frame */
 
1148
        s->mb_intra = 1;
 
1149
        s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
 
1150
    }
 
1151
 
 
1152
    if (!IS_SKIP(mb_type)) {
 
1153
        int i;
 
1154
        s->dsp.clear_blocks(s->block[0]);
 
1155
        /* decode each block */
 
1156
        for (i = 0; i < 6; i++) {
 
1157
            if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
 
1158
                av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
 
1159
                return -1;
 
1160
            }
 
1161
            cbp+=cbp;
 
1162
        }
 
1163
    }
 
1164
 
 
1165
    /* per-MB end of slice check */
 
1166
 
 
1167
    if(--s->mb_num_left <= 0){
 
1168
        if(mpeg4_is_resync(s))
 
1169
            return SLICE_END;
 
1170
        else
 
1171
            return SLICE_NOEND;
 
1172
    }else{
 
1173
        if(mpeg4_is_resync(s)){
 
1174
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
 
1175
            if(s->cbp_table[xy+delta])
 
1176
                return SLICE_END;
 
1177
        }
 
1178
        return SLICE_OK;
 
1179
    }
 
1180
}
 
1181
 
 
1182
static int mpeg4_decode_mb(MpegEncContext *s,
 
1183
                      DCTELEM block[6][64])
 
1184
{
 
1185
    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
 
1186
    int16_t *mot_val;
 
1187
    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
 
1188
    const int xy= s->mb_x + s->mb_y * s->mb_stride;
 
1189
 
 
1190
    assert(s->h263_pred);
 
1191
 
 
1192
    if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
 
1193
        do{
 
1194
            if (get_bits1(&s->gb)) {
 
1195
                /* skip mb */
 
1196
                s->mb_intra = 0;
 
1197
                for(i=0;i<6;i++)
 
1198
                    s->block_last_index[i] = -1;
 
1199
                s->mv_dir = MV_DIR_FORWARD;
 
1200
                s->mv_type = MV_TYPE_16X16;
 
1201
                if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
 
1202
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
 
1203
                    s->mcsel=1;
 
1204
                    s->mv[0][0][0]= get_amv(s, 0);
 
1205
                    s->mv[0][0][1]= get_amv(s, 1);
 
1206
 
 
1207
                    s->mb_skipped = 0;
 
1208
                }else{
 
1209
                    s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
 
1210
                    s->mcsel=0;
 
1211
                    s->mv[0][0][0] = 0;
 
1212
                    s->mv[0][0][1] = 0;
 
1213
                    s->mb_skipped = 1;
 
1214
                }
 
1215
                goto end;
 
1216
            }
 
1217
            cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 
1218
            if (cbpc < 0){
 
1219
                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
 
1220
                return -1;
 
1221
            }
 
1222
        }while(cbpc == 20);
 
1223
 
 
1224
        s->dsp.clear_blocks(s->block[0]);
 
1225
        dquant = cbpc & 8;
 
1226
        s->mb_intra = ((cbpc & 4) != 0);
 
1227
        if (s->mb_intra) goto intra;
 
1228
 
 
1229
        if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
 
1230
            s->mcsel= get_bits1(&s->gb);
 
1231
        else s->mcsel= 0;
 
1232
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
 
1233
 
 
1234
        cbp = (cbpc & 3) | (cbpy << 2);
 
1235
        if (dquant) {
 
1236
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 
1237
        }
 
1238
        if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
 
1239
            s->interlaced_dct= get_bits1(&s->gb);
 
1240
 
 
1241
        s->mv_dir = MV_DIR_FORWARD;
 
1242
        if ((cbpc & 16) == 0) {
 
1243
            if(s->mcsel){
 
1244
                s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
 
1245
                /* 16x16 global motion prediction */
 
1246
                s->mv_type = MV_TYPE_16X16;
 
1247
                mx= get_amv(s, 0);
 
1248
                my= get_amv(s, 1);
 
1249
                s->mv[0][0][0] = mx;
 
1250
                s->mv[0][0][1] = my;
 
1251
            }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
 
1252
                s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
 
1253
                /* 16x8 field motion prediction */
 
1254
                s->mv_type= MV_TYPE_FIELD;
 
1255
 
 
1256
                s->field_select[0][0]= get_bits1(&s->gb);
 
1257
                s->field_select[0][1]= get_bits1(&s->gb);
 
1258
 
 
1259
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 
1260
 
 
1261
                for(i=0; i<2; i++){
 
1262
                    mx = h263_decode_motion(s, pred_x, s->f_code);
 
1263
                    if (mx >= 0xffff)
 
1264
                        return -1;
 
1265
 
 
1266
                    my = h263_decode_motion(s, pred_y/2, s->f_code);
 
1267
                    if (my >= 0xffff)
 
1268
                        return -1;
 
1269
 
 
1270
                    s->mv[0][i][0] = mx;
 
1271
                    s->mv[0][i][1] = my;
 
1272
                }
 
1273
            }else{
 
1274
                s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
 
1275
                /* 16x16 motion prediction */
 
1276
                s->mv_type = MV_TYPE_16X16;
 
1277
                h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 
1278
                mx = h263_decode_motion(s, pred_x, s->f_code);
 
1279
 
 
1280
                if (mx >= 0xffff)
 
1281
                    return -1;
 
1282
 
 
1283
                my = h263_decode_motion(s, pred_y, s->f_code);
 
1284
 
 
1285
                if (my >= 0xffff)
 
1286
                    return -1;
 
1287
                s->mv[0][0][0] = mx;
 
1288
                s->mv[0][0][1] = my;
 
1289
            }
 
1290
        } else {
 
1291
            s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
 
1292
            s->mv_type = MV_TYPE_8X8;
 
1293
            for(i=0;i<4;i++) {
 
1294
                mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 
1295
                mx = h263_decode_motion(s, pred_x, s->f_code);
 
1296
                if (mx >= 0xffff)
 
1297
                    return -1;
 
1298
 
 
1299
                my = h263_decode_motion(s, pred_y, s->f_code);
 
1300
                if (my >= 0xffff)
 
1301
                    return -1;
 
1302
                s->mv[0][i][0] = mx;
 
1303
                s->mv[0][i][1] = my;
 
1304
                mot_val[0] = mx;
 
1305
                mot_val[1] = my;
 
1306
            }
 
1307
        }
 
1308
    } else if(s->pict_type==FF_B_TYPE) {
 
1309
        int modb1; // first bit of modb
 
1310
        int modb2; // second bit of modb
 
1311
        int mb_type;
 
1312
 
 
1313
        s->mb_intra = 0; //B-frames never contain intra blocks
 
1314
        s->mcsel=0;      //     ...               true gmc blocks
 
1315
 
 
1316
        if(s->mb_x==0){
 
1317
            for(i=0; i<2; i++){
 
1318
                s->last_mv[i][0][0]=
 
1319
                s->last_mv[i][0][1]=
 
1320
                s->last_mv[i][1][0]=
 
1321
                s->last_mv[i][1][1]= 0;
 
1322
            }
 
1323
 
 
1324
            ff_thread_await_progress((AVFrame*)s->next_picture_ptr, s->mb_y, 0);
 
1325
        }
 
1326
 
 
1327
        /* if we skipped it in the future P Frame than skip it now too */
 
1328
        s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
 
1329
 
 
1330
        if(s->mb_skipped){
 
1331
                /* skip mb */
 
1332
            for(i=0;i<6;i++)
 
1333
                s->block_last_index[i] = -1;
 
1334
 
 
1335
            s->mv_dir = MV_DIR_FORWARD;
 
1336
            s->mv_type = MV_TYPE_16X16;
 
1337
            s->mv[0][0][0] = 0;
 
1338
            s->mv[0][0][1] = 0;
 
1339
            s->mv[1][0][0] = 0;
 
1340
            s->mv[1][0][1] = 0;
 
1341
            s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
 
1342
            goto end;
 
1343
        }
 
1344
 
 
1345
        modb1= get_bits1(&s->gb);
 
1346
        if(modb1){
 
1347
            mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
 
1348
            cbp=0;
 
1349
        }else{
 
1350
            modb2= get_bits1(&s->gb);
 
1351
            mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
 
1352
            if(mb_type<0){
 
1353
                av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
 
1354
                return -1;
 
1355
            }
 
1356
            mb_type= mb_type_b_map[ mb_type ];
 
1357
            if(modb2) cbp= 0;
 
1358
            else{
 
1359
                s->dsp.clear_blocks(s->block[0]);
 
1360
                cbp= get_bits(&s->gb, 6);
 
1361
            }
 
1362
 
 
1363
            if ((!IS_DIRECT(mb_type)) && cbp) {
 
1364
                if(get_bits1(&s->gb)){
 
1365
                    ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
 
1366
                }
 
1367
            }
 
1368
 
 
1369
            if(!s->progressive_sequence){
 
1370
                if(cbp)
 
1371
                    s->interlaced_dct= get_bits1(&s->gb);
 
1372
 
 
1373
                if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
 
1374
                    mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
 
1375
                    mb_type &= ~MB_TYPE_16x16;
 
1376
 
 
1377
                    if(USES_LIST(mb_type, 0)){
 
1378
                        s->field_select[0][0]= get_bits1(&s->gb);
 
1379
                        s->field_select[0][1]= get_bits1(&s->gb);
 
1380
                    }
 
1381
                    if(USES_LIST(mb_type, 1)){
 
1382
                        s->field_select[1][0]= get_bits1(&s->gb);
 
1383
                        s->field_select[1][1]= get_bits1(&s->gb);
 
1384
                    }
 
1385
                }
 
1386
            }
 
1387
 
 
1388
            s->mv_dir = 0;
 
1389
            if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
 
1390
                s->mv_type= MV_TYPE_16X16;
 
1391
 
 
1392
                if(USES_LIST(mb_type, 0)){
 
1393
                    s->mv_dir = MV_DIR_FORWARD;
 
1394
 
 
1395
                    mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
 
1396
                    my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
 
1397
                    s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
 
1398
                    s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
 
1399
                }
 
1400
 
 
1401
                if(USES_LIST(mb_type, 1)){
 
1402
                    s->mv_dir |= MV_DIR_BACKWARD;
 
1403
 
 
1404
                    mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
 
1405
                    my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
 
1406
                    s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
 
1407
                    s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
 
1408
                }
 
1409
            }else if(!IS_DIRECT(mb_type)){
 
1410
                s->mv_type= MV_TYPE_FIELD;
 
1411
 
 
1412
                if(USES_LIST(mb_type, 0)){
 
1413
                    s->mv_dir = MV_DIR_FORWARD;
 
1414
 
 
1415
                    for(i=0; i<2; i++){
 
1416
                        mx = h263_decode_motion(s, s->last_mv[0][i][0]  , s->f_code);
 
1417
                        my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
 
1418
                        s->last_mv[0][i][0]=  s->mv[0][i][0] = mx;
 
1419
                        s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
 
1420
                    }
 
1421
                }
 
1422
 
 
1423
                if(USES_LIST(mb_type, 1)){
 
1424
                    s->mv_dir |= MV_DIR_BACKWARD;
 
1425
 
 
1426
                    for(i=0; i<2; i++){
 
1427
                        mx = h263_decode_motion(s, s->last_mv[1][i][0]  , s->b_code);
 
1428
                        my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
 
1429
                        s->last_mv[1][i][0]=  s->mv[1][i][0] = mx;
 
1430
                        s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
 
1431
                    }
 
1432
                }
 
1433
            }
 
1434
        }
 
1435
 
 
1436
        if(IS_DIRECT(mb_type)){
 
1437
            if(IS_SKIP(mb_type))
 
1438
                mx=my=0;
 
1439
            else{
 
1440
                mx = h263_decode_motion(s, 0, 1);
 
1441
                my = h263_decode_motion(s, 0, 1);
 
1442
            }
 
1443
 
 
1444
            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
 
1445
            mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
 
1446
        }
 
1447
        s->current_picture.mb_type[xy]= mb_type;
 
1448
    } else { /* I-Frame */
 
1449
        do{
 
1450
            cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
 
1451
            if (cbpc < 0){
 
1452
                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
 
1453
                return -1;
 
1454
            }
 
1455
        }while(cbpc == 8);
 
1456
 
 
1457
        dquant = cbpc & 4;
 
1458
        s->mb_intra = 1;
 
1459
intra:
 
1460
        s->ac_pred = get_bits1(&s->gb);
 
1461
        if(s->ac_pred)
 
1462
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
 
1463
        else
 
1464
            s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
 
1465
 
 
1466
        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 
1467
        if(cbpy<0){
 
1468
            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
 
1469
            return -1;
 
1470
        }
 
1471
        cbp = (cbpc & 3) | (cbpy << 2);
 
1472
 
 
1473
        s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
 
1474
 
 
1475
        if (dquant) {
 
1476
            ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
 
1477
        }
 
1478
 
 
1479
        if(!s->progressive_sequence)
 
1480
            s->interlaced_dct= get_bits1(&s->gb);
 
1481
 
 
1482
        s->dsp.clear_blocks(s->block[0]);
 
1483
        /* decode each block */
 
1484
        for (i = 0; i < 6; i++) {
 
1485
            if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
 
1486
                return -1;
 
1487
            cbp+=cbp;
 
1488
        }
 
1489
        goto end;
 
1490
    }
 
1491
 
 
1492
    /* decode each block */
 
1493
    for (i = 0; i < 6; i++) {
 
1494
        if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
 
1495
            return -1;
 
1496
        cbp+=cbp;
 
1497
    }
 
1498
end:
 
1499
 
 
1500
        /* per-MB end of slice check */
 
1501
    if(s->codec_id==CODEC_ID_MPEG4){
 
1502
        if(mpeg4_is_resync(s)){
 
1503
            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
 
1504
 
 
1505
            if(s->pict_type==FF_B_TYPE){
 
1506
                ff_thread_await_progress((AVFrame*)s->next_picture_ptr,
 
1507
                                        (s->mb_x + delta >= s->mb_width) ? FFMIN(s->mb_y+1, s->mb_height-1) : s->mb_y, 0);
 
1508
            }
 
1509
 
 
1510
            if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta])
 
1511
                return SLICE_OK;
 
1512
            return SLICE_END;
 
1513
        }
 
1514
    }
 
1515
 
 
1516
    return SLICE_OK;
 
1517
}
 
1518
 
 
1519
 
 
1520
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
 
1521
    int hours, minutes, seconds;
 
1522
 
 
1523
    hours= get_bits(gb, 5);
 
1524
    minutes= get_bits(gb, 6);
 
1525
    skip_bits1(gb);
 
1526
    seconds= get_bits(gb, 6);
 
1527
 
 
1528
    s->time_base= seconds + 60*(minutes + 60*hours);
 
1529
 
 
1530
    skip_bits1(gb);
 
1531
    skip_bits1(gb);
 
1532
 
 
1533
    return 0;
 
1534
}
 
1535
 
 
1536
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
 
1537
    int width, height, vo_ver_id;
 
1538
 
 
1539
    /* vol header */
 
1540
    skip_bits(gb, 1); /* random access */
 
1541
    s->vo_type= get_bits(gb, 8);
 
1542
    if (get_bits1(gb) != 0) { /* is_ol_id */
 
1543
        vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
 
1544
        skip_bits(gb, 3); /* vo_priority */
 
1545
    } else {
 
1546
        vo_ver_id = 1;
 
1547
    }
 
1548
    s->aspect_ratio_info= get_bits(gb, 4);
 
1549
    if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
 
1550
        s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
 
1551
        s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
 
1552
    }else{
 
1553
        s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info];
 
1554
    }
 
1555
 
 
1556
    if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
 
1557
        int chroma_format= get_bits(gb, 2);
 
1558
        if(chroma_format!=CHROMA_420){
 
1559
            av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
 
1560
        }
 
1561
        s->low_delay= get_bits1(gb);
 
1562
        if(get_bits1(gb)){ /* vbv parameters */
 
1563
            get_bits(gb, 15);   /* first_half_bitrate */
 
1564
            skip_bits1(gb);     /* marker */
 
1565
            get_bits(gb, 15);   /* latter_half_bitrate */
 
1566
            skip_bits1(gb);     /* marker */
 
1567
            get_bits(gb, 15);   /* first_half_vbv_buffer_size */
 
1568
            skip_bits1(gb);     /* marker */
 
1569
            get_bits(gb, 3);    /* latter_half_vbv_buffer_size */
 
1570
            get_bits(gb, 11);   /* first_half_vbv_occupancy */
 
1571
            skip_bits1(gb);     /* marker */
 
1572
            get_bits(gb, 15);   /* latter_half_vbv_occupancy */
 
1573
            skip_bits1(gb);     /* marker */
 
1574
        }
 
1575
    }else{
 
1576
        // set low delay flag only once the smartest? low delay detection won't be overriden
 
1577
        if(s->picture_number==0)
 
1578
            s->low_delay=0;
 
1579
    }
 
1580
 
 
1581
    s->shape = get_bits(gb, 2); /* vol shape */
 
1582
    if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
 
1583
    if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
 
1584
        av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
 
1585
        skip_bits(gb, 4);  //video_object_layer_shape_extension
 
1586
    }
 
1587
 
 
1588
    check_marker(gb, "before time_increment_resolution");
 
1589
 
 
1590
    s->avctx->time_base.den = get_bits(gb, 16);
 
1591
    if(!s->avctx->time_base.den){
 
1592
        av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
 
1593
        s->avctx->time_base.num = 0;
 
1594
        return -1;
 
1595
    }
 
1596
 
 
1597
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
 
1598
    if (s->time_increment_bits < 1)
 
1599
        s->time_increment_bits = 1;
 
1600
 
 
1601
    check_marker(gb, "before fixed_vop_rate");
 
1602
 
 
1603
    if (get_bits1(gb) != 0) {   /* fixed_vop_rate  */
 
1604
        s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
 
1605
    }else
 
1606
        s->avctx->time_base.num = 1;
 
1607
 
 
1608
    s->t_frame=0;
 
1609
 
 
1610
    if (s->shape != BIN_ONLY_SHAPE) {
 
1611
        if (s->shape == RECT_SHAPE) {
 
1612
            skip_bits1(gb);   /* marker */
 
1613
            width = get_bits(gb, 13);
 
1614
            skip_bits1(gb);   /* marker */
 
1615
            height = get_bits(gb, 13);
 
1616
            skip_bits1(gb);   /* marker */
 
1617
            if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */
 
1618
                s->width = width;
 
1619
                s->height = height;
 
1620
            }
 
1621
        }
 
1622
 
 
1623
        s->progressive_sequence=
 
1624
        s->progressive_frame= get_bits1(gb)^1;
 
1625
        s->interlaced_dct=0;
 
1626
        if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
 
1627
            av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");   /* OBMC Disable */
 
1628
        if (vo_ver_id == 1) {
 
1629
            s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
 
1630
        } else {
 
1631
            s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
 
1632
        }
 
1633
        if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
 
1634
        if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
 
1635
            if(s->vol_sprite_usage==STATIC_SPRITE){
 
1636
                s->sprite_width = get_bits(gb, 13);
 
1637
                skip_bits1(gb); /* marker */
 
1638
                s->sprite_height= get_bits(gb, 13);
 
1639
                skip_bits1(gb); /* marker */
 
1640
                s->sprite_left  = get_bits(gb, 13);
 
1641
                skip_bits1(gb); /* marker */
 
1642
                s->sprite_top   = get_bits(gb, 13);
 
1643
                skip_bits1(gb); /* marker */
 
1644
            }
 
1645
            s->num_sprite_warping_points= get_bits(gb, 6);
 
1646
            if(s->num_sprite_warping_points > 3){
 
1647
                av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
 
1648
                s->num_sprite_warping_points= 0;
 
1649
                return -1;
 
1650
            }
 
1651
            s->sprite_warping_accuracy = get_bits(gb, 2);
 
1652
            s->sprite_brightness_change= get_bits1(gb);
 
1653
            if(s->vol_sprite_usage==STATIC_SPRITE)
 
1654
                s->low_latency_sprite= get_bits1(gb);
 
1655
        }
 
1656
        // FIXME sadct disable bit if verid!=1 && shape not rect
 
1657
 
 
1658
        if (get_bits1(gb) == 1) {   /* not_8_bit */
 
1659
            s->quant_precision = get_bits(gb, 4); /* quant_precision */
 
1660
            if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
 
1661
            if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
 
1662
        } else {
 
1663
            s->quant_precision = 5;
 
1664
        }
 
1665
 
 
1666
        // FIXME a bunch of grayscale shape things
 
1667
 
 
1668
        if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
 
1669
            int i, v;
 
1670
 
 
1671
            /* load default matrixes */
 
1672
            for(i=0; i<64; i++){
 
1673
                int j= s->dsp.idct_permutation[i];
 
1674
                v= ff_mpeg4_default_intra_matrix[i];
 
1675
                s->intra_matrix[j]= v;
 
1676
                s->chroma_intra_matrix[j]= v;
 
1677
 
 
1678
                v= ff_mpeg4_default_non_intra_matrix[i];
 
1679
                s->inter_matrix[j]= v;
 
1680
                s->chroma_inter_matrix[j]= v;
 
1681
            }
 
1682
 
 
1683
            /* load custom intra matrix */
 
1684
            if(get_bits1(gb)){
 
1685
                int last=0;
 
1686
                for(i=0; i<64; i++){
 
1687
                    int j;
 
1688
                    v= get_bits(gb, 8);
 
1689
                    if(v==0) break;
 
1690
 
 
1691
                    last= v;
 
1692
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
 
1693
                    s->intra_matrix[j]= v;
 
1694
                    s->chroma_intra_matrix[j]= v;
 
1695
                }
 
1696
 
 
1697
                /* replicate last value */
 
1698
                for(; i<64; i++){
 
1699
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
 
1700
                    s->intra_matrix[j]= last;
 
1701
                    s->chroma_intra_matrix[j]= last;
 
1702
                }
 
1703
            }
 
1704
 
 
1705
            /* load custom non intra matrix */
 
1706
            if(get_bits1(gb)){
 
1707
                int last=0;
 
1708
                for(i=0; i<64; i++){
 
1709
                    int j;
 
1710
                    v= get_bits(gb, 8);
 
1711
                    if(v==0) break;
 
1712
 
 
1713
                    last= v;
 
1714
                    j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
 
1715
                    s->inter_matrix[j]= v;
 
1716
                    s->chroma_inter_matrix[j]= v;
 
1717
                }
 
1718
 
 
1719
                /* replicate last value */
 
1720
                for(; i<64; i++){
 
1721
                    int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
 
1722
                    s->inter_matrix[j]= last;
 
1723
                    s->chroma_inter_matrix[j]= last;
 
1724
                }
 
1725
            }
 
1726
 
 
1727
            // FIXME a bunch of grayscale shape things
 
1728
        }
 
1729
 
 
1730
        if(vo_ver_id != 1)
 
1731
             s->quarter_sample= get_bits1(gb);
 
1732
        else s->quarter_sample=0;
 
1733
 
 
1734
        if(!get_bits1(gb)){
 
1735
            int pos= get_bits_count(gb);
 
1736
            int estimation_method= get_bits(gb, 2);
 
1737
            if(estimation_method<2){
 
1738
                if(!get_bits1(gb)){
 
1739
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque
 
1740
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent
 
1741
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae
 
1742
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae
 
1743
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update
 
1744
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling
 
1745
                }
 
1746
                if(!get_bits1(gb)){
 
1747
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks
 
1748
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks
 
1749
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks
 
1750
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks
 
1751
                }
 
1752
                if(!check_marker(gb, "in complexity estimation part 1")){
 
1753
                    skip_bits_long(gb, pos - get_bits_count(gb));
 
1754
                    goto no_cplx_est;
 
1755
                }
 
1756
                if(!get_bits1(gb)){
 
1757
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs
 
1758
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines
 
1759
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms
 
1760
                    s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits
 
1761
                }
 
1762
                if(!get_bits1(gb)){
 
1763
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm
 
1764
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm
 
1765
                    s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q
 
1766
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q
 
1767
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2
 
1768
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4
 
1769
                }
 
1770
                if(!check_marker(gb, "in complexity estimation part 2")){
 
1771
                    skip_bits_long(gb, pos - get_bits_count(gb));
 
1772
                    goto no_cplx_est;
 
1773
                }
 
1774
                if(estimation_method==1){
 
1775
                    s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct
 
1776
                    s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel
 
1777
                }
 
1778
            }else
 
1779
                av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method);
 
1780
        }else{
 
1781
no_cplx_est:
 
1782
            s->cplx_estimation_trash_i=
 
1783
            s->cplx_estimation_trash_p=
 
1784
            s->cplx_estimation_trash_b= 0;
 
1785
        }
 
1786
 
 
1787
        s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
 
1788
 
 
1789
        s->data_partitioning= get_bits1(gb);
 
1790
        if(s->data_partitioning){
 
1791
            s->rvlc= get_bits1(gb);
 
1792
        }
 
1793
 
 
1794
        if(vo_ver_id != 1) {
 
1795
            s->new_pred= get_bits1(gb);
 
1796
            if(s->new_pred){
 
1797
                av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
 
1798
                skip_bits(gb, 2); /* requested upstream message type */
 
1799
                skip_bits1(gb); /* newpred segment type */
 
1800
            }
 
1801
            s->reduced_res_vop= get_bits1(gb);
 
1802
            if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
 
1803
        }
 
1804
        else{
 
1805
            s->new_pred=0;
 
1806
            s->reduced_res_vop= 0;
 
1807
        }
 
1808
 
 
1809
        s->scalability= get_bits1(gb);
 
1810
 
 
1811
        if (s->scalability) {
 
1812
            GetBitContext bak= *gb;
 
1813
            int ref_layer_id;
 
1814
            int ref_layer_sampling_dir;
 
1815
            int h_sampling_factor_n;
 
1816
            int h_sampling_factor_m;
 
1817
            int v_sampling_factor_n;
 
1818
            int v_sampling_factor_m;
 
1819
 
 
1820
            s->hierachy_type= get_bits1(gb);
 
1821
            ref_layer_id= get_bits(gb, 4);
 
1822
            ref_layer_sampling_dir= get_bits1(gb);
 
1823
            h_sampling_factor_n= get_bits(gb, 5);
 
1824
            h_sampling_factor_m= get_bits(gb, 5);
 
1825
            v_sampling_factor_n= get_bits(gb, 5);
 
1826
            v_sampling_factor_m= get_bits(gb, 5);
 
1827
            s->enhancement_type= get_bits1(gb);
 
1828
 
 
1829
            if(   h_sampling_factor_n==0 || h_sampling_factor_m==0
 
1830
               || v_sampling_factor_n==0 || v_sampling_factor_m==0){
 
1831
                /* illegal scalability header (VERY broken encoder),
 
1832
                 * trying to workaround */
 
1833
                s->scalability=0;
 
1834
                *gb= bak;
 
1835
            }else
 
1836
                av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
 
1837
 
 
1838
            // bin shape stuff FIXME
 
1839
        }
 
1840
    }
 
1841
    return 0;
 
1842
}
 
1843
 
 
1844
/**
 
1845
 * decodes the user data stuff in the header.
 
1846
 * Also initializes divx/xvid/lavc_version/build.
 
1847
 */
 
1848
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
 
1849
    char buf[256];
 
1850
    int i;
 
1851
    int e;
 
1852
    int ver = 0, build = 0, ver2 = 0, ver3 = 0;
 
1853
    char last;
 
1854
 
 
1855
    for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
 
1856
        if(show_bits(gb, 23) == 0) break;
 
1857
        buf[i]= get_bits(gb, 8);
 
1858
    }
 
1859
    buf[i]=0;
 
1860
 
 
1861
    /* divx detection */
 
1862
    e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
 
1863
    if(e<2)
 
1864
        e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
 
1865
    if(e>=2){
 
1866
        s->divx_version= ver;
 
1867
        s->divx_build= build;
 
1868
        s->divx_packed= e==3 && last=='p';
 
1869
        if(s->divx_packed && !s->showed_packed_warning) {
 
1870
            av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n");
 
1871
            s->showed_packed_warning=1;
 
1872
        }
 
1873
    }
 
1874
 
 
1875
    /* ffmpeg detection */
 
1876
    e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
 
1877
    if(e!=4)
 
1878
        e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
 
1879
    if(e!=4){
 
1880
        e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
 
1881
        if (e>1)
 
1882
            build= (ver<<16) + (ver2<<8) + ver3;
 
1883
    }
 
1884
    if(e!=4){
 
1885
        if(strcmp(buf, "ffmpeg")==0){
 
1886
            s->lavc_build= 4600;
 
1887
        }
 
1888
    }
 
1889
    if(e==4){
 
1890
        s->lavc_build= build;
 
1891
    }
 
1892
 
 
1893
    /* Xvid detection */
 
1894
    e=sscanf(buf, "XviD%d", &build);
 
1895
    if(e==1){
 
1896
        s->xvid_build= build;
 
1897
    }
 
1898
 
 
1899
    return 0;
 
1900
}
 
1901
 
 
1902
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
 
1903
    int time_incr, time_increment;
 
1904
 
 
1905
    s->pict_type = get_bits(gb, 2) + FF_I_TYPE;        /* pict type: I = 0 , P = 1 */
 
1906
    if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
 
1907
        av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
 
1908
        s->low_delay=0;
 
1909
    }
 
1910
 
 
1911
    s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
 
1912
    if(s->partitioned_frame)
 
1913
        s->decode_mb= mpeg4_decode_partitioned_mb;
 
1914
    else
 
1915
        s->decode_mb= mpeg4_decode_mb;
 
1916
 
 
1917
    time_incr=0;
 
1918
    while (get_bits1(gb) != 0)
 
1919
        time_incr++;
 
1920
 
 
1921
    check_marker(gb, "before time_increment");
 
1922
 
 
1923
    if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
 
1924
        av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
 
1925
 
 
1926
        for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
 
1927
            if (    s->pict_type == FF_P_TYPE
 
1928
                || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
 
1929
                if((show_bits(gb, s->time_increment_bits+6)&0x37) == 0x30) break;
 
1930
            }else
 
1931
                if((show_bits(gb, s->time_increment_bits+5)&0x1F) == 0x18) break;
 
1932
        }
 
1933
 
 
1934
        av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
 
1935
    }
 
1936
 
 
1937
    if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
 
1938
    else time_increment= get_bits(gb, s->time_increment_bits);
 
1939
 
 
1940
    if(s->pict_type!=FF_B_TYPE){
 
1941
        s->last_time_base= s->time_base;
 
1942
        s->time_base+= time_incr;
 
1943
        s->time= s->time_base*s->avctx->time_base.den + time_increment;
 
1944
        if(s->workaround_bugs&FF_BUG_UMP4){
 
1945
            if(s->time < s->last_non_b_time){
 
1946
                /* header is not mpeg-4-compatible, broken encoder,
 
1947
                 * trying to workaround */
 
1948
                s->time_base++;
 
1949
                s->time+= s->avctx->time_base.den;
 
1950
            }
 
1951
        }
 
1952
        s->pp_time= s->time - s->last_non_b_time;
 
1953
        s->last_non_b_time= s->time;
 
1954
    }else{
 
1955
        s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
 
1956
        s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 
1957
        if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 
1958
            /* messed up order, maybe after seeking? skipping current b-frame */
 
1959
            return FRAME_SKIPPED;
 
1960
        }
 
1961
        ff_mpeg4_init_direct_mv(s);
 
1962
 
 
1963
        if(s->t_frame==0) s->t_frame= s->pb_time;
 
1964
        if(s->t_frame==0) s->t_frame=1; // 1/0 protection
 
1965
        s->pp_field_time= (  ROUNDED_DIV(s->last_non_b_time, s->t_frame)
 
1966
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
 
1967
        s->pb_field_time= (  ROUNDED_DIV(s->time, s->t_frame)
 
1968
                           - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
 
1969
        if(!s->progressive_sequence){
 
1970
            if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
 
1971
                return FRAME_SKIPPED;
 
1972
        }
 
1973
    }
 
1974
 
 
1975
    if(s->avctx->time_base.num)
 
1976
        s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
 
1977
    else
 
1978
        s->current_picture_ptr->pts= AV_NOPTS_VALUE;
 
1979
    if(s->avctx->debug&FF_DEBUG_PTS)
 
1980
        av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
 
1981
 
 
1982
    check_marker(gb, "before vop_coded");
 
1983
 
 
1984
    /* vop coded */
 
1985
    if (get_bits1(gb) != 1){
 
1986
        if(s->avctx->debug&FF_DEBUG_PICT_INFO)
 
1987
            av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
 
1988
        return FRAME_SKIPPED;
 
1989
    }
 
1990
    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE
 
1991
                          || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
 
1992
        /* rounding type for motion estimation */
 
1993
        s->no_rounding = get_bits1(gb);
 
1994
    } else {
 
1995
        s->no_rounding = 0;
 
1996
    }
 
1997
//FIXME reduced res stuff
 
1998
 
 
1999
     if (s->shape != RECT_SHAPE) {
 
2000
         if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) {
 
2001
             int width, height, hor_spat_ref, ver_spat_ref;
 
2002
 
 
2003
             width = get_bits(gb, 13);
 
2004
             skip_bits1(gb);   /* marker */
 
2005
             height = get_bits(gb, 13);
 
2006
             skip_bits1(gb);   /* marker */
 
2007
             hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
 
2008
             skip_bits1(gb);   /* marker */
 
2009
             ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
 
2010
         }
 
2011
         skip_bits1(gb); /* change_CR_disable */
 
2012
 
 
2013
         if (get_bits1(gb) != 0) {
 
2014
             skip_bits(gb, 8); /* constant_alpha_value */
 
2015
         }
 
2016
     }
 
2017
//FIXME complexity estimation stuff
 
2018
 
 
2019
     if (s->shape != BIN_ONLY_SHAPE) {
 
2020
         skip_bits_long(gb, s->cplx_estimation_trash_i);
 
2021
         if(s->pict_type != FF_I_TYPE)
 
2022
            skip_bits_long(gb, s->cplx_estimation_trash_p);
 
2023
         if(s->pict_type == FF_B_TYPE)
 
2024
            skip_bits_long(gb, s->cplx_estimation_trash_b);
 
2025
 
 
2026
         s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
 
2027
         if(!s->progressive_sequence){
 
2028
             s->top_field_first= get_bits1(gb);
 
2029
             s->alternate_scan= get_bits1(gb);
 
2030
         }else
 
2031
             s->alternate_scan= 0;
 
2032
     }
 
2033
 
 
2034
     if(s->alternate_scan){
 
2035
         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
 
2036
         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
 
2037
         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
 
2038
         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 
2039
     } else{
 
2040
         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
 
2041
         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
 
2042
         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 
2043
         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 
2044
     }
 
2045
 
 
2046
     if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
 
2047
         mpeg4_decode_sprite_trajectory(s, gb);
 
2048
         if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
 
2049
         if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
 
2050
     }
 
2051
 
 
2052
     if (s->shape != BIN_ONLY_SHAPE) {
 
2053
         s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
 
2054
         if(s->qscale==0){
 
2055
             av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
 
2056
             return -1; // makes no sense to continue, as there is nothing left from the image then
 
2057
         }
 
2058
 
 
2059
         if (s->pict_type != FF_I_TYPE) {
 
2060
             s->f_code = get_bits(gb, 3);       /* fcode_for */
 
2061
             if(s->f_code==0){
 
2062
                 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
 
2063
                 return -1; // makes no sense to continue, as the MV decoding will break very quickly
 
2064
             }
 
2065
         }else
 
2066
             s->f_code=1;
 
2067
 
 
2068
         if (s->pict_type == FF_B_TYPE) {
 
2069
             s->b_code = get_bits(gb, 3);
 
2070
         }else
 
2071
             s->b_code=1;
 
2072
 
 
2073
         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
 
2074
             av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d\n",
 
2075
                 s->qscale, s->f_code, s->b_code,
 
2076
                 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
 
2077
                 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
 
2078
                 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
 
2079
                 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold, s->cplx_estimation_trash_i, s->cplx_estimation_trash_p, s->cplx_estimation_trash_b);
 
2080
         }
 
2081
 
 
2082
         if(!s->scalability){
 
2083
             if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) {
 
2084
                 skip_bits1(gb); // vop shape coding type
 
2085
             }
 
2086
         }else{
 
2087
             if(s->enhancement_type){
 
2088
                 int load_backward_shape= get_bits1(gb);
 
2089
                 if(load_backward_shape){
 
2090
                     av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
 
2091
                 }
 
2092
             }
 
2093
             skip_bits(gb, 2); //ref_select_code
 
2094
         }
 
2095
     }
 
2096
     /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
 
2097
     // note we cannot detect divx5 without b-frames easily (although it's buggy too)
 
2098
     if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==-1 && s->picture_number==0){
 
2099
         av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
 
2100
         s->low_delay=1;
 
2101
     }
 
2102
 
 
2103
     s->picture_number++; // better than pic number==0 always ;)
 
2104
 
 
2105
     s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
 
2106
     s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
 
2107
 
 
2108
     if(s->workaround_bugs&FF_BUG_EDGE){
 
2109
         s->h_edge_pos= s->width;
 
2110
         s->v_edge_pos= s->height;
 
2111
     }
 
2112
     return 0;
 
2113
}
 
2114
 
 
2115
/**
 
2116
 * decode mpeg4 headers
 
2117
 * @return <0 if no VOP found (or a damaged one)
 
2118
 *         FRAME_SKIPPED if a not coded VOP is found
 
2119
 *         0 if a VOP is found
 
2120
 */
 
2121
int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
 
2122
{
 
2123
    int startcode, v;
 
2124
 
 
2125
    /* search next start code */
 
2126
    align_get_bits(gb);
 
2127
 
 
2128
    if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){
 
2129
        skip_bits(gb, 24);
 
2130
        if(get_bits(gb, 8) == 0xF0)
 
2131
            goto end;
 
2132
    }
 
2133
 
 
2134
    startcode = 0xff;
 
2135
    for(;;) {
 
2136
        if(get_bits_count(gb) >= gb->size_in_bits){
 
2137
            if(gb->size_in_bits==8 && (s->divx_version>=0 || s->xvid_build>=0)){
 
2138
                av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
 
2139
                return FRAME_SKIPPED; //divx bug
 
2140
            }else
 
2141
                return -1; //end of stream
 
2142
        }
 
2143
 
 
2144
        /* use the bits after the test */
 
2145
        v = get_bits(gb, 8);
 
2146
        startcode = ((startcode << 8) | v) & 0xffffffff;
 
2147
 
 
2148
        if((startcode&0xFFFFFF00) != 0x100)
 
2149
            continue; //no startcode
 
2150
 
 
2151
        if(s->avctx->debug&FF_DEBUG_STARTCODE){
 
2152
            av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
 
2153
            if     (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
 
2154
            else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
 
2155
            else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
 
2156
            else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
 
2157
            else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
 
2158
            else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
 
2159
            else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
 
2160
            else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
 
2161
            else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
 
2162
            else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
 
2163
            else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
 
2164
            else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
 
2165
            else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
 
2166
            else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
 
2167
            else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
 
2168
            else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
 
2169
            else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
 
2170
            else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
 
2171
            else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
 
2172
            else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
 
2173
            else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
 
2174
            else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
 
2175
            else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
 
2176
            else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
 
2177
            else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
 
2178
            else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
 
2179
            else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
 
2180
            av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
 
2181
        }
 
2182
 
 
2183
        if(startcode >= 0x120 && startcode <= 0x12F){
 
2184
            if(decode_vol_header(s, gb) < 0)
 
2185
                return -1;
 
2186
        }
 
2187
        else if(startcode == USER_DATA_STARTCODE){
 
2188
            decode_user_data(s, gb);
 
2189
        }
 
2190
        else if(startcode == GOP_STARTCODE){
 
2191
            mpeg4_decode_gop_header(s, gb);
 
2192
        }
 
2193
        else if(startcode == VOP_STARTCODE){
 
2194
            break;
 
2195
        }
 
2196
 
 
2197
        align_get_bits(gb);
 
2198
        startcode = 0xff;
 
2199
    }
 
2200
end:
 
2201
    if(s->flags& CODEC_FLAG_LOW_DELAY)
 
2202
        s->low_delay=1;
 
2203
    s->avctx->has_b_frames= !s->low_delay;
 
2204
    return decode_vop_header(s, gb);
 
2205
}
 
2206
 
 
2207
static av_cold int decode_init(AVCodecContext *avctx)
 
2208
{
 
2209
    MpegEncContext *s = avctx->priv_data;
 
2210
    int ret;
 
2211
    static int done = 0;
 
2212
 
 
2213
    s->divx_version=
 
2214
    s->divx_build=
 
2215
    s->xvid_build=
 
2216
    s->lavc_build= -1;
 
2217
 
 
2218
    if((ret=ff_h263_decode_init(avctx)) < 0)
 
2219
        return ret;
 
2220
 
 
2221
    if (!done) {
 
2222
        done = 1;
 
2223
 
 
2224
        init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
 
2225
        init_rl(&rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
 
2226
        init_rl(&rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
 
2227
        INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
 
2228
        INIT_VLC_RL(rvlc_rl_inter, 1072);
 
2229
        INIT_VLC_RL(rvlc_rl_intra, 1072);
 
2230
        INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
 
2231
                 &ff_mpeg4_DCtab_lum[0][1], 2, 1,
 
2232
                 &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
 
2233
        INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
 
2234
                 &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
 
2235
                 &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
 
2236
        INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
 
2237
                 &sprite_trajectory_tab[0][1], 4, 2,
 
2238
                 &sprite_trajectory_tab[0][0], 4, 2, 128);
 
2239
        INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
 
2240
                 &mb_type_b_tab[0][1], 2, 1,
 
2241
                 &mb_type_b_tab[0][0], 2, 1, 16);
 
2242
    }
 
2243
 
 
2244
    s->h263_pred = 1;
 
2245
    s->low_delay = 0; //default, might be overriden in the vol header during header parsing
 
2246
    s->decode_mb= mpeg4_decode_mb;
 
2247
    s->time_increment_bits = 4; /* default value for broken headers */
 
2248
    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
 
2249
 
 
2250
    return 0;
 
2251
}
 
2252
 
 
2253
AVCodec mpeg4_decoder = {
 
2254
    "mpeg4",
 
2255
    AVMEDIA_TYPE_VIDEO,
 
2256
    CODEC_ID_MPEG4,
 
2257
    sizeof(MpegEncContext),
 
2258
    decode_init,
 
2259
    NULL,
 
2260
    ff_h263_decode_end,
 
2261
    ff_h263_decode_frame,
 
2262
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_FRAME_THREADS,
 
2263
    .flush= ff_mpeg_flush,
 
2264
    .max_lowres= 3,
 
2265
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
 
2266
    .pix_fmts= ff_hwaccel_pixfmt_list_420,
 
2267
    .update_thread_context= ONLY_IF_THREADS_ENABLED(ff_mpeg_update_thread_context)
 
2268
};
 
2269
 
 
2270
 
 
2271
#if CONFIG_MPEG4_VDPAU_DECODER
 
2272
AVCodec mpeg4_vdpau_decoder = {
 
2273
    "mpeg4_vdpau",
 
2274
    AVMEDIA_TYPE_VIDEO,
 
2275
    CODEC_ID_MPEG4,
 
2276
    sizeof(MpegEncContext),
 
2277
    decode_init,
 
2278
    NULL,
 
2279
    ff_h263_decode_end,
 
2280
    ff_h263_decode_frame,
 
2281
    CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
 
2282
    .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
 
2283
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_VDPAU_MPEG4, PIX_FMT_NONE},
 
2284
};
 
2285
#endif