3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of Libav.
8 * Libav 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.
13 * Libav 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.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include "mpegvideo.h"
24 #include "mpeg4video.h"
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
34 #define MB_TYPE_B_VLC_BITS 4
37 static VLC dc_lum
, dc_chrom
;
38 static VLC sprite_trajectory
;
39 static VLC mb_type_b_vlc
;
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
,
50 * @param n block index (0-3 are luma, 4-5 are chroma)
51 * @param dir the ac prediction direction
53 void mpeg4_pred_ac(MpegEncContext
* s
, DCTELEM
*block
, int n
,
57 int16_t *ac_val
, *ac_val1
;
58 int8_t * const qscale_table
= s
->current_picture
.f
.qscale_table
;
61 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
65 const int xy
= s
->mb_x
-1 + s
->mb_y
*s
->mb_stride
;
69 if(s
->mb_x
==0 || s
->qscale
== qscale_table
[xy
] || n
==1 || n
==3){
72 block
[s
->dsp
.idct_permutation
[i
<<3]] += ac_val
[i
];
75 /* different qscale, we must rescale */
77 block
[s
->dsp
.idct_permutation
[i
<<3]] += ROUNDED_DIV(ac_val
[i
]*qscale_table
[xy
], s
->qscale
);
81 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
- s
->mb_stride
;
83 ac_val
-= 16 * s
->block_wrap
[n
];
85 if(s
->mb_y
==0 || s
->qscale
== qscale_table
[xy
] || n
==2 || n
==3){
88 block
[s
->dsp
.idct_permutation
[i
]] += ac_val
[i
+ 8];
91 /* different qscale, we must rescale */
93 block
[s
->dsp
.idct_permutation
[i
]] += ROUNDED_DIV(ac_val
[i
+ 8]*qscale_table
[xy
], s
->qscale
);
100 ac_val1
[i
] = block
[s
->dsp
.idct_permutation
[i
<<3]];
104 ac_val1
[8 + i
] = block
[s
->dsp
.idct_permutation
[i
]];
109 * check if the next stuff is a resync marker or the end.
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);
116 if(s
->workaround_bugs
&FF_BUG_NO_PADDING
){
121 if(s
->pict_type
==AV_PICTURE_TYPE_B
|| (v
>>(8-s
->pict_type
)!=1) || s
->partitioned_frame
)
123 skip_bits(&s
->gb
, 8+s
->pict_type
);
124 bits_count
+= 8+s
->pict_type
;
125 v
= show_bits(&s
->gb
, 16);
128 if(bits_count
+ 8 >= s
->gb
.size_in_bits
){
130 v
|= 0x7F >> (7-(bits_count
&7));
135 if(v
== ff_mpeg4_resync_prefix
[bits_count
&7]){
137 GetBitContext gb
= s
->gb
;
139 skip_bits(&s
->gb
, 1);
140 align_get_bits(&s
->gb
);
142 for(len
=0; len
<32; len
++){
143 if(get_bits1(&s
->gb
)) break;
148 if(len
>=ff_mpeg4_get_video_packet_prefix_length(s
))
155 static void mpeg4_decode_sprite_trajectory(MpegEncContext
* s
, GetBitContext
*gb
)
158 int a
= 2<<s
->sprite_warping_accuracy
;
159 int rho
= 3-s
->sprite_warping_accuracy
;
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];
171 for(i
=0; i
<s
->num_sprite_warping_points
; i
++){
175 length
= get_vlc2(gb
, sprite_trajectory
.table
, SPRITE_TRAJ_VLC_BITS
, 3);
177 x
= get_xbits(gb
, length
);
179 if(!(s
->divx_version
==500 && s
->divx_build
==413)) skip_bits1(gb
); /* marker bit */
181 length
= get_vlc2(gb
, sprite_trajectory
.table
, SPRITE_TRAJ_VLC_BITS
, 3);
183 y
=get_xbits(gb
, length
);
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
;
190 s
->sprite_traj
[i
][0]= s
->sprite_traj
[i
][1]= 0;
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'
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];
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]);
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]); */
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
);
229 switch(s
->num_sprite_warping_points
)
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;
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;
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]
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]
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]);
279 s
->sprite_shift
[0]= alpha
+rho
;
280 s
->sprite_shift
[1]= alpha
+rho
+2;
283 min_ab
= FFMIN(alpha
, beta
);
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]
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]
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
;
309 s
->sprite_shift
[0]= alpha
+ beta
+ rho
- min_ab
;
310 s
->sprite_shift
[1]= alpha
+ beta
+ rho
- min_ab
+ 2;
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])
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;
332 int shift_y
= 16 - s
->sprite_shift
[0];
333 int shift_c
= 16 - s
->sprite_shift
[1];
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;
341 s
->real_sprite_warping_points
= s
->num_sprite_warping_points
;
346 * decodes the next video packet.
347 * @return <0 if something went wrong
349 int mpeg4_decode_video_packet_header(MpegEncContext
*s
)
351 int mb_num_bits
= av_log2(s
->mb_num
- 1) + 1;
352 int header_extension
=0, mb_num
, len
;
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;
357 for(len
=0; len
<32; len
++){
358 if(get_bits1(&s
->gb
)) break;
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");
366 if(s
->shape
!= RECT_SHAPE
){
367 header_extension
= get_bits1(&s
->gb
);
368 //FIXME more stuff here
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
);
376 if(s
->pict_type
== AV_PICTURE_TYPE_B
){
377 int mb_x
= 0, mb_y
= 0;
379 while (s
->next_picture
.f
.mbskip_table
[s
->mb_index2xy
[mb_num
]]) {
380 if (!mb_x
) ff_thread_await_progress((AVFrame
*)s
->next_picture_ptr
, mb_y
++, 0);
382 if (++mb_x
== s
->mb_width
) mb_x
= 0;
384 if(mb_num
>= s
->mb_num
) return -1; // slice contains just skipped MBs which where already decoded
387 s
->mb_x
= mb_num
% s
->mb_width
;
388 s
->mb_y
= mb_num
/ s
->mb_width
;
390 if(s
->shape
!= BIN_ONLY_SHAPE
){
391 int qscale
= get_bits(&s
->gb
, s
->quant_precision
);
393 s
->chroma_qscale
=s
->qscale
= qscale
;
396 if(s
->shape
== RECT_SHAPE
){
397 header_extension
= get_bits1(&s
->gb
);
399 if(header_extension
){
402 while (get_bits1(&s
->gb
) != 0)
405 check_marker(&s
->gb
, "before time_increment in video packed header");
406 skip_bits(&s
->gb
, s
->time_increment_bits
); /* time_increment */
407 check_marker(&s
->gb
, "before vop_coding_type in video packed header");
409 skip_bits(&s
->gb
, 2); /* vop coding type */
410 //FIXME not rect stuff here
412 if(s
->shape
!= BIN_ONLY_SHAPE
){
413 skip_bits(&s
->gb
, 3); /* intra dc vlc threshold */
414 //FIXME don't just ignore everything
415 if(s
->pict_type
== AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
){
416 mpeg4_decode_sprite_trajectory(s
, &s
->gb
);
417 av_log(s
->avctx
, AV_LOG_ERROR
, "untested\n");
420 //FIXME reduced res stuff here
422 if (s
->pict_type
!= AV_PICTURE_TYPE_I
) {
423 int f_code
= get_bits(&s
->gb
, 3); /* fcode_for */
425 av_log(s
->avctx
, AV_LOG_ERROR
, "Error, video packet header damaged (f_code=0)\n");
428 if (s
->pict_type
== AV_PICTURE_TYPE_B
) {
429 int b_code
= get_bits(&s
->gb
, 3);
431 av_log(s
->avctx
, AV_LOG_ERROR
, "Error, video packet header damaged (b_code=0)\n");
436 //FIXME new-pred stuff
442 * gets the average motion vector for a GMC MB.
443 * @param n either 0 for the x component or 1 for y
444 * @return the average MV for a GMC MB
446 static inline int get_amv(MpegEncContext
*s
, int n
){
447 int x
, y
, mb_v
, sum
, dx
, dy
, shift
;
448 int len
= 1 << (s
->f_code
+ 4);
449 const int a
= s
->sprite_warping_accuracy
;
451 if(s
->workaround_bugs
& FF_BUG_AMV
)
452 len
>>= s
->quarter_sample
;
454 if(s
->real_sprite_warping_points
==1){
455 if(s
->divx_version
==500 && s
->divx_build
==413)
456 sum
= s
->sprite_offset
[0][n
] / (1<<(a
- s
->quarter_sample
));
458 sum
= RSHIFT(s
->sprite_offset
[0][n
]<<s
->quarter_sample
, a
);
460 dx
= s
->sprite_delta
[n
][0];
461 dy
= s
->sprite_delta
[n
][1];
462 shift
= s
->sprite_shift
[0];
463 if(n
) dy
-= 1<<(shift
+ a
+ 1);
464 else dx
-= 1<<(shift
+ a
+ 1);
465 mb_v
= s
->sprite_offset
[0][n
] + dx
*s
->mb_x
*16 + dy
*s
->mb_y
*16;
478 sum
= RSHIFT(sum
, a
+8-s
->quarter_sample
);
481 if (sum
< -len
) sum
= -len
;
482 else if (sum
>= len
) sum
= len
-1;
488 * decodes the dc value.
489 * @param n block index (0-3 are luma, 4-5 are chroma)
490 * @param dir_ptr the prediction direction will be stored here
491 * @return the quantized dc
493 static inline int mpeg4_decode_dc(MpegEncContext
* s
, int n
, int *dir_ptr
)
498 code
= get_vlc2(&s
->gb
, dc_lum
.table
, DC_VLC_BITS
, 1);
500 code
= get_vlc2(&s
->gb
, dc_chrom
.table
, DC_VLC_BITS
, 1);
501 if (code
< 0 || code
> 9 /* && s->nbit<9 */){
502 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal dc vlc\n");
510 level
= 2*get_bits1(&s
->gb
)-1;
512 if(get_bits1(&s
->gb
))
513 level
= get_bits(&s
->gb
, code
-1) + (1<<(code
-1));
515 level
= -get_bits(&s
->gb
, code
-1) - (1<<(code
-1));
518 level
= get_xbits(&s
->gb
, code
);
522 if(get_bits1(&s
->gb
)==0){ /* marker */
523 if(s
->error_recognition
>=2){
524 av_log(s
->avctx
, AV_LOG_ERROR
, "dc marker bit missing\n");
531 return ff_mpeg4_pred_dc(s
, n
, level
, dir_ptr
, 0);
535 * decodes first partition.
536 * @return number of MBs decoded or <0 if an error occurred
538 static int mpeg4_decode_partition_a(MpegEncContext
*s
){
540 static const int8_t quant_tab
[4] = { -1, -2, 1, 2 };
542 /* decode first partition */
544 s
->first_slice_line
=1;
545 for(; s
->mb_y
<s
->mb_height
; s
->mb_y
++){
546 ff_init_block_index(s
);
547 for(; s
->mb_x
<s
->mb_width
; s
->mb_x
++){
548 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
553 ff_update_block_index(s
);
554 if(s
->mb_x
== s
->resync_mb_x
&& s
->mb_y
== s
->resync_mb_y
+1)
555 s
->first_slice_line
=0;
557 if(s
->pict_type
==AV_PICTURE_TYPE_I
){
561 if(show_bits_long(&s
->gb
, 19)==DC_MARKER
){
565 cbpc
= get_vlc2(&s
->gb
, ff_h263_intra_MCBPC_vlc
.table
, INTRA_MCBPC_VLC_BITS
, 2);
567 av_log(s
->avctx
, AV_LOG_ERROR
, "cbpc corrupted at %d %d\n", s
->mb_x
, s
->mb_y
);
572 s
->cbp_table
[xy
]= cbpc
& 3;
573 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_INTRA
;
577 ff_set_qscale(s
, s
->qscale
+ quant_tab
[get_bits(&s
->gb
, 2)]);
579 s
->current_picture
.f
.qscale_table
[xy
]= s
->qscale
;
581 s
->mbintra_table
[xy
]= 1;
584 int dc
= mpeg4_decode_dc(s
, i
, &dc_pred_dir
);
586 av_log(s
->avctx
, AV_LOG_ERROR
, "DC corrupted at %d %d\n", s
->mb_x
, s
->mb_y
);
590 if(dc_pred_dir
) dir
|=1;
592 s
->pred_dir_table
[xy
]= dir
;
593 }else{ /* P/S_TYPE */
594 int mx
, my
, pred_x
, pred_y
, bits
;
595 int16_t * const mot_val
= s
->current_picture
.f
.motion_val
[0][s
->block_index
[0]];
596 const int stride
= s
->b8_stride
*2;
599 bits
= show_bits(&s
->gb
, 17);
600 if(bits
==MOTION_MARKER
){
606 if(s
->pict_type
==AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
){
607 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_SKIP
| MB_TYPE_16x16
| MB_TYPE_GMC
| MB_TYPE_L0
;
611 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_SKIP
| MB_TYPE_16x16
| MB_TYPE_L0
;
614 mot_val
[0 ]= mot_val
[2 ]=
615 mot_val
[0+stride
]= mot_val
[2+stride
]= mx
;
616 mot_val
[1 ]= mot_val
[3 ]=
617 mot_val
[1+stride
]= mot_val
[3+stride
]= my
;
619 if(s
->mbintra_table
[xy
])
620 ff_clean_intra_table_entries(s
);
624 cbpc
= get_vlc2(&s
->gb
, ff_h263_inter_MCBPC_vlc
.table
, INTER_MCBPC_VLC_BITS
, 2);
626 av_log(s
->avctx
, AV_LOG_ERROR
, "cbpc corrupted at %d %d\n", s
->mb_x
, s
->mb_y
);
632 s
->cbp_table
[xy
]= cbpc
&(8+3); //8 is dquant
634 s
->mb_intra
= ((cbpc
& 4) != 0);
637 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_INTRA
;
638 s
->mbintra_table
[xy
]= 1;
639 mot_val
[0 ]= mot_val
[2 ]=
640 mot_val
[0+stride
]= mot_val
[2+stride
]= 0;
641 mot_val
[1 ]= mot_val
[3 ]=
642 mot_val
[1+stride
]= mot_val
[3+stride
]= 0;
644 if(s
->mbintra_table
[xy
])
645 ff_clean_intra_table_entries(s
);
647 if(s
->pict_type
==AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
&& (cbpc
& 16) == 0)
648 s
->mcsel
= get_bits1(&s
->gb
);
651 if ((cbpc
& 16) == 0) {
652 /* 16x16 motion prediction */
654 h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
656 mx
= h263_decode_motion(s
, pred_x
, s
->f_code
);
660 my
= h263_decode_motion(s
, pred_y
, s
->f_code
);
663 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_16x16
| MB_TYPE_L0
;
667 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_16x16
| MB_TYPE_GMC
| MB_TYPE_L0
;
670 mot_val
[0 ]= mot_val
[2 ] =
671 mot_val
[0+stride
]= mot_val
[2+stride
]= mx
;
672 mot_val
[1 ]= mot_val
[3 ]=
673 mot_val
[1+stride
]= mot_val
[3+stride
]= my
;
676 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_8x8
| MB_TYPE_L0
;
678 int16_t *mot_val
= h263_pred_motion(s
, i
, 0, &pred_x
, &pred_y
);
679 mx
= h263_decode_motion(s
, pred_x
, s
->f_code
);
683 my
= h263_decode_motion(s
, pred_y
, s
->f_code
);
700 * decode second partition.
701 * @return <0 if an error occurred
703 static int mpeg4_decode_partition_b(MpegEncContext
*s
, int mb_count
){
705 static const int8_t quant_tab
[4] = { -1, -2, 1, 2 };
707 s
->mb_x
= s
->resync_mb_x
;
708 s
->first_slice_line
=1;
709 for(s
->mb_y
= s
->resync_mb_y
; mb_num
< mb_count
; s
->mb_y
++){
710 ff_init_block_index(s
);
711 for(; mb_num
< mb_count
&& s
->mb_x
<s
->mb_width
; s
->mb_x
++){
712 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
715 ff_update_block_index(s
);
716 if(s
->mb_x
== s
->resync_mb_x
&& s
->mb_y
== s
->resync_mb_y
+1)
717 s
->first_slice_line
=0;
719 if(s
->pict_type
==AV_PICTURE_TYPE_I
){
720 int ac_pred
= get_bits1(&s
->gb
);
721 int cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
723 av_log(s
->avctx
, AV_LOG_ERROR
, "cbpy corrupted at %d %d\n", s
->mb_x
, s
->mb_y
);
727 s
->cbp_table
[xy
]|= cbpy
<<2;
728 s
->current_picture
.f
.mb_type
[xy
] |= ac_pred
*MB_TYPE_ACPRED
;
729 }else{ /* P || S_TYPE */
730 if (IS_INTRA(s
->current_picture
.f
.mb_type
[xy
])) {
732 int ac_pred
= get_bits1(&s
->gb
);
733 int cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
736 av_log(s
->avctx
, AV_LOG_ERROR
, "I cbpy corrupted at %d %d\n", s
->mb_x
, s
->mb_y
);
740 if(s
->cbp_table
[xy
] & 8) {
741 ff_set_qscale(s
, s
->qscale
+ quant_tab
[get_bits(&s
->gb
, 2)]);
743 s
->current_picture
.f
.qscale_table
[xy
] = s
->qscale
;
747 int dc
= mpeg4_decode_dc(s
, i
, &dc_pred_dir
);
749 av_log(s
->avctx
, AV_LOG_ERROR
, "DC corrupted at %d %d\n", s
->mb_x
, s
->mb_y
);
753 if(dc_pred_dir
) dir
|=1;
755 s
->cbp_table
[xy
]&= 3; //remove dquant
756 s
->cbp_table
[xy
]|= cbpy
<<2;
757 s
->current_picture
.f
.mb_type
[xy
] |= ac_pred
*MB_TYPE_ACPRED
;
758 s
->pred_dir_table
[xy
]= dir
;
759 } else if (IS_SKIP(s
->current_picture
.f
.mb_type
[xy
])) {
760 s
->current_picture
.f
.qscale_table
[xy
] = s
->qscale
;
763 int cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
766 av_log(s
->avctx
, AV_LOG_ERROR
, "P cbpy corrupted at %d %d\n", s
->mb_x
, s
->mb_y
);
770 if(s
->cbp_table
[xy
] & 8) {
771 ff_set_qscale(s
, s
->qscale
+ quant_tab
[get_bits(&s
->gb
, 2)]);
773 s
->current_picture
.f
.qscale_table
[xy
] = s
->qscale
;
775 s
->cbp_table
[xy
]&= 3; //remove dquant
776 s
->cbp_table
[xy
]|= (cbpy
^0xf)<<2;
780 if(mb_num
>= mb_count
) return 0;
787 * decodes the first & second partition
788 * @return <0 if error (and sets error type in the error_status_table)
790 int ff_mpeg4_decode_partitions(MpegEncContext
*s
)
793 const int part_a_error
= s
->pict_type
==AV_PICTURE_TYPE_I ?
(DC_ERROR
|MV_ERROR
) : MV_ERROR
;
794 const int part_a_end
= s
->pict_type
==AV_PICTURE_TYPE_I ?
(DC_END
|MV_END
) : MV_END
;
796 mb_num
= mpeg4_decode_partition_a(s
);
798 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
, s
->mb_y
, part_a_error
);
802 if(s
->resync_mb_x
+ s
->resync_mb_y
*s
->mb_width
+ mb_num
> s
->mb_num
){
803 av_log(s
->avctx
, AV_LOG_ERROR
, "slice below monitor ...\n");
804 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
, s
->mb_y
, part_a_error
);
808 s
->mb_num_left
= mb_num
;
810 if(s
->pict_type
==AV_PICTURE_TYPE_I
){
811 while(show_bits(&s
->gb
, 9) == 1)
812 skip_bits(&s
->gb
, 9);
813 if(get_bits_long(&s
->gb
, 19)!=DC_MARKER
){
814 av_log(s
->avctx
, AV_LOG_ERROR
, "marker missing after first I partition at %d %d\n", s
->mb_x
, s
->mb_y
);
818 while(show_bits(&s
->gb
, 10) == 1)
819 skip_bits(&s
->gb
, 10);
820 if(get_bits(&s
->gb
, 17)!=MOTION_MARKER
){
821 av_log(s
->avctx
, AV_LOG_ERROR
, "marker missing after first P partition at %d %d\n", s
->mb_x
, s
->mb_y
);
825 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, part_a_end
);
827 if( mpeg4_decode_partition_b(s
, mb_num
) < 0){
828 if(s
->pict_type
==AV_PICTURE_TYPE_P
)
829 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
, s
->mb_y
, DC_ERROR
);
832 if(s
->pict_type
==AV_PICTURE_TYPE_P
)
833 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, DC_END
);
841 * @return <0 if an error occurred
843 static inline int mpeg4_decode_block(MpegEncContext
* s
, DCTELEM
* block
,
844 int n
, int coded
, int intra
, int rvlc
)
846 int level
, i
, last
, run
;
849 RL_VLC_ELEM
* rl_vlc
;
850 const uint8_t * scan_table
;
853 //Note intra & rvlc should be optimized away if this is inlined
856 if(s
->use_intra_dc_vlc
){
858 if(s
->partitioned_frame
){
859 level
= s
->dc_val
[0][ s
->block_index
[n
] ];
860 if(n
<4) level
= FASTDIV((level
+ (s
->y_dc_scale
>>1)), s
->y_dc_scale
);
861 else level
= FASTDIV((level
+ (s
->c_dc_scale
>>1)), s
->c_dc_scale
);
862 dc_pred_dir
= (s
->pred_dir_table
[s
->mb_x
+ s
->mb_y
*s
->mb_stride
]<<n
)&32;
864 level
= mpeg4_decode_dc(s
, n
, &dc_pred_dir
);
872 ff_mpeg4_pred_dc(s
, n
, 0, &dc_pred_dir
, 0);
879 rl_vlc
= rvlc_rl_intra
.rl_vlc
[0];
881 rl
= &ff_mpeg4_rl_intra
;
882 rl_vlc
= ff_mpeg4_rl_intra
.rl_vlc
[0];
885 if (dc_pred_dir
== 0)
886 scan_table
= s
->intra_v_scantable
.permutated
; /* left */
888 scan_table
= s
->intra_h_scantable
.permutated
; /* top */
890 scan_table
= s
->intra_scantable
.permutated
;
897 s
->block_last_index
[n
] = i
;
900 if(rvlc
) rl
= &rvlc_rl_inter
;
901 else rl
= &ff_h263_rl_inter
;
903 scan_table
= s
->intra_scantable
.permutated
;
909 rl_vlc
= rvlc_rl_inter
.rl_vlc
[0];
911 rl_vlc
= ff_h263_rl_inter
.rl_vlc
[0];
914 qmul
= s
->qscale
<< 1;
915 qadd
= (s
->qscale
- 1) | 1;
917 rl_vlc
= rvlc_rl_inter
.rl_vlc
[s
->qscale
];
919 rl_vlc
= ff_h263_rl_inter
.rl_vlc
[s
->qscale
];
924 OPEN_READER(re
, &s
->gb
);
926 UPDATE_CACHE(re
, &s
->gb
);
927 GET_RL_VLC(level
, run
, re
, &s
->gb
, rl_vlc
, TEX_VLC_BITS
, 2, 0);
931 if(SHOW_UBITS(re
, &s
->gb
, 1)==0){
932 av_log(s
->avctx
, AV_LOG_ERROR
, "1. marker bit missing in rvlc esc\n");
934 }; SKIP_CACHE(re
, &s
->gb
, 1);
936 last
= SHOW_UBITS(re
, &s
->gb
, 1); SKIP_CACHE(re
, &s
->gb
, 1);
937 run
= SHOW_UBITS(re
, &s
->gb
, 6); LAST_SKIP_CACHE(re
, &s
->gb
, 6);
938 SKIP_COUNTER(re
, &s
->gb
, 1+1+6);
939 UPDATE_CACHE(re
, &s
->gb
);
941 if(SHOW_UBITS(re
, &s
->gb
, 1)==0){
942 av_log(s
->avctx
, AV_LOG_ERROR
, "2. marker bit missing in rvlc esc\n");
944 }; SKIP_CACHE(re
, &s
->gb
, 1);
946 level
= SHOW_UBITS(re
, &s
->gb
, 11); SKIP_CACHE(re
, &s
->gb
, 11);
948 if(SHOW_UBITS(re
, &s
->gb
, 5)!=0x10){
949 av_log(s
->avctx
, AV_LOG_ERROR
, "reverse esc missing\n");
951 }; SKIP_CACHE(re
, &s
->gb
, 5);
953 level
= level
* qmul
+ qadd
;
954 level
= (level
^ SHOW_SBITS(re
, &s
->gb
, 1)) - SHOW_SBITS(re
, &s
->gb
, 1); LAST_SKIP_CACHE(re
, &s
->gb
, 1);
955 SKIP_COUNTER(re
, &s
->gb
, 1+11+5+1);
961 cache
= GET_CACHE(re
, &s
->gb
);
966 if (cache
&0x80000000) {
967 if (cache
&0x40000000) {
969 SKIP_CACHE(re
, &s
->gb
, 2);
970 last
= SHOW_UBITS(re
, &s
->gb
, 1); SKIP_CACHE(re
, &s
->gb
, 1);
971 run
= SHOW_UBITS(re
, &s
->gb
, 6); LAST_SKIP_CACHE(re
, &s
->gb
, 6);
972 SKIP_COUNTER(re
, &s
->gb
, 2+1+6);
973 UPDATE_CACHE(re
, &s
->gb
);
976 level
= SHOW_SBITS(re
, &s
->gb
, 12); LAST_SKIP_BITS(re
, &s
->gb
, 12);
978 if(SHOW_UBITS(re
, &s
->gb
, 1)==0){
979 av_log(s
->avctx
, AV_LOG_ERROR
, "1. marker bit missing in 3. esc\n");
981 }; SKIP_CACHE(re
, &s
->gb
, 1);
983 level
= SHOW_SBITS(re
, &s
->gb
, 12); SKIP_CACHE(re
, &s
->gb
, 12);
985 if(SHOW_UBITS(re
, &s
->gb
, 1)==0){
986 av_log(s
->avctx
, AV_LOG_ERROR
, "2. marker bit missing in 3. esc\n");
988 }; LAST_SKIP_CACHE(re
, &s
->gb
, 1);
990 SKIP_COUNTER(re
, &s
->gb
, 1+12+1);
994 if(s
->error_recognition
>= FF_ER_COMPLIANT
){
995 const int abs_level
= FFABS(level
);
996 if(abs_level
<=MAX_LEVEL
&& run
<=MAX_RUN
){
997 const int run1
= run
- rl
->max_run
[last
][abs_level
] - 1;
998 if(abs_level
<= rl
->max_level
[last
][run
]){
999 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal 3. esc, vlc encoding possible\n");
1002 if(s
->error_recognition
> FF_ER_COMPLIANT
){
1003 if(abs_level
<= rl
->max_level
[last
][run
]*2){
1004 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal 3. esc, esc 1 encoding possible\n");
1007 if(run1
>= 0 && abs_level
<= rl
->max_level
[last
][run1
]){
1008 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal 3. esc, esc 2 encoding possible\n");
1015 if (level
>0) level
= level
* qmul
+ qadd
;
1016 else level
= level
* qmul
- qadd
;
1018 if((unsigned)(level
+ 2048) > 4095){
1019 if(s
->error_recognition
> FF_ER_COMPLIANT
){
1020 if(level
> 2560 || level
<-2560){
1021 av_log(s
->avctx
, AV_LOG_ERROR
, "|level| overflow in 3. esc, qp=%d\n", s
->qscale
);
1025 level
= level
<0 ?
-2048 : 2047;
1032 SKIP_BITS(re
, &s
->gb
, 2);
1033 GET_RL_VLC(level
, run
, re
, &s
->gb
, rl_vlc
, TEX_VLC_BITS
, 2, 1);
1034 i
+= run
+ rl
->max_run
[run
>>7][level
/qmul
] +1; //FIXME opt indexing
1035 level
= (level
^ SHOW_SBITS(re
, &s
->gb
, 1)) - SHOW_SBITS(re
, &s
->gb
, 1);
1036 LAST_SKIP_BITS(re
, &s
->gb
, 1);
1040 SKIP_BITS(re
, &s
->gb
, 1);
1041 GET_RL_VLC(level
, run
, re
, &s
->gb
, rl_vlc
, TEX_VLC_BITS
, 2, 1);
1043 level
= level
+ rl
->max_level
[run
>>7][(run
-1)&63] * qmul
;//FIXME opt indexing
1044 level
= (level
^ SHOW_SBITS(re
, &s
->gb
, 1)) - SHOW_SBITS(re
, &s
->gb
, 1);
1045 LAST_SKIP_BITS(re
, &s
->gb
, 1);
1050 level
= (level
^ SHOW_SBITS(re
, &s
->gb
, 1)) - SHOW_SBITS(re
, &s
->gb
, 1);
1051 LAST_SKIP_BITS(re
, &s
->gb
, 1);
1056 av_log(s
->avctx
, AV_LOG_ERROR
, "ac-tex damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
1060 block
[scan_table
[i
]] = level
;
1064 block
[scan_table
[i
]] = level
;
1066 CLOSE_READER(re
, &s
->gb
);
1070 if(!s
->use_intra_dc_vlc
){
1071 block
[0] = ff_mpeg4_pred_dc(s
, n
, block
[0], &dc_pred_dir
, 0);
1073 i
-= i
>>31; //if(i == -1) i=0;
1076 mpeg4_pred_ac(s
, block
, n
, dc_pred_dir
);
1078 i
= 63; /* XXX: not optimal */
1081 s
->block_last_index
[n
] = i
;
1086 * decode partition C of one MB.
1087 * @return <0 if an error occurred
1089 static int mpeg4_decode_partitioned_mb(MpegEncContext
*s
, DCTELEM block
[6][64])
1092 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
1094 mb_type
= s
->current_picture
.f
.mb_type
[xy
];
1095 cbp
= s
->cbp_table
[xy
];
1097 s
->use_intra_dc_vlc
= s
->qscale
< s
->intra_dc_threshold
;
1099 if (s
->current_picture
.f
.qscale_table
[xy
] != s
->qscale
) {
1100 ff_set_qscale(s
, s
->current_picture
.f
.qscale_table
[xy
]);
1103 if (s
->pict_type
== AV_PICTURE_TYPE_P
|| s
->pict_type
==AV_PICTURE_TYPE_S
) {
1106 s
->mv
[0][i
][0] = s
->current_picture
.f
.motion_val
[0][s
->block_index
[i
]][0];
1107 s
->mv
[0][i
][1] = s
->current_picture
.f
.motion_val
[0][s
->block_index
[i
]][1];
1109 s
->mb_intra
= IS_INTRA(mb_type
);
1111 if (IS_SKIP(mb_type
)) {
1114 s
->block_last_index
[i
] = -1;
1115 s
->mv_dir
= MV_DIR_FORWARD
;
1116 s
->mv_type
= MV_TYPE_16X16
;
1117 if(s
->pict_type
==AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
){
1124 }else if(s
->mb_intra
){
1125 s
->ac_pred
= IS_ACPRED(s
->current_picture
.f
.mb_type
[xy
]);
1126 }else if(!s
->mb_intra
){
1127 // s->mcsel= 0; //FIXME do we need to init that
1129 s
->mv_dir
= MV_DIR_FORWARD
;
1130 if (IS_8X8(mb_type
)) {
1131 s
->mv_type
= MV_TYPE_8X8
;
1133 s
->mv_type
= MV_TYPE_16X16
;
1136 } else { /* I-Frame */
1138 s
->ac_pred
= IS_ACPRED(s
->current_picture
.f
.mb_type
[xy
]);
1141 if (!IS_SKIP(mb_type
)) {
1143 s
->dsp
.clear_blocks(s
->block
[0]);
1144 /* decode each block */
1145 for (i
= 0; i
< 6; i
++) {
1146 if(mpeg4_decode_block(s
, block
[i
], i
, cbp
&32, s
->mb_intra
, s
->rvlc
) < 0){
1147 av_log(s
->avctx
, AV_LOG_ERROR
, "texture corrupted at %d %d %d\n", s
->mb_x
, s
->mb_y
, s
->mb_intra
);
1154 /* per-MB end of slice check */
1156 if(--s
->mb_num_left
<= 0){
1157 if(mpeg4_is_resync(s
))
1162 if(mpeg4_is_resync(s
)){
1163 const int delta
= s
->mb_x
+ 1 == s
->mb_width ?
2 : 1;
1164 if(s
->cbp_table
[xy
+delta
])
1171 static int mpeg4_decode_mb(MpegEncContext
*s
,
1172 DCTELEM block
[6][64])
1174 int cbpc
, cbpy
, i
, cbp
, pred_x
, pred_y
, mx
, my
, dquant
;
1176 static int8_t quant_tab
[4] = { -1, -2, 1, 2 };
1177 const int xy
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
1179 assert(s
->h263_pred
);
1181 if (s
->pict_type
== AV_PICTURE_TYPE_P
|| s
->pict_type
==AV_PICTURE_TYPE_S
) {
1183 if (get_bits1(&s
->gb
)) {
1187 s
->block_last_index
[i
] = -1;
1188 s
->mv_dir
= MV_DIR_FORWARD
;
1189 s
->mv_type
= MV_TYPE_16X16
;
1190 if(s
->pict_type
==AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
){
1191 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_SKIP
| MB_TYPE_GMC
| MB_TYPE_16x16
| MB_TYPE_L0
;
1193 s
->mv
[0][0][0]= get_amv(s
, 0);
1194 s
->mv
[0][0][1]= get_amv(s
, 1);
1198 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_SKIP
| MB_TYPE_16x16
| MB_TYPE_L0
;
1206 cbpc
= get_vlc2(&s
->gb
, ff_h263_inter_MCBPC_vlc
.table
, INTER_MCBPC_VLC_BITS
, 2);
1208 av_log(s
->avctx
, AV_LOG_ERROR
, "cbpc damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
1213 s
->dsp
.clear_blocks(s
->block
[0]);
1215 s
->mb_intra
= ((cbpc
& 4) != 0);
1216 if (s
->mb_intra
) goto intra
;
1218 if(s
->pict_type
==AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
&& (cbpc
& 16) == 0)
1219 s
->mcsel
= get_bits1(&s
->gb
);
1221 cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1) ^ 0x0F;
1223 cbp
= (cbpc
& 3) | (cbpy
<< 2);
1225 ff_set_qscale(s
, s
->qscale
+ quant_tab
[get_bits(&s
->gb
, 2)]);
1227 if((!s
->progressive_sequence
) && (cbp
|| (s
->workaround_bugs
&FF_BUG_XVID_ILACE
)))
1228 s
->interlaced_dct
= get_bits1(&s
->gb
);
1230 s
->mv_dir
= MV_DIR_FORWARD
;
1231 if ((cbpc
& 16) == 0) {
1233 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_GMC
| MB_TYPE_16x16
| MB_TYPE_L0
;
1234 /* 16x16 global motion prediction */
1235 s
->mv_type
= MV_TYPE_16X16
;
1238 s
->mv
[0][0][0] = mx
;
1239 s
->mv
[0][0][1] = my
;
1240 }else if((!s
->progressive_sequence
) && get_bits1(&s
->gb
)){
1241 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_16x8
| MB_TYPE_L0
| MB_TYPE_INTERLACED
;
1242 /* 16x8 field motion prediction */
1243 s
->mv_type
= MV_TYPE_FIELD
;
1245 s
->field_select
[0][0]= get_bits1(&s
->gb
);
1246 s
->field_select
[0][1]= get_bits1(&s
->gb
);
1248 h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
1251 mx
= h263_decode_motion(s
, pred_x
, s
->f_code
);
1255 my
= h263_decode_motion(s
, pred_y
/2, s
->f_code
);
1259 s
->mv
[0][i
][0] = mx
;
1260 s
->mv
[0][i
][1] = my
;
1263 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_16x16
| MB_TYPE_L0
;
1264 /* 16x16 motion prediction */
1265 s
->mv_type
= MV_TYPE_16X16
;
1266 h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
1267 mx
= h263_decode_motion(s
, pred_x
, s
->f_code
);
1272 my
= h263_decode_motion(s
, pred_y
, s
->f_code
);
1276 s
->mv
[0][0][0] = mx
;
1277 s
->mv
[0][0][1] = my
;
1280 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_8x8
| MB_TYPE_L0
;
1281 s
->mv_type
= MV_TYPE_8X8
;
1283 mot_val
= h263_pred_motion(s
, i
, 0, &pred_x
, &pred_y
);
1284 mx
= h263_decode_motion(s
, pred_x
, s
->f_code
);
1288 my
= h263_decode_motion(s
, pred_y
, s
->f_code
);
1291 s
->mv
[0][i
][0] = mx
;
1292 s
->mv
[0][i
][1] = my
;
1297 } else if(s
->pict_type
==AV_PICTURE_TYPE_B
) {
1298 int modb1
; // first bit of modb
1299 int modb2
; // second bit of modb
1302 s
->mb_intra
= 0; //B-frames never contain intra blocks
1303 s
->mcsel
=0; // ... true gmc blocks
1307 s
->last_mv
[i
][0][0]=
1308 s
->last_mv
[i
][0][1]=
1309 s
->last_mv
[i
][1][0]=
1310 s
->last_mv
[i
][1][1]= 0;
1313 ff_thread_await_progress((AVFrame
*)s
->next_picture_ptr
, s
->mb_y
, 0);
1316 /* if we skipped it in the future P Frame than skip it now too */
1317 s
->mb_skipped
= s
->next_picture
.f
.mbskip_table
[s
->mb_y
* s
->mb_stride
+ s
->mb_x
]; // Note, skiptab=0 if last was GMC
1322 s
->block_last_index
[i
] = -1;
1324 s
->mv_dir
= MV_DIR_FORWARD
;
1325 s
->mv_type
= MV_TYPE_16X16
;
1330 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_SKIP
| MB_TYPE_16x16
| MB_TYPE_L0
;
1334 modb1
= get_bits1(&s
->gb
);
1336 mb_type
= MB_TYPE_DIRECT2
| MB_TYPE_SKIP
| MB_TYPE_L0L1
; //like MB_TYPE_B_DIRECT but no vectors coded
1339 modb2
= get_bits1(&s
->gb
);
1340 mb_type
= get_vlc2(&s
->gb
, mb_type_b_vlc
.table
, MB_TYPE_B_VLC_BITS
, 1);
1342 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal MB_type\n");
1345 mb_type
= mb_type_b_map
[ mb_type
];
1348 s
->dsp
.clear_blocks(s
->block
[0]);
1349 cbp
= get_bits(&s
->gb
, 6);
1352 if ((!IS_DIRECT(mb_type
)) && cbp
) {
1353 if(get_bits1(&s
->gb
)){
1354 ff_set_qscale(s
, s
->qscale
+ get_bits1(&s
->gb
)*4 - 2);
1358 if(!s
->progressive_sequence
){
1360 s
->interlaced_dct
= get_bits1(&s
->gb
);
1362 if(!IS_DIRECT(mb_type
) && get_bits1(&s
->gb
)){
1363 mb_type
|= MB_TYPE_16x8
| MB_TYPE_INTERLACED
;
1364 mb_type
&= ~MB_TYPE_16x16
;
1366 if(USES_LIST(mb_type
, 0)){
1367 s
->field_select
[0][0]= get_bits1(&s
->gb
);
1368 s
->field_select
[0][1]= get_bits1(&s
->gb
);
1370 if(USES_LIST(mb_type
, 1)){
1371 s
->field_select
[1][0]= get_bits1(&s
->gb
);
1372 s
->field_select
[1][1]= get_bits1(&s
->gb
);
1378 if((mb_type
& (MB_TYPE_DIRECT2
|MB_TYPE_INTERLACED
)) == 0){
1379 s
->mv_type
= MV_TYPE_16X16
;
1381 if(USES_LIST(mb_type
, 0)){
1382 s
->mv_dir
= MV_DIR_FORWARD
;
1384 mx
= h263_decode_motion(s
, s
->last_mv
[0][0][0], s
->f_code
);
1385 my
= h263_decode_motion(s
, s
->last_mv
[0][0][1], s
->f_code
);
1386 s
->last_mv
[0][1][0]= s
->last_mv
[0][0][0]= s
->mv
[0][0][0] = mx
;
1387 s
->last_mv
[0][1][1]= s
->last_mv
[0][0][1]= s
->mv
[0][0][1] = my
;
1390 if(USES_LIST(mb_type
, 1)){
1391 s
->mv_dir
|= MV_DIR_BACKWARD
;
1393 mx
= h263_decode_motion(s
, s
->last_mv
[1][0][0], s
->b_code
);
1394 my
= h263_decode_motion(s
, s
->last_mv
[1][0][1], s
->b_code
);
1395 s
->last_mv
[1][1][0]= s
->last_mv
[1][0][0]= s
->mv
[1][0][0] = mx
;
1396 s
->last_mv
[1][1][1]= s
->last_mv
[1][0][1]= s
->mv
[1][0][1] = my
;
1398 }else if(!IS_DIRECT(mb_type
)){
1399 s
->mv_type
= MV_TYPE_FIELD
;
1401 if(USES_LIST(mb_type
, 0)){
1402 s
->mv_dir
= MV_DIR_FORWARD
;
1405 mx
= h263_decode_motion(s
, s
->last_mv
[0][i
][0] , s
->f_code
);
1406 my
= h263_decode_motion(s
, s
->last_mv
[0][i
][1]/2, s
->f_code
);
1407 s
->last_mv
[0][i
][0]= s
->mv
[0][i
][0] = mx
;
1408 s
->last_mv
[0][i
][1]= (s
->mv
[0][i
][1] = my
)*2;
1412 if(USES_LIST(mb_type
, 1)){
1413 s
->mv_dir
|= MV_DIR_BACKWARD
;
1416 mx
= h263_decode_motion(s
, s
->last_mv
[1][i
][0] , s
->b_code
);
1417 my
= h263_decode_motion(s
, s
->last_mv
[1][i
][1]/2, s
->b_code
);
1418 s
->last_mv
[1][i
][0]= s
->mv
[1][i
][0] = mx
;
1419 s
->last_mv
[1][i
][1]= (s
->mv
[1][i
][1] = my
)*2;
1425 if(IS_DIRECT(mb_type
)){
1426 if(IS_SKIP(mb_type
))
1429 mx
= h263_decode_motion(s
, 0, 1);
1430 my
= h263_decode_motion(s
, 0, 1);
1433 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
| MV_DIRECT
;
1434 mb_type
|= ff_mpeg4_set_direct_mv(s
, mx
, my
);
1436 s
->current_picture
.f
.mb_type
[xy
] = mb_type
;
1437 } else { /* I-Frame */
1439 cbpc
= get_vlc2(&s
->gb
, ff_h263_intra_MCBPC_vlc
.table
, INTRA_MCBPC_VLC_BITS
, 2);
1441 av_log(s
->avctx
, AV_LOG_ERROR
, "I cbpc damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
1449 s
->ac_pred
= get_bits1(&s
->gb
);
1451 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_INTRA
| MB_TYPE_ACPRED
;
1453 s
->current_picture
.f
.mb_type
[xy
] = MB_TYPE_INTRA
;
1455 cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
1457 av_log(s
->avctx
, AV_LOG_ERROR
, "I cbpy damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
1460 cbp
= (cbpc
& 3) | (cbpy
<< 2);
1462 s
->use_intra_dc_vlc
= s
->qscale
< s
->intra_dc_threshold
;
1465 ff_set_qscale(s
, s
->qscale
+ quant_tab
[get_bits(&s
->gb
, 2)]);
1468 if(!s
->progressive_sequence
)
1469 s
->interlaced_dct
= get_bits1(&s
->gb
);
1471 s
->dsp
.clear_blocks(s
->block
[0]);
1472 /* decode each block */
1473 for (i
= 0; i
< 6; i
++) {
1474 if (mpeg4_decode_block(s
, block
[i
], i
, cbp
&32, 1, 0) < 0)
1481 /* decode each block */
1482 for (i
= 0; i
< 6; i
++) {
1483 if (mpeg4_decode_block(s
, block
[i
], i
, cbp
&32, 0, 0) < 0)
1489 /* per-MB end of slice check */
1490 if(s
->codec_id
==CODEC_ID_MPEG4
){
1491 if(mpeg4_is_resync(s
)){
1492 const int delta
= s
->mb_x
+ 1 == s
->mb_width ?
2 : 1;
1494 if (s
->pict_type
== AV_PICTURE_TYPE_B
&& s
->next_picture
.f
.mbskip_table
[xy
+ delta
]) {
1495 ff_thread_await_progress((AVFrame
*)s
->next_picture_ptr
,
1496 (s
->mb_x
+ delta
>= s
->mb_width
) ?
FFMIN(s
->mb_y
+1, s
->mb_height
-1) : s
->mb_y
, 0);
1499 if (s
->pict_type
== AV_PICTURE_TYPE_B
&& s
->next_picture
.f
.mbskip_table
[xy
+ delta
])
1509 static int mpeg4_decode_gop_header(MpegEncContext
* s
, GetBitContext
*gb
){
1510 int hours
, minutes
, seconds
;
1511 unsigned time_code
= show_bits(gb
, 18);
1513 if (time_code
& 0x40) { /* marker_bit */
1514 hours
= time_code
>> 13;
1515 minutes
= time_code
>> 7 & 0x3f;
1516 seconds
= time_code
& 0x3f;
1517 s
->time_base
= seconds
+ 60*(minutes
+ 60*hours
);
1518 skip_bits(gb
, 20); /* time_code, closed_gov, broken_link */
1520 av_log(s
->avctx
, AV_LOG_WARNING
, "GOP header missing marker_bit\n");
1526 static int mpeg4_decode_profile_level(MpegEncContext
* s
, GetBitContext
*gb
){
1527 int profile_and_level_indication
;
1529 profile_and_level_indication
= get_bits(gb
, 8);
1531 s
->avctx
->profile
= (profile_and_level_indication
& 0xf0) >> 4;
1532 s
->avctx
->level
= (profile_and_level_indication
& 0x0f);
1534 // for Simple profile, level 0
1535 if (s
->avctx
->profile
== 0 && s
->avctx
->level
== 8) {
1536 s
->avctx
->level
= 0;
1542 static int decode_vol_header(MpegEncContext
*s
, GetBitContext
*gb
){
1543 int width
, height
, vo_ver_id
;
1546 skip_bits(gb
, 1); /* random access */
1547 s
->vo_type
= get_bits(gb
, 8);
1548 if (get_bits1(gb
) != 0) { /* is_ol_id */
1549 vo_ver_id
= get_bits(gb
, 4); /* vo_ver_id */
1550 skip_bits(gb
, 3); /* vo_priority */
1554 s
->aspect_ratio_info
= get_bits(gb
, 4);
1555 if(s
->aspect_ratio_info
== FF_ASPECT_EXTENDED
){
1556 s
->avctx
->sample_aspect_ratio
.num
= get_bits(gb
, 8); // par_width
1557 s
->avctx
->sample_aspect_ratio
.den
= get_bits(gb
, 8); // par_height
1559 s
->avctx
->sample_aspect_ratio
= ff_h263_pixel_aspect
[s
->aspect_ratio_info
];
1562 if ((s
->vol_control_parameters
=get_bits1(gb
))) { /* vol control parameter */
1563 int chroma_format
= get_bits(gb
, 2);
1564 if(chroma_format
!=CHROMA_420
){
1565 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal chroma format\n");
1567 s
->low_delay
= get_bits1(gb
);
1568 if(get_bits1(gb
)){ /* vbv parameters */
1569 get_bits(gb
, 15); /* first_half_bitrate */
1570 skip_bits1(gb
); /* marker */
1571 get_bits(gb
, 15); /* latter_half_bitrate */
1572 skip_bits1(gb
); /* marker */
1573 get_bits(gb
, 15); /* first_half_vbv_buffer_size */
1574 skip_bits1(gb
); /* marker */
1575 get_bits(gb
, 3); /* latter_half_vbv_buffer_size */
1576 get_bits(gb
, 11); /* first_half_vbv_occupancy */
1577 skip_bits1(gb
); /* marker */
1578 get_bits(gb
, 15); /* latter_half_vbv_occupancy */
1579 skip_bits1(gb
); /* marker */
1582 // set low delay flag only once the smartest? low delay detection won't be overriden
1583 if(s
->picture_number
==0)
1587 s
->shape
= get_bits(gb
, 2); /* vol shape */
1588 if(s
->shape
!= RECT_SHAPE
) av_log(s
->avctx
, AV_LOG_ERROR
, "only rectangular vol supported\n");
1589 if(s
->shape
== GRAY_SHAPE
&& vo_ver_id
!= 1){
1590 av_log(s
->avctx
, AV_LOG_ERROR
, "Gray shape not supported\n");
1591 skip_bits(gb
, 4); //video_object_layer_shape_extension
1594 check_marker(gb
, "before time_increment_resolution");
1596 s
->avctx
->time_base
.den
= get_bits(gb
, 16);
1597 if(!s
->avctx
->time_base
.den
){
1598 av_log(s
->avctx
, AV_LOG_ERROR
, "time_base.den==0\n");
1599 s
->avctx
->time_base
.num
= 0;
1603 s
->time_increment_bits
= av_log2(s
->avctx
->time_base
.den
- 1) + 1;
1604 if (s
->time_increment_bits
< 1)
1605 s
->time_increment_bits
= 1;
1607 check_marker(gb
, "before fixed_vop_rate");
1609 if (get_bits1(gb
) != 0) { /* fixed_vop_rate */
1610 s
->avctx
->time_base
.num
= get_bits(gb
, s
->time_increment_bits
);
1612 s
->avctx
->time_base
.num
= 1;
1616 if (s
->shape
!= BIN_ONLY_SHAPE
) {
1617 if (s
->shape
== RECT_SHAPE
) {
1618 skip_bits1(gb
); /* marker */
1619 width
= get_bits(gb
, 13);
1620 skip_bits1(gb
); /* marker */
1621 height
= get_bits(gb
, 13);
1622 skip_bits1(gb
); /* marker */
1623 if(width
&& height
&& !(s
->width
&& s
->codec_tag
== AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */
1629 s
->progressive_sequence
=
1630 s
->progressive_frame
= get_bits1(gb
)^1;
1631 s
->interlaced_dct
=0;
1632 if(!get_bits1(gb
) && (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
))
1633 av_log(s
->avctx
, AV_LOG_INFO
, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
1634 if (vo_ver_id
== 1) {
1635 s
->vol_sprite_usage
= get_bits1(gb
); /* vol_sprite_usage */
1637 s
->vol_sprite_usage
= get_bits(gb
, 2); /* vol_sprite_usage */
1639 if(s
->vol_sprite_usage
==STATIC_SPRITE
) av_log(s
->avctx
, AV_LOG_ERROR
, "Static Sprites not supported\n");
1640 if(s
->vol_sprite_usage
==STATIC_SPRITE
|| s
->vol_sprite_usage
==GMC_SPRITE
){
1641 if(s
->vol_sprite_usage
==STATIC_SPRITE
){
1642 s
->sprite_width
= get_bits(gb
, 13);
1643 skip_bits1(gb
); /* marker */
1644 s
->sprite_height
= get_bits(gb
, 13);
1645 skip_bits1(gb
); /* marker */
1646 s
->sprite_left
= get_bits(gb
, 13);
1647 skip_bits1(gb
); /* marker */
1648 s
->sprite_top
= get_bits(gb
, 13);
1649 skip_bits1(gb
); /* marker */
1651 s
->num_sprite_warping_points
= get_bits(gb
, 6);
1652 if(s
->num_sprite_warping_points
> 3){
1653 av_log(s
->avctx
, AV_LOG_ERROR
, "%d sprite_warping_points\n", s
->num_sprite_warping_points
);
1654 s
->num_sprite_warping_points
= 0;
1657 s
->sprite_warping_accuracy
= get_bits(gb
, 2);
1658 s
->sprite_brightness_change
= get_bits1(gb
);
1659 if(s
->vol_sprite_usage
==STATIC_SPRITE
)
1660 s
->low_latency_sprite
= get_bits1(gb
);
1662 // FIXME sadct disable bit if verid!=1 && shape not rect
1664 if (get_bits1(gb
) == 1) { /* not_8_bit */
1665 s
->quant_precision
= get_bits(gb
, 4); /* quant_precision */
1666 if(get_bits(gb
, 4)!=8) av_log(s
->avctx
, AV_LOG_ERROR
, "N-bit not supported\n"); /* bits_per_pixel */
1667 if(s
->quant_precision
!=5) av_log(s
->avctx
, AV_LOG_ERROR
, "quant precision %d\n", s
->quant_precision
);
1669 s
->quant_precision
= 5;
1672 // FIXME a bunch of grayscale shape things
1674 if((s
->mpeg_quant
=get_bits1(gb
))){ /* vol_quant_type */
1677 /* load default matrixes */
1678 for(i
=0; i
<64; i
++){
1679 int j
= s
->dsp
.idct_permutation
[i
];
1680 v
= ff_mpeg4_default_intra_matrix
[i
];
1681 s
->intra_matrix
[j
]= v
;
1682 s
->chroma_intra_matrix
[j
]= v
;
1684 v
= ff_mpeg4_default_non_intra_matrix
[i
];
1685 s
->inter_matrix
[j
]= v
;
1686 s
->chroma_inter_matrix
[j
]= v
;
1689 /* load custom intra matrix */
1692 for(i
=0; i
<64; i
++){
1698 j
= s
->dsp
.idct_permutation
[ ff_zigzag_direct
[i
] ];
1699 s
->intra_matrix
[j
]= v
;
1700 s
->chroma_intra_matrix
[j
]= v
;
1703 /* replicate last value */
1705 int j
= s
->dsp
.idct_permutation
[ ff_zigzag_direct
[i
] ];
1706 s
->intra_matrix
[j
]= last
;
1707 s
->chroma_intra_matrix
[j
]= last
;
1711 /* load custom non intra matrix */
1714 for(i
=0; i
<64; i
++){
1720 j
= s
->dsp
.idct_permutation
[ ff_zigzag_direct
[i
] ];
1721 s
->inter_matrix
[j
]= v
;
1722 s
->chroma_inter_matrix
[j
]= v
;
1725 /* replicate last value */
1727 int j
= s
->dsp
.idct_permutation
[ ff_zigzag_direct
[i
] ];
1728 s
->inter_matrix
[j
]= last
;
1729 s
->chroma_inter_matrix
[j
]= last
;
1733 // FIXME a bunch of grayscale shape things
1737 s
->quarter_sample
= get_bits1(gb
);
1738 else s
->quarter_sample
=0;
1741 int pos
= get_bits_count(gb
);
1742 int estimation_method
= get_bits(gb
, 2);
1743 if(estimation_method
<2){
1745 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //opaque
1746 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //transparent
1747 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //intra_cae
1748 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //inter_cae
1749 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //no_update
1750 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //upampling
1753 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //intra_blocks
1754 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //inter_blocks
1755 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //inter4v_blocks
1756 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //not coded blocks
1758 if(!check_marker(gb
, "in complexity estimation part 1")){
1759 skip_bits_long(gb
, pos
- get_bits_count(gb
));
1763 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //dct_coeffs
1764 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //dct_lines
1765 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //vlc_syms
1766 s
->cplx_estimation_trash_i
+= 4*get_bits1(gb
); //vlc_bits
1769 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //apm
1770 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //npm
1771 s
->cplx_estimation_trash_b
+= 8*get_bits1(gb
); //interpolate_mc_q
1772 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //forwback_mc_q
1773 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //halfpel2
1774 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //halfpel4
1776 if(!check_marker(gb
, "in complexity estimation part 2")){
1777 skip_bits_long(gb
, pos
- get_bits_count(gb
));
1780 if(estimation_method
==1){
1781 s
->cplx_estimation_trash_i
+= 8*get_bits1(gb
); //sadct
1782 s
->cplx_estimation_trash_p
+= 8*get_bits1(gb
); //qpel
1785 av_log(s
->avctx
, AV_LOG_ERROR
, "Invalid Complexity estimation method %d\n", estimation_method
);
1788 s
->cplx_estimation_trash_i
=
1789 s
->cplx_estimation_trash_p
=
1790 s
->cplx_estimation_trash_b
= 0;
1793 s
->resync_marker
= !get_bits1(gb
); /* resync_marker_disabled */
1795 s
->data_partitioning
= get_bits1(gb
);
1796 if(s
->data_partitioning
){
1797 s
->rvlc
= get_bits1(gb
);
1800 if(vo_ver_id
!= 1) {
1801 s
->new_pred
= get_bits1(gb
);
1803 av_log(s
->avctx
, AV_LOG_ERROR
, "new pred not supported\n");
1804 skip_bits(gb
, 2); /* requested upstream message type */
1805 skip_bits1(gb
); /* newpred segment type */
1807 s
->reduced_res_vop
= get_bits1(gb
);
1808 if(s
->reduced_res_vop
) av_log(s
->avctx
, AV_LOG_ERROR
, "reduced resolution VOP not supported\n");
1812 s
->reduced_res_vop
= 0;
1815 s
->scalability
= get_bits1(gb
);
1817 if (s
->scalability
) {
1818 GetBitContext bak
= *gb
;
1819 int h_sampling_factor_n
;
1820 int h_sampling_factor_m
;
1821 int v_sampling_factor_n
;
1822 int v_sampling_factor_m
;
1824 s
->hierachy_type
= get_bits1(gb
);
1825 skip_bits(gb
, 4); /* ref_layer_id */
1826 skip_bits1(gb
); /* ref_layer_sampling_dir */
1827 h_sampling_factor_n
= get_bits(gb
, 5);
1828 h_sampling_factor_m
= get_bits(gb
, 5);
1829 v_sampling_factor_n
= get_bits(gb
, 5);
1830 v_sampling_factor_m
= get_bits(gb
, 5);
1831 s
->enhancement_type
= get_bits1(gb
);
1833 if( h_sampling_factor_n
==0 || h_sampling_factor_m
==0
1834 || v_sampling_factor_n
==0 || v_sampling_factor_m
==0){
1835 /* illegal scalability header (VERY broken encoder),
1836 * trying to workaround */
1840 av_log(s
->avctx
, AV_LOG_ERROR
, "scalability not supported\n");
1842 // bin shape stuff FIXME
1849 * decodes the user data stuff in the header.
1850 * Also initializes divx/xvid/lavc_version/build.
1852 static int decode_user_data(MpegEncContext
*s
, GetBitContext
*gb
){
1856 int ver
= 0, build
= 0, ver2
= 0, ver3
= 0;
1859 for(i
=0; i
<255 && get_bits_count(gb
) < gb
->size_in_bits
; i
++){
1860 if(show_bits(gb
, 23) == 0) break;
1861 buf
[i
]= get_bits(gb
, 8);
1865 /* divx detection */
1866 e
=sscanf(buf
, "DivX%dBuild%d%c", &ver
, &build
, &last
);
1868 e
=sscanf(buf
, "DivX%db%d%c", &ver
, &build
, &last
);
1870 s
->divx_version
= ver
;
1871 s
->divx_build
= build
;
1872 s
->divx_packed
= e
==3 && last
=='p';
1873 if(s
->divx_packed
&& !s
->showed_packed_warning
) {
1874 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid and inefficient vfw-avi packed B frames detected\n");
1875 s
->showed_packed_warning
=1;
1879 /* ffmpeg detection */
1880 e
=sscanf(buf
, "FFmpe%*[^b]b%d", &build
)+3;
1882 e
=sscanf(buf
, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver
, &ver2
, &ver3
, &build
);
1884 e
=sscanf(buf
, "Lavc%d.%d.%d", &ver
, &ver2
, &ver3
)+1;
1886 build
= (ver
<<16) + (ver2
<<8) + ver3
;
1889 if(strcmp(buf
, "ffmpeg")==0){
1890 s
->lavc_build
= 4600;
1894 s
->lavc_build
= build
;
1897 /* Xvid detection */
1898 e
=sscanf(buf
, "XviD%d", &build
);
1900 s
->xvid_build
= build
;
1906 static int decode_vop_header(MpegEncContext
*s
, GetBitContext
*gb
){
1907 int time_incr
, time_increment
;
1909 s
->pict_type
= get_bits(gb
, 2) + AV_PICTURE_TYPE_I
; /* pict type: I = 0 , P = 1 */
1910 if(s
->pict_type
==AV_PICTURE_TYPE_B
&& s
->low_delay
&& s
->vol_control_parameters
==0 && !(s
->flags
& CODEC_FLAG_LOW_DELAY
)){
1911 av_log(s
->avctx
, AV_LOG_ERROR
, "low_delay flag incorrectly, clearing it\n");
1915 s
->partitioned_frame
= s
->data_partitioning
&& s
->pict_type
!=AV_PICTURE_TYPE_B
;
1916 if(s
->partitioned_frame
)
1917 s
->decode_mb
= mpeg4_decode_partitioned_mb
;
1919 s
->decode_mb
= mpeg4_decode_mb
;
1922 while (get_bits1(gb
) != 0)
1925 check_marker(gb
, "before time_increment");
1927 if(s
->time_increment_bits
==0 || !(show_bits(gb
, s
->time_increment_bits
+1)&1)){
1928 av_log(s
->avctx
, AV_LOG_ERROR
, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
1930 for(s
->time_increment_bits
=1 ;s
->time_increment_bits
<16; s
->time_increment_bits
++){
1931 if ( s
->pict_type
== AV_PICTURE_TYPE_P
1932 || (s
->pict_type
== AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
)) {
1933 if((show_bits(gb
, s
->time_increment_bits
+6)&0x37) == 0x30) break;
1935 if((show_bits(gb
, s
->time_increment_bits
+5)&0x1F) == 0x18) break;
1938 av_log(s
->avctx
, AV_LOG_ERROR
, "my guess is %d bits ;)\n",s
->time_increment_bits
);
1941 if(IS_3IV1
) time_increment
= get_bits1(gb
); //FIXME investigate further
1942 else time_increment
= get_bits(gb
, s
->time_increment_bits
);
1944 if(s
->pict_type
!=AV_PICTURE_TYPE_B
){
1945 s
->last_time_base
= s
->time_base
;
1946 s
->time_base
+= time_incr
;
1947 s
->time
= s
->time_base
*s
->avctx
->time_base
.den
+ time_increment
;
1948 if(s
->workaround_bugs
&FF_BUG_UMP4
){
1949 if(s
->time
< s
->last_non_b_time
){
1950 /* header is not mpeg-4-compatible, broken encoder,
1951 * trying to workaround */
1953 s
->time
+= s
->avctx
->time_base
.den
;
1956 s
->pp_time
= s
->time
- s
->last_non_b_time
;
1957 s
->last_non_b_time
= s
->time
;
1959 s
->time
= (s
->last_time_base
+ time_incr
)*s
->avctx
->time_base
.den
+ time_increment
;
1960 s
->pb_time
= s
->pp_time
- (s
->last_non_b_time
- s
->time
);
1961 if(s
->pp_time
<=s
->pb_time
|| s
->pp_time
<= s
->pp_time
- s
->pb_time
|| s
->pp_time
<=0){
1962 /* messed up order, maybe after seeking? skipping current b-frame */
1963 return FRAME_SKIPPED
;
1965 ff_mpeg4_init_direct_mv(s
);
1967 if(s
->t_frame
==0) s
->t_frame
= s
->pb_time
;
1968 if(s
->t_frame
==0) s
->t_frame
=1; // 1/0 protection
1969 s
->pp_field_time
= ( ROUNDED_DIV(s
->last_non_b_time
, s
->t_frame
)
1970 - ROUNDED_DIV(s
->last_non_b_time
- s
->pp_time
, s
->t_frame
))*2;
1971 s
->pb_field_time
= ( ROUNDED_DIV(s
->time
, s
->t_frame
)
1972 - ROUNDED_DIV(s
->last_non_b_time
- s
->pp_time
, s
->t_frame
))*2;
1973 if(!s
->progressive_sequence
){
1974 if(s
->pp_field_time
<= s
->pb_field_time
|| s
->pb_field_time
<= 1)
1975 return FRAME_SKIPPED
;
1979 if(s
->avctx
->time_base
.num
)
1980 s
->current_picture_ptr
->f
.pts
= (s
->time
+ s
->avctx
->time_base
.num
/ 2) / s
->avctx
->time_base
.num
;
1982 s
->current_picture_ptr
->f
.pts
= AV_NOPTS_VALUE
;
1983 if(s
->avctx
->debug
&FF_DEBUG_PTS
)
1984 av_log(s
->avctx
, AV_LOG_DEBUG
, "MPEG4 PTS: %"PRId64
"\n",
1985 s
->current_picture_ptr
->f
.pts
);
1987 check_marker(gb
, "before vop_coded");
1990 if (get_bits1(gb
) != 1){
1991 if(s
->avctx
->debug
&FF_DEBUG_PICT_INFO
)
1992 av_log(s
->avctx
, AV_LOG_ERROR
, "vop not coded\n");
1993 return FRAME_SKIPPED
;
1995 if (s
->shape
!= BIN_ONLY_SHAPE
&& ( s
->pict_type
== AV_PICTURE_TYPE_P
1996 || (s
->pict_type
== AV_PICTURE_TYPE_S
&& s
->vol_sprite_usage
==GMC_SPRITE
))) {
1997 /* rounding type for motion estimation */
1998 s
->no_rounding
= get_bits1(gb
);
2002 //FIXME reduced res stuff
2004 if (s
->shape
!= RECT_SHAPE
) {
2005 if (s
->vol_sprite_usage
!= 1 || s
->pict_type
!= AV_PICTURE_TYPE_I
) {
2006 skip_bits(gb
, 13); /* width */
2007 skip_bits1(gb
); /* marker */
2008 skip_bits(gb
, 13); /* height */
2009 skip_bits1(gb
); /* marker */
2010 skip_bits(gb
, 13); /* hor_spat_ref */
2011 skip_bits1(gb
); /* marker */
2012 skip_bits(gb
, 13); /* ver_spat_ref */
2014 skip_bits1(gb
); /* change_CR_disable */
2016 if (get_bits1(gb
) != 0) {
2017 skip_bits(gb
, 8); /* constant_alpha_value */
2020 //FIXME complexity estimation stuff
2022 if (s
->shape
!= BIN_ONLY_SHAPE
) {
2023 skip_bits_long(gb
, s
->cplx_estimation_trash_i
);
2024 if(s
->pict_type
!= AV_PICTURE_TYPE_I
)
2025 skip_bits_long(gb
, s
->cplx_estimation_trash_p
);
2026 if(s
->pict_type
== AV_PICTURE_TYPE_B
)
2027 skip_bits_long(gb
, s
->cplx_estimation_trash_b
);
2029 s
->intra_dc_threshold
= mpeg4_dc_threshold
[ get_bits(gb
, 3) ];
2030 if(!s
->progressive_sequence
){
2031 s
->top_field_first
= get_bits1(gb
);
2032 s
->alternate_scan
= get_bits1(gb
);
2034 s
->alternate_scan
= 0;
2037 if(s
->alternate_scan
){
2038 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->inter_scantable
, ff_alternate_vertical_scan
);
2039 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->intra_scantable
, ff_alternate_vertical_scan
);
2040 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->intra_h_scantable
, ff_alternate_vertical_scan
);
2041 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->intra_v_scantable
, ff_alternate_vertical_scan
);
2043 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->inter_scantable
, ff_zigzag_direct
);
2044 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->intra_scantable
, ff_zigzag_direct
);
2045 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->intra_h_scantable
, ff_alternate_horizontal_scan
);
2046 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->intra_v_scantable
, ff_alternate_vertical_scan
);
2049 if(s
->pict_type
== AV_PICTURE_TYPE_S
&& (s
->vol_sprite_usage
==STATIC_SPRITE
|| s
->vol_sprite_usage
==GMC_SPRITE
)){
2050 mpeg4_decode_sprite_trajectory(s
, gb
);
2051 if(s
->sprite_brightness_change
) av_log(s
->avctx
, AV_LOG_ERROR
, "sprite_brightness_change not supported\n");
2052 if(s
->vol_sprite_usage
==STATIC_SPRITE
) av_log(s
->avctx
, AV_LOG_ERROR
, "static sprite not supported\n");
2055 if (s
->shape
!= BIN_ONLY_SHAPE
) {
2056 s
->chroma_qscale
= s
->qscale
= get_bits(gb
, s
->quant_precision
);
2058 av_log(s
->avctx
, AV_LOG_ERROR
, "Error, header damaged or not MPEG4 header (qscale=0)\n");
2059 return -1; // makes no sense to continue, as there is nothing left from the image then
2062 if (s
->pict_type
!= AV_PICTURE_TYPE_I
) {
2063 s
->f_code
= get_bits(gb
, 3); /* fcode_for */
2065 av_log(s
->avctx
, AV_LOG_ERROR
, "Error, header damaged or not MPEG4 header (f_code=0)\n");
2066 return -1; // makes no sense to continue, as the MV decoding will break very quickly
2071 if (s
->pict_type
== AV_PICTURE_TYPE_B
) {
2072 s
->b_code
= get_bits(gb
, 3);
2076 if(s
->avctx
->debug
&FF_DEBUG_PICT_INFO
){
2077 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",
2078 s
->qscale
, s
->f_code
, s
->b_code
,
2079 s
->pict_type
== AV_PICTURE_TYPE_I ?
"I" : (s
->pict_type
== AV_PICTURE_TYPE_P ?
"P" : (s
->pict_type
== AV_PICTURE_TYPE_B ?
"B" : "S")),
2080 gb
->size_in_bits
,s
->progressive_sequence
, s
->alternate_scan
, s
->top_field_first
,
2081 s
->quarter_sample ?
"q" : "h", s
->data_partitioning
, s
->resync_marker
, s
->num_sprite_warping_points
,
2082 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
);
2085 if(!s
->scalability
){
2086 if (s
->shape
!=RECT_SHAPE
&& s
->pict_type
!=AV_PICTURE_TYPE_I
) {
2087 skip_bits1(gb
); // vop shape coding type
2090 if(s
->enhancement_type
){
2091 int load_backward_shape
= get_bits1(gb
);
2092 if(load_backward_shape
){
2093 av_log(s
->avctx
, AV_LOG_ERROR
, "load backward shape isn't supported\n");
2096 skip_bits(gb
, 2); //ref_select_code
2099 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
2100 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
2101 if(s
->vo_type
==0 && s
->vol_control_parameters
==0 && s
->divx_version
==-1 && s
->picture_number
==0){
2102 av_log(s
->avctx
, AV_LOG_WARNING
, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
2106 s
->picture_number
++; // better than pic number==0 always ;)
2108 s
->y_dc_scale_table
= ff_mpeg4_y_dc_scale_table
; //FIXME add short header support
2109 s
->c_dc_scale_table
= ff_mpeg4_c_dc_scale_table
;
2111 if(s
->workaround_bugs
&FF_BUG_EDGE
){
2112 s
->h_edge_pos
= s
->width
;
2113 s
->v_edge_pos
= s
->height
;
2119 * decode mpeg4 headers
2120 * @return <0 if no VOP found (or a damaged one)
2121 * FRAME_SKIPPED if a not coded VOP is found
2122 * 0 if a VOP is found
2124 int ff_mpeg4_decode_picture_header(MpegEncContext
* s
, GetBitContext
*gb
)
2128 /* search next start code */
2131 if(s
->codec_tag
== AV_RL32("WV1F") && show_bits(gb
, 24) == 0x575630){
2133 if(get_bits(gb
, 8) == 0xF0)
2139 if(get_bits_count(gb
) >= gb
->size_in_bits
){
2140 if(gb
->size_in_bits
==8 && (s
->divx_version
>=0 || s
->xvid_build
>=0)){
2141 av_log(s
->avctx
, AV_LOG_WARNING
, "frame skip %d\n", gb
->size_in_bits
);
2142 return FRAME_SKIPPED
; //divx bug
2144 return -1; //end of stream
2147 /* use the bits after the test */
2148 v
= get_bits(gb
, 8);
2149 startcode
= ((startcode
<< 8) | v
) & 0xffffffff;
2151 if((startcode
&0xFFFFFF00) != 0x100)
2152 continue; //no startcode
2154 if(s
->avctx
->debug
&FF_DEBUG_STARTCODE
){
2155 av_log(s
->avctx
, AV_LOG_DEBUG
, "startcode: %3X ", startcode
);
2156 if (startcode
<=0x11F) av_log(s
->avctx
, AV_LOG_DEBUG
, "Video Object Start");
2157 else if(startcode
<=0x12F) av_log(s
->avctx
, AV_LOG_DEBUG
, "Video Object Layer Start");
2158 else if(startcode
<=0x13F) av_log(s
->avctx
, AV_LOG_DEBUG
, "Reserved");
2159 else if(startcode
<=0x15F) av_log(s
->avctx
, AV_LOG_DEBUG
, "FGS bp start");
2160 else if(startcode
<=0x1AF) av_log(s
->avctx
, AV_LOG_DEBUG
, "Reserved");
2161 else if(startcode
==0x1B0) av_log(s
->avctx
, AV_LOG_DEBUG
, "Visual Object Seq Start");
2162 else if(startcode
==0x1B1) av_log(s
->avctx
, AV_LOG_DEBUG
, "Visual Object Seq End");
2163 else if(startcode
==0x1B2) av_log(s
->avctx
, AV_LOG_DEBUG
, "User Data");
2164 else if(startcode
==0x1B3) av_log(s
->avctx
, AV_LOG_DEBUG
, "Group of VOP start");
2165 else if(startcode
==0x1B4) av_log(s
->avctx
, AV_LOG_DEBUG
, "Video Session Error");
2166 else if(startcode
==0x1B5) av_log(s
->avctx
, AV_LOG_DEBUG
, "Visual Object Start");
2167 else if(startcode
==0x1B6) av_log(s
->avctx
, AV_LOG_DEBUG
, "Video Object Plane start");
2168 else if(startcode
==0x1B7) av_log(s
->avctx
, AV_LOG_DEBUG
, "slice start");
2169 else if(startcode
==0x1B8) av_log(s
->avctx
, AV_LOG_DEBUG
, "extension start");
2170 else if(startcode
==0x1B9) av_log(s
->avctx
, AV_LOG_DEBUG
, "fgs start");
2171 else if(startcode
==0x1BA) av_log(s
->avctx
, AV_LOG_DEBUG
, "FBA Object start");
2172 else if(startcode
==0x1BB) av_log(s
->avctx
, AV_LOG_DEBUG
, "FBA Object Plane start");
2173 else if(startcode
==0x1BC) av_log(s
->avctx
, AV_LOG_DEBUG
, "Mesh Object start");
2174 else if(startcode
==0x1BD) av_log(s
->avctx
, AV_LOG_DEBUG
, "Mesh Object Plane start");
2175 else if(startcode
==0x1BE) av_log(s
->avctx
, AV_LOG_DEBUG
, "Still Texture Object start");
2176 else if(startcode
==0x1BF) av_log(s
->avctx
, AV_LOG_DEBUG
, "Texture Spatial Layer start");
2177 else if(startcode
==0x1C0) av_log(s
->avctx
, AV_LOG_DEBUG
, "Texture SNR Layer start");
2178 else if(startcode
==0x1C1) av_log(s
->avctx
, AV_LOG_DEBUG
, "Texture Tile start");
2179 else if(startcode
==0x1C2) av_log(s
->avctx
, AV_LOG_DEBUG
, "Texture Shape Layer start");
2180 else if(startcode
==0x1C3) av_log(s
->avctx
, AV_LOG_DEBUG
, "stuffing start");
2181 else if(startcode
<=0x1C5) av_log(s
->avctx
, AV_LOG_DEBUG
, "reserved");
2182 else if(startcode
<=0x1FF) av_log(s
->avctx
, AV_LOG_DEBUG
, "System start");
2183 av_log(s
->avctx
, AV_LOG_DEBUG
, " at %d\n", get_bits_count(gb
));
2186 if(startcode
>= 0x120 && startcode
<= 0x12F){
2187 if(decode_vol_header(s
, gb
) < 0)
2190 else if(startcode
== USER_DATA_STARTCODE
){
2191 decode_user_data(s
, gb
);
2193 else if(startcode
== GOP_STARTCODE
){
2194 mpeg4_decode_gop_header(s
, gb
);
2196 else if(startcode
== VOS_STARTCODE
){
2197 mpeg4_decode_profile_level(s
, gb
);
2199 else if(startcode
== VOP_STARTCODE
){
2207 if(s
->flags
& CODEC_FLAG_LOW_DELAY
)
2209 s
->avctx
->has_b_frames
= !s
->low_delay
;
2210 return decode_vop_header(s
, gb
);
2213 static av_cold
int decode_init(AVCodecContext
*avctx
)
2215 MpegEncContext
*s
= avctx
->priv_data
;
2217 static int done
= 0;
2224 if((ret
=ff_h263_decode_init(avctx
)) < 0)
2230 init_rl(&ff_mpeg4_rl_intra
, ff_mpeg4_static_rl_table_store
[0]);
2231 init_rl(&rvlc_rl_inter
, ff_mpeg4_static_rl_table_store
[1]);
2232 init_rl(&rvlc_rl_intra
, ff_mpeg4_static_rl_table_store
[2]);
2233 INIT_VLC_RL(ff_mpeg4_rl_intra
, 554);
2234 INIT_VLC_RL(rvlc_rl_inter
, 1072);
2235 INIT_VLC_RL(rvlc_rl_intra
, 1072);
2236 INIT_VLC_STATIC(&dc_lum
, DC_VLC_BITS
, 10 /* 13 */,
2237 &ff_mpeg4_DCtab_lum
[0][1], 2, 1,
2238 &ff_mpeg4_DCtab_lum
[0][0], 2, 1, 512);
2239 INIT_VLC_STATIC(&dc_chrom
, DC_VLC_BITS
, 10 /* 13 */,
2240 &ff_mpeg4_DCtab_chrom
[0][1], 2, 1,
2241 &ff_mpeg4_DCtab_chrom
[0][0], 2, 1, 512);
2242 INIT_VLC_STATIC(&sprite_trajectory
, SPRITE_TRAJ_VLC_BITS
, 15,
2243 &sprite_trajectory_tab
[0][1], 4, 2,
2244 &sprite_trajectory_tab
[0][0], 4, 2, 128);
2245 INIT_VLC_STATIC(&mb_type_b_vlc
, MB_TYPE_B_VLC_BITS
, 4,
2246 &mb_type_b_tab
[0][1], 2, 1,
2247 &mb_type_b_tab
[0][0], 2, 1, 16);
2251 s
->low_delay
= 0; //default, might be overriden in the vol header during header parsing
2252 s
->decode_mb
= mpeg4_decode_mb
;
2253 s
->time_increment_bits
= 4; /* default value for broken headers */
2254 avctx
->chroma_sample_location
= AVCHROMA_LOC_LEFT
;
2259 static const AVProfile mpeg4_video_profiles
[] = {
2260 { FF_PROFILE_MPEG4_SIMPLE
, "Simple Profile" },
2261 { FF_PROFILE_MPEG4_SIMPLE_SCALABLE
, "Simple Scalable Profile" },
2262 { FF_PROFILE_MPEG4_CORE
, "Core Profile" },
2263 { FF_PROFILE_MPEG4_MAIN
, "Main Profile" },
2264 { FF_PROFILE_MPEG4_N_BIT
, "N-bit Profile" },
2265 { FF_PROFILE_MPEG4_SCALABLE_TEXTURE
, "Scalable Texture Profile" },
2266 { FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION
, "Simple Face Animation Profile" },
2267 { FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE
, "Basic Animated Texture Profile" },
2268 { FF_PROFILE_MPEG4_HYBRID
, "Hybrid Profile" },
2269 { FF_PROFILE_MPEG4_ADVANCED_REAL_TIME
, "Advanced Real Time Simple Profile" },
2270 { FF_PROFILE_MPEG4_CORE_SCALABLE
, "Code Scalable Profile" },
2271 { FF_PROFILE_MPEG4_ADVANCED_CODING
, "Advanced Coding Profile" },
2272 { FF_PROFILE_MPEG4_ADVANCED_CORE
, "Advanced Core Profile" },
2273 { FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE
, "Advanced Scalable Texture Profile" },
2274 { FF_PROFILE_MPEG4_SIMPLE_STUDIO
, "Simple Studio Profile" },
2275 { FF_PROFILE_MPEG4_ADVANCED_SIMPLE
, "Advanced Simple Profile" },
2278 AVCodec ff_mpeg4_decoder
= {
2282 sizeof(MpegEncContext
),
2286 ff_h263_decode_frame
,
2287 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
| CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
| CODEC_CAP_FRAME_THREADS
,
2288 .flush
= ff_mpeg_flush
,
2290 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
2291 .pix_fmts
= ff_hwaccel_pixfmt_list_420
,
2292 .profiles
= NULL_IF_CONFIG_SMALL(mpeg4_video_profiles
),
2293 .update_thread_context
= ONLY_IF_THREADS_ENABLED(ff_mpeg_update_thread_context
)
2297 #if CONFIG_MPEG4_VDPAU_DECODER
2298 AVCodec ff_mpeg4_vdpau_decoder
= {
2302 sizeof(MpegEncContext
),
2306 ff_h263_decode_frame
,
2307 CODEC_CAP_DR1
| CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
| CODEC_CAP_HWACCEL_VDPAU
,
2308 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
2309 .pix_fmts
= (const enum PixelFormat
[]){PIX_FMT_VDPAU_MPEG4
, PIX_FMT_NONE
},