00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "mpegvideo.h"
00024 #include "mpeg4video.h"
00025 #include "h263.h"
00026
00027
00028
00029
00030
00031 #define SPRITE_TRAJ_VLC_BITS 6
00032 #define DC_VLC_BITS 9
00033 #define MB_TYPE_B_VLC_BITS 4
00034
00035
00036 static VLC dc_lum, dc_chrom;
00037 static VLC sprite_trajectory;
00038 static VLC mb_type_b_vlc;
00039
00040 static const int mb_type_b_map[4]= {
00041 MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
00042 MB_TYPE_L0L1 | MB_TYPE_16x16,
00043 MB_TYPE_L1 | MB_TYPE_16x16,
00044 MB_TYPE_L0 | MB_TYPE_16x16,
00045 };
00046
00052 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
00053 int dir)
00054 {
00055 int i;
00056 int16_t *ac_val, *ac_val1;
00057 int8_t * const qscale_table= s->current_picture.qscale_table;
00058
00059
00060 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00061 ac_val1 = ac_val;
00062 if (s->ac_pred) {
00063 if (dir == 0) {
00064 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
00065
00066 ac_val -= 16;
00067
00068 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
00069
00070 for(i=1;i<8;i++) {
00071 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
00072 }
00073 }else{
00074
00075 for(i=1;i<8;i++) {
00076 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
00077 }
00078 }
00079 } else {
00080 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
00081
00082 ac_val -= 16 * s->block_wrap[n];
00083
00084 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
00085
00086 for(i=1;i<8;i++) {
00087 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
00088 }
00089 }else{
00090
00091 for(i=1;i<8;i++) {
00092 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
00093 }
00094 }
00095 }
00096 }
00097
00098 for(i=1;i<8;i++)
00099 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
00100
00101
00102 for(i=1;i<8;i++)
00103 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
00104
00105 }
00106
00111 static inline int mpeg4_is_resync(MpegEncContext *s){
00112 int bits_count= get_bits_count(&s->gb);
00113 int v= show_bits(&s->gb, 16);
00114
00115 if(s->workaround_bugs&FF_BUG_NO_PADDING){
00116 return 0;
00117 }
00118
00119 while(v<=0xFF){
00120 if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
00121 break;
00122 skip_bits(&s->gb, 8+s->pict_type);
00123 bits_count+= 8+s->pict_type;
00124 v= show_bits(&s->gb, 16);
00125 }
00126
00127 if(bits_count + 8 >= s->gb.size_in_bits){
00128 v>>=8;
00129 v|= 0x7F >> (7-(bits_count&7));
00130
00131 if(v==0x7F)
00132 return 1;
00133 }else{
00134 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
00135 int len;
00136 GetBitContext gb= s->gb;
00137
00138 skip_bits(&s->gb, 1);
00139 align_get_bits(&s->gb);
00140
00141 for(len=0; len<32; len++){
00142 if(get_bits1(&s->gb)) break;
00143 }
00144
00145 s->gb= gb;
00146
00147 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
00148 return 1;
00149 }
00150 }
00151 return 0;
00152 }
00153
00154 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
00155 {
00156 int i;
00157 int a= 2<<s->sprite_warping_accuracy;
00158 int rho= 3-s->sprite_warping_accuracy;
00159 int r=16/a;
00160 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}};
00161 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
00162 int sprite_ref[4][2];
00163 int virtual_ref[2][2];
00164 int w2, h2, w3, h3;
00165 int alpha=0, beta=0;
00166 int w= s->width;
00167 int h= s->height;
00168 int min_ab;
00169
00170 for(i=0; i<s->num_sprite_warping_points; i++){
00171 int length;
00172 int x=0, y=0;
00173
00174 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
00175 if(length){
00176 x= get_xbits(gb, length);
00177 }
00178 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb);
00179
00180 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
00181 if(length){
00182 y=get_xbits(gb, length);
00183 }
00184 skip_bits1(gb);
00185 s->sprite_traj[i][0]= d[i][0]= x;
00186 s->sprite_traj[i][1]= d[i][1]= y;
00187 }
00188 for(; i<4; i++)
00189 s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0;
00190
00191 while((1<<alpha)<w) alpha++;
00192 while((1<<beta )<h) beta++;
00193 w2= 1<<alpha;
00194 h2= 1<<beta;
00195
00196
00197 if(s->divx_version==500 && s->divx_build==413){
00198 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
00199 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
00200 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
00201 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
00202 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
00203 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
00204 } else {
00205 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
00206 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
00207 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
00208 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
00209 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
00210 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
00211 }
00212
00213
00214
00215
00216
00217
00218
00219 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
00220 + 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);
00221 virtual_ref[0][1]= 16*vop_ref[0][1]
00222 + 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);
00223 virtual_ref[1][0]= 16*vop_ref[0][0]
00224 + 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);
00225 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
00226 + 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);
00227
00228 switch(s->num_sprite_warping_points)
00229 {
00230 case 0:
00231 s->sprite_offset[0][0]= 0;
00232 s->sprite_offset[0][1]= 0;
00233 s->sprite_offset[1][0]= 0;
00234 s->sprite_offset[1][1]= 0;
00235 s->sprite_delta[0][0]= a;
00236 s->sprite_delta[0][1]= 0;
00237 s->sprite_delta[1][0]= 0;
00238 s->sprite_delta[1][1]= a;
00239 s->sprite_shift[0]= 0;
00240 s->sprite_shift[1]= 0;
00241 break;
00242 case 1:
00243 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
00244 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
00245 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
00246 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
00247 s->sprite_delta[0][0]= a;
00248 s->sprite_delta[0][1]= 0;
00249 s->sprite_delta[1][0]= 0;
00250 s->sprite_delta[1][1]= a;
00251 s->sprite_shift[0]= 0;
00252 s->sprite_shift[1]= 0;
00253 break;
00254 case 2:
00255 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
00256 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
00257 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
00258 + (1<<(alpha+rho-1));
00259 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
00260 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
00261 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
00262 + (1<<(alpha+rho-1));
00263 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
00264 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
00265 +2*w2*r*sprite_ref[0][0]
00266 - 16*w2
00267 + (1<<(alpha+rho+1)));
00268 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
00269 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
00270 +2*w2*r*sprite_ref[0][1]
00271 - 16*w2
00272 + (1<<(alpha+rho+1)));
00273 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
00274 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
00275 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
00276 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
00277
00278 s->sprite_shift[0]= alpha+rho;
00279 s->sprite_shift[1]= alpha+rho+2;
00280 break;
00281 case 3:
00282 min_ab= FFMIN(alpha, beta);
00283 w3= w2>>min_ab;
00284 h3= h2>>min_ab;
00285 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
00286 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
00287 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
00288 + (1<<(alpha+beta+rho-min_ab-1));
00289 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
00290 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
00291 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
00292 + (1<<(alpha+beta+rho-min_ab-1));
00293 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
00294 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
00295 + 2*w2*h3*r*sprite_ref[0][0]
00296 - 16*w2*h3
00297 + (1<<(alpha+beta+rho-min_ab+1));
00298 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
00299 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
00300 + 2*w2*h3*r*sprite_ref[0][1]
00301 - 16*w2*h3
00302 + (1<<(alpha+beta+rho-min_ab+1));
00303 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
00304 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
00305 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
00306 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
00307
00308 s->sprite_shift[0]= alpha + beta + rho - min_ab;
00309 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
00310 break;
00311 }
00312
00313 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
00314 && s->sprite_delta[0][1] == 0
00315 && s->sprite_delta[1][0] == 0
00316 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
00317 {
00318 s->sprite_offset[0][0]>>=s->sprite_shift[0];
00319 s->sprite_offset[0][1]>>=s->sprite_shift[0];
00320 s->sprite_offset[1][0]>>=s->sprite_shift[1];
00321 s->sprite_offset[1][1]>>=s->sprite_shift[1];
00322 s->sprite_delta[0][0]= a;
00323 s->sprite_delta[0][1]= 0;
00324 s->sprite_delta[1][0]= 0;
00325 s->sprite_delta[1][1]= a;
00326 s->sprite_shift[0]= 0;
00327 s->sprite_shift[1]= 0;
00328 s->real_sprite_warping_points=1;
00329 }
00330 else{
00331 int shift_y= 16 - s->sprite_shift[0];
00332 int shift_c= 16 - s->sprite_shift[1];
00333 for(i=0; i<2; i++){
00334 s->sprite_offset[0][i]<<= shift_y;
00335 s->sprite_offset[1][i]<<= shift_c;
00336 s->sprite_delta[0][i]<<= shift_y;
00337 s->sprite_delta[1][i]<<= shift_y;
00338 s->sprite_shift[i]= 16;
00339 }
00340 s->real_sprite_warping_points= s->num_sprite_warping_points;
00341 }
00342 }
00343
00348 int mpeg4_decode_video_packet_header(MpegEncContext *s)
00349 {
00350 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
00351 int header_extension=0, mb_num, len;
00352
00353
00354 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
00355
00356 for(len=0; len<32; len++){
00357 if(get_bits1(&s->gb)) break;
00358 }
00359
00360 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
00361 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
00362 return -1;
00363 }
00364
00365 if(s->shape != RECT_SHAPE){
00366 header_extension= get_bits1(&s->gb);
00367
00368 }
00369
00370 mb_num= get_bits(&s->gb, mb_num_bits);
00371 if(mb_num>=s->mb_num){
00372 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
00373 return -1;
00374 }
00375 if(s->pict_type == FF_B_TYPE){
00376 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
00377 if(mb_num >= s->mb_num) return -1;
00378 }
00379
00380 s->mb_x= mb_num % s->mb_width;
00381 s->mb_y= mb_num / s->mb_width;
00382
00383 if(s->shape != BIN_ONLY_SHAPE){
00384 int qscale= get_bits(&s->gb, s->quant_precision);
00385 if(qscale)
00386 s->chroma_qscale=s->qscale= qscale;
00387 }
00388
00389 if(s->shape == RECT_SHAPE){
00390 header_extension= get_bits1(&s->gb);
00391 }
00392 if(header_extension){
00393 int time_increment;
00394 int time_incr=0;
00395
00396 while (get_bits1(&s->gb) != 0)
00397 time_incr++;
00398
00399 check_marker(&s->gb, "before time_increment in video packed header");
00400 time_increment= get_bits(&s->gb, s->time_increment_bits);
00401 check_marker(&s->gb, "before vop_coding_type in video packed header");
00402
00403 skip_bits(&s->gb, 2);
00404
00405
00406 if(s->shape != BIN_ONLY_SHAPE){
00407 skip_bits(&s->gb, 3);
00408
00409 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
00410 mpeg4_decode_sprite_trajectory(s, &s->gb);
00411 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
00412 }
00413
00414
00415
00416 if (s->pict_type != FF_I_TYPE) {
00417 int f_code = get_bits(&s->gb, 3);
00418 if(f_code==0){
00419 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
00420 }
00421 }
00422 if (s->pict_type == FF_B_TYPE) {
00423 int b_code = get_bits(&s->gb, 3);
00424 if(b_code==0){
00425 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
00426 }
00427 }
00428 }
00429 }
00430
00431
00432 return 0;
00433 }
00434
00440 static inline int get_amv(MpegEncContext *s, int n){
00441 int x, y, mb_v, sum, dx, dy, shift;
00442 int len = 1 << (s->f_code + 4);
00443 const int a= s->sprite_warping_accuracy;
00444
00445 if(s->workaround_bugs & FF_BUG_AMV)
00446 len >>= s->quarter_sample;
00447
00448 if(s->real_sprite_warping_points==1){
00449 if(s->divx_version==500 && s->divx_build==413)
00450 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
00451 else
00452 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
00453 }else{
00454 dx= s->sprite_delta[n][0];
00455 dy= s->sprite_delta[n][1];
00456 shift= s->sprite_shift[0];
00457 if(n) dy -= 1<<(shift + a + 1);
00458 else dx -= 1<<(shift + a + 1);
00459 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
00460
00461 sum=0;
00462 for(y=0; y<16; y++){
00463 int v;
00464
00465 v= mb_v + dy*y;
00466
00467 for(x=0; x<16; x++){
00468 sum+= v>>shift;
00469 v+= dx;
00470 }
00471 }
00472 sum= RSHIFT(sum, a+8-s->quarter_sample);
00473 }
00474
00475 if (sum < -len) sum= -len;
00476 else if (sum >= len) sum= len-1;
00477
00478 return sum;
00479 }
00480
00487 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
00488 {
00489 int level, code;
00490
00491 if (n < 4)
00492 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
00493 else
00494 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
00495 if (code < 0 || code > 9 ){
00496 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
00497 return -1;
00498 }
00499 if (code == 0) {
00500 level = 0;
00501 } else {
00502 if(IS_3IV1){
00503 if(code==1)
00504 level= 2*get_bits1(&s->gb)-1;
00505 else{
00506 if(get_bits1(&s->gb))
00507 level = get_bits(&s->gb, code-1) + (1<<(code-1));
00508 else
00509 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
00510 }
00511 }else{
00512 level = get_xbits(&s->gb, code);
00513 }
00514
00515 if (code > 8){
00516 if(get_bits1(&s->gb)==0){
00517 if(s->error_recognition>=2){
00518 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
00519 return -1;
00520 }
00521 }
00522 }
00523 }
00524
00525 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
00526 }
00527
00532 static int mpeg4_decode_partition_a(MpegEncContext *s){
00533 int mb_num;
00534 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
00535
00536
00537 mb_num=0;
00538 s->first_slice_line=1;
00539 for(; s->mb_y<s->mb_height; s->mb_y++){
00540 ff_init_block_index(s);
00541 for(; s->mb_x<s->mb_width; s->mb_x++){
00542 const int xy= s->mb_x + s->mb_y*s->mb_stride;
00543 int cbpc;
00544 int dir=0;
00545
00546 mb_num++;
00547 ff_update_block_index(s);
00548 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
00549 s->first_slice_line=0;
00550
00551 if(s->pict_type==FF_I_TYPE){
00552 int i;
00553
00554 do{
00555 if(show_bits_long(&s->gb, 19)==DC_MARKER){
00556 return mb_num-1;
00557 }
00558
00559 cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
00560 if (cbpc < 0){
00561 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
00562 return -1;
00563 }
00564 }while(cbpc == 8);
00565
00566 s->cbp_table[xy]= cbpc & 3;
00567 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
00568 s->mb_intra = 1;
00569
00570 if(cbpc & 4) {
00571 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
00572 }
00573 s->current_picture.qscale_table[xy]= s->qscale;
00574
00575 s->mbintra_table[xy]= 1;
00576 for(i=0; i<6; i++){
00577 int dc_pred_dir;
00578 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
00579 if(dc < 0){
00580 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
00581 return -1;
00582 }
00583 dir<<=1;
00584 if(dc_pred_dir) dir|=1;
00585 }
00586 s->pred_dir_table[xy]= dir;
00587 }else{
00588 int mx, my, pred_x, pred_y, bits;
00589 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
00590 const int stride= s->b8_stride*2;
00591
00592 try_again:
00593 bits= show_bits(&s->gb, 17);
00594 if(bits==MOTION_MARKER){
00595 return mb_num-1;
00596 }
00597 skip_bits1(&s->gb);
00598 if(bits&0x10000){
00599
00600 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
00601 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
00602 mx= get_amv(s, 0);
00603 my= get_amv(s, 1);
00604 }else{
00605 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
00606 mx=my=0;
00607 }
00608 mot_val[0 ]= mot_val[2 ]=
00609 mot_val[0+stride]= mot_val[2+stride]= mx;
00610 mot_val[1 ]= mot_val[3 ]=
00611 mot_val[1+stride]= mot_val[3+stride]= my;
00612
00613 if(s->mbintra_table[xy])
00614 ff_clean_intra_table_entries(s);
00615 continue;
00616 }
00617
00618 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
00619 if (cbpc < 0){
00620 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
00621 return -1;
00622 }
00623 if(cbpc == 20)
00624 goto try_again;
00625
00626 s->cbp_table[xy]= cbpc&(8+3);
00627
00628 s->mb_intra = ((cbpc & 4) != 0);
00629
00630 if(s->mb_intra){
00631 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
00632 s->mbintra_table[xy]= 1;
00633 mot_val[0 ]= mot_val[2 ]=
00634 mot_val[0+stride]= mot_val[2+stride]= 0;
00635 mot_val[1 ]= mot_val[3 ]=
00636 mot_val[1+stride]= mot_val[3+stride]= 0;
00637 }else{
00638 if(s->mbintra_table[xy])
00639 ff_clean_intra_table_entries(s);
00640
00641 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
00642 s->mcsel= get_bits1(&s->gb);
00643 else s->mcsel= 0;
00644
00645 if ((cbpc & 16) == 0) {
00646
00647
00648 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00649 if(!s->mcsel){
00650 mx = h263_decode_motion(s, pred_x, s->f_code);
00651 if (mx >= 0xffff)
00652 return -1;
00653
00654 my = h263_decode_motion(s, pred_y, s->f_code);
00655 if (my >= 0xffff)
00656 return -1;
00657 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
00658 } else {
00659 mx = get_amv(s, 0);
00660 my = get_amv(s, 1);
00661 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
00662 }
00663
00664 mot_val[0 ]= mot_val[2 ] =
00665 mot_val[0+stride]= mot_val[2+stride]= mx;
00666 mot_val[1 ]= mot_val[3 ]=
00667 mot_val[1+stride]= mot_val[3+stride]= my;
00668 } else {
00669 int i;
00670 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
00671 for(i=0;i<4;i++) {
00672 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
00673 mx = h263_decode_motion(s, pred_x, s->f_code);
00674 if (mx >= 0xffff)
00675 return -1;
00676
00677 my = h263_decode_motion(s, pred_y, s->f_code);
00678 if (my >= 0xffff)
00679 return -1;
00680 mot_val[0] = mx;
00681 mot_val[1] = my;
00682 }
00683 }
00684 }
00685 }
00686 }
00687 s->mb_x= 0;
00688 }
00689
00690 return mb_num;
00691 }
00692
00697 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
00698 int mb_num=0;
00699 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
00700
00701 s->mb_x= s->resync_mb_x;
00702 s->first_slice_line=1;
00703 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
00704 ff_init_block_index(s);
00705 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
00706 const int xy= s->mb_x + s->mb_y*s->mb_stride;
00707
00708 mb_num++;
00709 ff_update_block_index(s);
00710 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
00711 s->first_slice_line=0;
00712
00713 if(s->pict_type==FF_I_TYPE){
00714 int ac_pred= get_bits1(&s->gb);
00715 int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
00716 if(cbpy<0){
00717 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
00718 return -1;
00719 }
00720
00721 s->cbp_table[xy]|= cbpy<<2;
00722 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
00723 }else{
00724 if(IS_INTRA(s->current_picture.mb_type[xy])){
00725 int dir=0,i;
00726 int ac_pred = get_bits1(&s->gb);
00727 int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
00728
00729 if(cbpy<0){
00730 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
00731 return -1;
00732 }
00733
00734 if(s->cbp_table[xy] & 8) {
00735 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
00736 }
00737 s->current_picture.qscale_table[xy]= s->qscale;
00738
00739 for(i=0; i<6; i++){
00740 int dc_pred_dir;
00741 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
00742 if(dc < 0){
00743 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
00744 return -1;
00745 }
00746 dir<<=1;
00747 if(dc_pred_dir) dir|=1;
00748 }
00749 s->cbp_table[xy]&= 3;
00750 s->cbp_table[xy]|= cbpy<<2;
00751 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
00752 s->pred_dir_table[xy]= dir;
00753 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
00754 s->current_picture.qscale_table[xy]= s->qscale;
00755 s->cbp_table[xy]= 0;
00756 }else{
00757 int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
00758
00759 if(cbpy<0){
00760 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
00761 return -1;
00762 }
00763
00764 if(s->cbp_table[xy] & 8) {
00765 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
00766 }
00767 s->current_picture.qscale_table[xy]= s->qscale;
00768
00769 s->cbp_table[xy]&= 3;
00770 s->cbp_table[xy]|= (cbpy^0xf)<<2;
00771 }
00772 }
00773 }
00774 if(mb_num >= mb_count) return 0;
00775 s->mb_x= 0;
00776 }
00777 return 0;
00778 }
00779
00784 int ff_mpeg4_decode_partitions(MpegEncContext *s)
00785 {
00786 int mb_num;
00787 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
00788 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END;
00789
00790 mb_num= mpeg4_decode_partition_a(s);
00791 if(mb_num<0){
00792 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
00793 return -1;
00794 }
00795
00796 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
00797 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
00798 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
00799 return -1;
00800 }
00801
00802 s->mb_num_left= mb_num;
00803
00804 if(s->pict_type==FF_I_TYPE){
00805 while(show_bits(&s->gb, 9) == 1)
00806 skip_bits(&s->gb, 9);
00807 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
00808 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
00809 return -1;
00810 }
00811 }else{
00812 while(show_bits(&s->gb, 10) == 1)
00813 skip_bits(&s->gb, 10);
00814 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
00815 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
00816 return -1;
00817 }
00818 }
00819 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
00820
00821 if( mpeg4_decode_partition_b(s, mb_num) < 0){
00822 if(s->pict_type==FF_P_TYPE)
00823 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
00824 return -1;
00825 }else{
00826 if(s->pict_type==FF_P_TYPE)
00827 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
00828 }
00829
00830 return 0;
00831 }
00832
00837 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
00838 int n, int coded, int intra, int rvlc)
00839 {
00840 int level, i, last, run;
00841 int dc_pred_dir;
00842 RLTable * rl;
00843 RL_VLC_ELEM * rl_vlc;
00844 const uint8_t * scan_table;
00845 int qmul, qadd;
00846
00847
00848
00849 if(intra) {
00850 if(s->use_intra_dc_vlc){
00851
00852 if(s->partitioned_frame){
00853 level = s->dc_val[0][ s->block_index[n] ];
00854 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
00855 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
00856 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
00857 }else{
00858 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
00859 if (level < 0)
00860 return -1;
00861 }
00862 block[0] = level;
00863 i = 0;
00864 }else{
00865 i = -1;
00866 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
00867 }
00868 if (!coded)
00869 goto not_coded;
00870
00871 if(rvlc){
00872 rl = &rvlc_rl_intra;
00873 rl_vlc = rvlc_rl_intra.rl_vlc[0];
00874 }else{
00875 rl = &ff_mpeg4_rl_intra;
00876 rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
00877 }
00878 if (s->ac_pred) {
00879 if (dc_pred_dir == 0)
00880 scan_table = s->intra_v_scantable.permutated;
00881 else
00882 scan_table = s->intra_h_scantable.permutated;
00883 } else {
00884 scan_table = s->intra_scantable.permutated;
00885 }
00886 qmul=1;
00887 qadd=0;
00888 } else {
00889 i = -1;
00890 if (!coded) {
00891 s->block_last_index[n] = i;
00892 return 0;
00893 }
00894 if(rvlc) rl = &rvlc_rl_inter;
00895 else rl = &ff_h263_rl_inter;
00896
00897 scan_table = s->intra_scantable.permutated;
00898
00899 if(s->mpeg_quant){
00900 qmul=1;
00901 qadd=0;
00902 if(rvlc){
00903 rl_vlc = rvlc_rl_inter.rl_vlc[0];
00904 }else{
00905 rl_vlc = ff_h263_rl_inter.rl_vlc[0];
00906 }
00907 }else{
00908 qmul = s->qscale << 1;
00909 qadd = (s->qscale - 1) | 1;
00910 if(rvlc){
00911 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
00912 }else{
00913 rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
00914 }
00915 }
00916 }
00917 {
00918 OPEN_READER(re, &s->gb);
00919 for(;;) {
00920 UPDATE_CACHE(re, &s->gb);
00921 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
00922 if (level==0) {
00923
00924 if(rvlc){
00925 if(SHOW_UBITS(re, &s->gb, 1)==0){
00926 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
00927 return -1;
00928 }; SKIP_CACHE(re, &s->gb, 1);
00929
00930 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
00931 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
00932 SKIP_COUNTER(re, &s->gb, 1+1+6);
00933 UPDATE_CACHE(re, &s->gb);
00934
00935 if(SHOW_UBITS(re, &s->gb, 1)==0){
00936 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
00937 return -1;
00938 }; SKIP_CACHE(re, &s->gb, 1);
00939
00940 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
00941
00942 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
00943 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
00944 return -1;
00945 }; SKIP_CACHE(re, &s->gb, 5);
00946
00947 level= level * qmul + qadd;
00948 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
00949 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
00950
00951 i+= run + 1;
00952 if(last) i+=192;
00953 }else{
00954 int cache;
00955 cache= GET_CACHE(re, &s->gb);
00956
00957 if(IS_3IV1)
00958 cache ^= 0xC0000000;
00959
00960 if (cache&0x80000000) {
00961 if (cache&0x40000000) {
00962
00963 SKIP_CACHE(re, &s->gb, 2);
00964 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
00965 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
00966 SKIP_COUNTER(re, &s->gb, 2+1+6);
00967 UPDATE_CACHE(re, &s->gb);
00968
00969 if(IS_3IV1){
00970 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
00971 }else{
00972 if(SHOW_UBITS(re, &s->gb, 1)==0){
00973 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
00974 return -1;
00975 }; SKIP_CACHE(re, &s->gb, 1);
00976
00977 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
00978
00979 if(SHOW_UBITS(re, &s->gb, 1)==0){
00980 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
00981 return -1;
00982 }; LAST_SKIP_CACHE(re, &s->gb, 1);
00983
00984 SKIP_COUNTER(re, &s->gb, 1+12+1);
00985 }
00986
00987 #if 0
00988 if(s->error_recognition >= FF_ER_COMPLIANT){
00989 const int abs_level= FFABS(level);
00990 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
00991 const int run1= run - rl->max_run[last][abs_level] - 1;
00992 if(abs_level <= rl->max_level[last][run]){
00993 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
00994 return -1;
00995 }
00996 if(s->error_recognition > FF_ER_COMPLIANT){
00997 if(abs_level <= rl->max_level[last][run]*2){
00998 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
00999 return -1;
01000 }
01001 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
01002 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
01003 return -1;
01004 }
01005 }
01006 }
01007 }
01008 #endif
01009 if (level>0) level= level * qmul + qadd;
01010 else level= level * qmul - qadd;
01011
01012 if((unsigned)(level + 2048) > 4095){
01013 if(s->error_recognition > FF_ER_COMPLIANT){
01014 if(level > 2560 || level<-2560){
01015 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
01016 return -1;
01017 }
01018 }
01019 level= level<0 ? -2048 : 2047;
01020 }
01021
01022 i+= run + 1;
01023 if(last) i+=192;
01024 } else {
01025
01026 SKIP_BITS(re, &s->gb, 2);
01027 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01028 i+= run + rl->max_run[run>>7][level/qmul] +1;
01029 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01030 LAST_SKIP_BITS(re, &s->gb, 1);
01031 }
01032 } else {
01033
01034 SKIP_BITS(re, &s->gb, 1);
01035 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01036 i+= run;
01037 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;
01038 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01039 LAST_SKIP_BITS(re, &s->gb, 1);
01040 }
01041 }
01042 } else {
01043 i+= run;
01044 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01045 LAST_SKIP_BITS(re, &s->gb, 1);
01046 }
01047 if (i > 62){
01048 i-= 192;
01049 if(i&(~63)){
01050 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
01051 return -1;
01052 }
01053
01054 block[scan_table[i]] = level;
01055 break;
01056 }
01057
01058 block[scan_table[i]] = level;
01059 }
01060 CLOSE_READER(re, &s->gb);
01061 }
01062 not_coded:
01063 if (intra) {
01064 if(!s->use_intra_dc_vlc){
01065 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
01066
01067 i -= i>>31;
01068 }
01069
01070 mpeg4_pred_ac(s, block, n, dc_pred_dir);
01071 if (s->ac_pred) {
01072 i = 63;
01073 }
01074 }
01075 s->block_last_index[n] = i;
01076 return 0;
01077 }
01078
01083 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
01084 {
01085 int cbp, mb_type;
01086 const int xy= s->mb_x + s->mb_y*s->mb_stride;
01087
01088 mb_type= s->current_picture.mb_type[xy];
01089 cbp = s->cbp_table[xy];
01090
01091 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
01092
01093 if(s->current_picture.qscale_table[xy] != s->qscale){
01094 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
01095 }
01096
01097 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
01098 int i;
01099 for(i=0; i<4; i++){
01100 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
01101 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
01102 }
01103 s->mb_intra = IS_INTRA(mb_type);
01104
01105 if (IS_SKIP(mb_type)) {
01106
01107 for(i=0;i<6;i++)
01108 s->block_last_index[i] = -1;
01109 s->mv_dir = MV_DIR_FORWARD;
01110 s->mv_type = MV_TYPE_16X16;
01111 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
01112 s->mcsel=1;
01113 s->mb_skipped = 0;
01114 }else{
01115 s->mcsel=0;
01116 s->mb_skipped = 1;
01117 }
01118 }else if(s->mb_intra){
01119 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
01120 }else if(!s->mb_intra){
01121
01122
01123 s->mv_dir = MV_DIR_FORWARD;
01124 if (IS_8X8(mb_type)) {
01125 s->mv_type = MV_TYPE_8X8;
01126 } else {
01127 s->mv_type = MV_TYPE_16X16;
01128 }
01129 }
01130 } else {
01131 s->mb_intra = 1;
01132 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
01133 }
01134
01135 if (!IS_SKIP(mb_type)) {
01136 int i;
01137 s->dsp.clear_blocks(s->block[0]);
01138
01139 for (i = 0; i < 6; i++) {
01140 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
01141 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
01142 return -1;
01143 }
01144 cbp+=cbp;
01145 }
01146 }
01147
01148
01149
01150 if(--s->mb_num_left <= 0){
01151 if(mpeg4_is_resync(s))
01152 return SLICE_END;
01153 else
01154 return SLICE_NOEND;
01155 }else{
01156 if(mpeg4_is_resync(s)){
01157 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
01158 if(s->cbp_table[xy+delta])
01159 return SLICE_END;
01160 }
01161 return SLICE_OK;
01162 }
01163 }
01164
01165 static int mpeg4_decode_mb(MpegEncContext *s,
01166 DCTELEM block[6][64])
01167 {
01168 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
01169 int16_t *mot_val;
01170 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
01171 const int xy= s->mb_x + s->mb_y * s->mb_stride;
01172
01173 assert(s->h263_pred);
01174
01175 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) {
01176 do{
01177 if (get_bits1(&s->gb)) {
01178
01179 s->mb_intra = 0;
01180 for(i=0;i<6;i++)
01181 s->block_last_index[i] = -1;
01182 s->mv_dir = MV_DIR_FORWARD;
01183 s->mv_type = MV_TYPE_16X16;
01184 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
01185 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
01186 s->mcsel=1;
01187 s->mv[0][0][0]= get_amv(s, 0);
01188 s->mv[0][0][1]= get_amv(s, 1);
01189
01190 s->mb_skipped = 0;
01191 }else{
01192 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
01193 s->mcsel=0;
01194 s->mv[0][0][0] = 0;
01195 s->mv[0][0][1] = 0;
01196 s->mb_skipped = 1;
01197 }
01198 goto end;
01199 }
01200 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
01201 if (cbpc < 0){
01202 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
01203 return -1;
01204 }
01205 }while(cbpc == 20);
01206
01207 s->dsp.clear_blocks(s->block[0]);
01208 dquant = cbpc & 8;
01209 s->mb_intra = ((cbpc & 4) != 0);
01210 if (s->mb_intra) goto intra;
01211
01212 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
01213 s->mcsel= get_bits1(&s->gb);
01214 else s->mcsel= 0;
01215 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
01216
01217 cbp = (cbpc & 3) | (cbpy << 2);
01218 if (dquant) {
01219 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
01220 }
01221 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
01222 s->interlaced_dct= get_bits1(&s->gb);
01223
01224 s->mv_dir = MV_DIR_FORWARD;
01225 if ((cbpc & 16) == 0) {
01226 if(s->mcsel){
01227 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
01228
01229 s->mv_type = MV_TYPE_16X16;
01230 mx= get_amv(s, 0);
01231 my= get_amv(s, 1);
01232 s->mv[0][0][0] = mx;
01233 s->mv[0][0][1] = my;
01234 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
01235 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
01236
01237 s->mv_type= MV_TYPE_FIELD;
01238
01239 s->field_select[0][0]= get_bits1(&s->gb);
01240 s->field_select[0][1]= get_bits1(&s->gb);
01241
01242 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01243
01244 for(i=0; i<2; i++){
01245 mx = h263_decode_motion(s, pred_x, s->f_code);
01246 if (mx >= 0xffff)
01247 return -1;
01248
01249 my = h263_decode_motion(s, pred_y/2, s->f_code);
01250 if (my >= 0xffff)
01251 return -1;
01252
01253 s->mv[0][i][0] = mx;
01254 s->mv[0][i][1] = my;
01255 }
01256 }else{
01257 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
01258
01259 s->mv_type = MV_TYPE_16X16;
01260 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01261 mx = h263_decode_motion(s, pred_x, s->f_code);
01262
01263 if (mx >= 0xffff)
01264 return -1;
01265
01266 my = h263_decode_motion(s, pred_y, s->f_code);
01267
01268 if (my >= 0xffff)
01269 return -1;
01270 s->mv[0][0][0] = mx;
01271 s->mv[0][0][1] = my;
01272 }
01273 } else {
01274 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
01275 s->mv_type = MV_TYPE_8X8;
01276 for(i=0;i<4;i++) {
01277 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01278 mx = h263_decode_motion(s, pred_x, s->f_code);
01279 if (mx >= 0xffff)
01280 return -1;
01281
01282 my = h263_decode_motion(s, pred_y, s->f_code);
01283 if (my >= 0xffff)
01284 return -1;
01285 s->mv[0][i][0] = mx;
01286 s->mv[0][i][1] = my;
01287 mot_val[0] = mx;
01288 mot_val[1] = my;
01289 }
01290 }
01291 } else if(s->pict_type==FF_B_TYPE) {
01292 int modb1;
01293 int modb2;
01294 int mb_type;
01295
01296 s->mb_intra = 0;
01297 s->mcsel=0;
01298
01299 if(s->mb_x==0){
01300 for(i=0; i<2; i++){
01301 s->last_mv[i][0][0]=
01302 s->last_mv[i][0][1]=
01303 s->last_mv[i][1][0]=
01304 s->last_mv[i][1][1]= 0;
01305 }
01306 }
01307
01308
01309 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x];
01310
01311 if(s->mb_skipped){
01312
01313 for(i=0;i<6;i++)
01314 s->block_last_index[i] = -1;
01315
01316 s->mv_dir = MV_DIR_FORWARD;
01317 s->mv_type = MV_TYPE_16X16;
01318 s->mv[0][0][0] = 0;
01319 s->mv[0][0][1] = 0;
01320 s->mv[1][0][0] = 0;
01321 s->mv[1][0][1] = 0;
01322 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
01323 goto end;
01324 }
01325
01326 modb1= get_bits1(&s->gb);
01327 if(modb1){
01328 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1;
01329 cbp=0;
01330 }else{
01331 modb2= get_bits1(&s->gb);
01332 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
01333 if(mb_type<0){
01334 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
01335 return -1;
01336 }
01337 mb_type= mb_type_b_map[ mb_type ];
01338 if(modb2) cbp= 0;
01339 else{
01340 s->dsp.clear_blocks(s->block[0]);
01341 cbp= get_bits(&s->gb, 6);
01342 }
01343
01344 if ((!IS_DIRECT(mb_type)) && cbp) {
01345 if(get_bits1(&s->gb)){
01346 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
01347 }
01348 }
01349
01350 if(!s->progressive_sequence){
01351 if(cbp)
01352 s->interlaced_dct= get_bits1(&s->gb);
01353
01354 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
01355 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
01356 mb_type &= ~MB_TYPE_16x16;
01357
01358 if(USES_LIST(mb_type, 0)){
01359 s->field_select[0][0]= get_bits1(&s->gb);
01360 s->field_select[0][1]= get_bits1(&s->gb);
01361 }
01362 if(USES_LIST(mb_type, 1)){
01363 s->field_select[1][0]= get_bits1(&s->gb);
01364 s->field_select[1][1]= get_bits1(&s->gb);
01365 }
01366 }
01367 }
01368
01369 s->mv_dir = 0;
01370 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
01371 s->mv_type= MV_TYPE_16X16;
01372
01373 if(USES_LIST(mb_type, 0)){
01374 s->mv_dir = MV_DIR_FORWARD;
01375
01376 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
01377 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
01378 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
01379 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
01380 }
01381
01382 if(USES_LIST(mb_type, 1)){
01383 s->mv_dir |= MV_DIR_BACKWARD;
01384
01385 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
01386 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
01387 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
01388 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
01389 }
01390 }else if(!IS_DIRECT(mb_type)){
01391 s->mv_type= MV_TYPE_FIELD;
01392
01393 if(USES_LIST(mb_type, 0)){
01394 s->mv_dir = MV_DIR_FORWARD;
01395
01396 for(i=0; i<2; i++){
01397 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
01398 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
01399 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
01400 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
01401 }
01402 }
01403
01404 if(USES_LIST(mb_type, 1)){
01405 s->mv_dir |= MV_DIR_BACKWARD;
01406
01407 for(i=0; i<2; i++){
01408 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
01409 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
01410 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
01411 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
01412 }
01413 }
01414 }
01415 }
01416
01417 if(IS_DIRECT(mb_type)){
01418 if(IS_SKIP(mb_type))
01419 mx=my=0;
01420 else{
01421 mx = h263_decode_motion(s, 0, 1);
01422 my = h263_decode_motion(s, 0, 1);
01423 }
01424
01425 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
01426 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
01427 }
01428 s->current_picture.mb_type[xy]= mb_type;
01429 } else {
01430 do{
01431 cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
01432 if (cbpc < 0){
01433 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
01434 return -1;
01435 }
01436 }while(cbpc == 8);
01437
01438 dquant = cbpc & 4;
01439 s->mb_intra = 1;
01440 intra:
01441 s->ac_pred = get_bits1(&s->gb);
01442 if(s->ac_pred)
01443 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
01444 else
01445 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
01446
01447 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
01448 if(cbpy<0){
01449 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
01450 return -1;
01451 }
01452 cbp = (cbpc & 3) | (cbpy << 2);
01453
01454 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
01455
01456 if (dquant) {
01457 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
01458 }
01459
01460 if(!s->progressive_sequence)
01461 s->interlaced_dct= get_bits1(&s->gb);
01462
01463 s->dsp.clear_blocks(s->block[0]);
01464
01465 for (i = 0; i < 6; i++) {
01466 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
01467 return -1;
01468 cbp+=cbp;
01469 }
01470 goto end;
01471 }
01472
01473
01474 for (i = 0; i < 6; i++) {
01475 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
01476 return -1;
01477 cbp+=cbp;
01478 }
01479 end:
01480
01481
01482 if(s->codec_id==CODEC_ID_MPEG4){
01483 if(mpeg4_is_resync(s)){
01484 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
01485 if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta])
01486 return SLICE_OK;
01487 return SLICE_END;
01488 }
01489 }
01490
01491 return SLICE_OK;
01492 }
01493
01494
01495 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
01496 int hours, minutes, seconds;
01497 unsigned time_code = show_bits(gb, 18);
01498
01499 if (time_code & 0x40) {
01500 hours = time_code >> 13;
01501 minutes = time_code >> 7 & 0x3f;
01502 seconds = time_code & 0x3f;
01503 s->time_base = seconds + 60*(minutes + 60*hours);
01504 skip_bits(gb, 20);
01505 } else {
01506 av_log(s->avctx, AV_LOG_WARNING, "GOP header missing marker_bit\n");
01507 }
01508
01509 return 0;
01510 }
01511
01512 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
01513 int width, height, vo_ver_id;
01514
01515
01516 skip_bits(gb, 1);
01517 s->vo_type= get_bits(gb, 8);
01518 if (get_bits1(gb) != 0) {
01519 vo_ver_id = get_bits(gb, 4);
01520 skip_bits(gb, 3);
01521 } else {
01522 vo_ver_id = 1;
01523 }
01524 s->aspect_ratio_info= get_bits(gb, 4);
01525 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
01526 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8);
01527 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8);
01528 }else{
01529 s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info];
01530 }
01531
01532 if ((s->vol_control_parameters=get_bits1(gb))) {
01533 int chroma_format= get_bits(gb, 2);
01534 if(chroma_format!=CHROMA_420){
01535 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
01536 }
01537 s->low_delay= get_bits1(gb);
01538 if(get_bits1(gb)){
01539 get_bits(gb, 15);
01540 skip_bits1(gb);
01541 get_bits(gb, 15);
01542 skip_bits1(gb);
01543 get_bits(gb, 15);
01544 skip_bits1(gb);
01545 get_bits(gb, 3);
01546 get_bits(gb, 11);
01547 skip_bits1(gb);
01548 get_bits(gb, 15);
01549 skip_bits1(gb);
01550 }
01551 }else{
01552
01553 if(s->picture_number==0)
01554 s->low_delay=0;
01555 }
01556
01557 s->shape = get_bits(gb, 2);
01558 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
01559 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
01560 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
01561 skip_bits(gb, 4);
01562 }
01563
01564 check_marker(gb, "before time_increment_resolution");
01565
01566 s->avctx->time_base.den = get_bits(gb, 16);
01567 if(!s->avctx->time_base.den){
01568 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
01569 s->avctx->time_base.num = 0;
01570 return -1;
01571 }
01572
01573 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
01574 if (s->time_increment_bits < 1)
01575 s->time_increment_bits = 1;
01576
01577 check_marker(gb, "before fixed_vop_rate");
01578
01579 if (get_bits1(gb) != 0) {
01580 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
01581 }else
01582 s->avctx->time_base.num = 1;
01583
01584 s->t_frame=0;
01585
01586 if (s->shape != BIN_ONLY_SHAPE) {
01587 if (s->shape == RECT_SHAPE) {
01588 skip_bits1(gb);
01589 width = get_bits(gb, 13);
01590 skip_bits1(gb);
01591 height = get_bits(gb, 13);
01592 skip_bits1(gb);
01593 if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){
01594 s->width = width;
01595 s->height = height;
01596 }
01597 }
01598
01599 s->progressive_sequence=
01600 s->progressive_frame= get_bits1(gb)^1;
01601 s->interlaced_dct=0;
01602 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
01603 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");
01604 if (vo_ver_id == 1) {
01605 s->vol_sprite_usage = get_bits1(gb);
01606 } else {
01607 s->vol_sprite_usage = get_bits(gb, 2);
01608 }
01609 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
01610 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
01611 if(s->vol_sprite_usage==STATIC_SPRITE){
01612 s->sprite_width = get_bits(gb, 13);
01613 skip_bits1(gb);
01614 s->sprite_height= get_bits(gb, 13);
01615 skip_bits1(gb);
01616 s->sprite_left = get_bits(gb, 13);
01617 skip_bits1(gb);
01618 s->sprite_top = get_bits(gb, 13);
01619 skip_bits1(gb);
01620 }
01621 s->num_sprite_warping_points= get_bits(gb, 6);
01622 if(s->num_sprite_warping_points > 3){
01623 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
01624 s->num_sprite_warping_points= 0;
01625 return -1;
01626 }
01627 s->sprite_warping_accuracy = get_bits(gb, 2);
01628 s->sprite_brightness_change= get_bits1(gb);
01629 if(s->vol_sprite_usage==STATIC_SPRITE)
01630 s->low_latency_sprite= get_bits1(gb);
01631 }
01632
01633
01634 if (get_bits1(gb) == 1) {
01635 s->quant_precision = get_bits(gb, 4);
01636 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n");
01637 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
01638 } else {
01639 s->quant_precision = 5;
01640 }
01641
01642
01643
01644 if((s->mpeg_quant=get_bits1(gb))){
01645 int i, v;
01646
01647
01648 for(i=0; i<64; i++){
01649 int j= s->dsp.idct_permutation[i];
01650 v= ff_mpeg4_default_intra_matrix[i];
01651 s->intra_matrix[j]= v;
01652 s->chroma_intra_matrix[j]= v;
01653
01654 v= ff_mpeg4_default_non_intra_matrix[i];
01655 s->inter_matrix[j]= v;
01656 s->chroma_inter_matrix[j]= v;
01657 }
01658
01659
01660 if(get_bits1(gb)){
01661 int last=0;
01662 for(i=0; i<64; i++){
01663 int j;
01664 v= get_bits(gb, 8);
01665 if(v==0) break;
01666
01667 last= v;
01668 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01669 s->intra_matrix[j]= v;
01670 s->chroma_intra_matrix[j]= v;
01671 }
01672
01673
01674 for(; i<64; i++){
01675 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01676 s->intra_matrix[j]= last;
01677 s->chroma_intra_matrix[j]= last;
01678 }
01679 }
01680
01681
01682 if(get_bits1(gb)){
01683 int last=0;
01684 for(i=0; i<64; i++){
01685 int j;
01686 v= get_bits(gb, 8);
01687 if(v==0) break;
01688
01689 last= v;
01690 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01691 s->inter_matrix[j]= v;
01692 s->chroma_inter_matrix[j]= v;
01693 }
01694
01695
01696 for(; i<64; i++){
01697 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01698 s->inter_matrix[j]= last;
01699 s->chroma_inter_matrix[j]= last;
01700 }
01701 }
01702
01703
01704 }
01705
01706 if(vo_ver_id != 1)
01707 s->quarter_sample= get_bits1(gb);
01708 else s->quarter_sample=0;
01709
01710 if(!get_bits1(gb)){
01711 int pos= get_bits_count(gb);
01712 int estimation_method= get_bits(gb, 2);
01713 if(estimation_method<2){
01714 if(!get_bits1(gb)){
01715 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01716 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01717 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01718 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01719 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01720 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01721 }
01722 if(!get_bits1(gb)){
01723 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01724 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01725 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01726 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01727 }
01728 if(!check_marker(gb, "in complexity estimation part 1")){
01729 skip_bits_long(gb, pos - get_bits_count(gb));
01730 goto no_cplx_est;
01731 }
01732 if(!get_bits1(gb)){
01733 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01734 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01735 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01736 s->cplx_estimation_trash_i += 4*get_bits1(gb);
01737 }
01738 if(!get_bits1(gb)){
01739 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01740 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01741 s->cplx_estimation_trash_b += 8*get_bits1(gb);
01742 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01743 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01744 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01745 }
01746 if(!check_marker(gb, "in complexity estimation part 2")){
01747 skip_bits_long(gb, pos - get_bits_count(gb));
01748 goto no_cplx_est;
01749 }
01750 if(estimation_method==1){
01751 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01752 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01753 }
01754 }else
01755 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method);
01756 }else{
01757 no_cplx_est:
01758 s->cplx_estimation_trash_i=
01759 s->cplx_estimation_trash_p=
01760 s->cplx_estimation_trash_b= 0;
01761 }
01762
01763 s->resync_marker= !get_bits1(gb);
01764
01765 s->data_partitioning= get_bits1(gb);
01766 if(s->data_partitioning){
01767 s->rvlc= get_bits1(gb);
01768 }
01769
01770 if(vo_ver_id != 1) {
01771 s->new_pred= get_bits1(gb);
01772 if(s->new_pred){
01773 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
01774 skip_bits(gb, 2);
01775 skip_bits1(gb);
01776 }
01777 s->reduced_res_vop= get_bits1(gb);
01778 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
01779 }
01780 else{
01781 s->new_pred=0;
01782 s->reduced_res_vop= 0;
01783 }
01784
01785 s->scalability= get_bits1(gb);
01786
01787 if (s->scalability) {
01788 GetBitContext bak= *gb;
01789 int ref_layer_id;
01790 int ref_layer_sampling_dir;
01791 int h_sampling_factor_n;
01792 int h_sampling_factor_m;
01793 int v_sampling_factor_n;
01794 int v_sampling_factor_m;
01795
01796 s->hierachy_type= get_bits1(gb);
01797 ref_layer_id= get_bits(gb, 4);
01798 ref_layer_sampling_dir= get_bits1(gb);
01799 h_sampling_factor_n= get_bits(gb, 5);
01800 h_sampling_factor_m= get_bits(gb, 5);
01801 v_sampling_factor_n= get_bits(gb, 5);
01802 v_sampling_factor_m= get_bits(gb, 5);
01803 s->enhancement_type= get_bits1(gb);
01804
01805 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
01806 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
01807
01808
01809 s->scalability=0;
01810 *gb= bak;
01811 }else
01812 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
01813
01814
01815 }
01816 }
01817 return 0;
01818 }
01819
01824 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
01825 char buf[256];
01826 int i;
01827 int e;
01828 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
01829 char last;
01830
01831 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
01832 if(show_bits(gb, 23) == 0) break;
01833 buf[i]= get_bits(gb, 8);
01834 }
01835 buf[i]=0;
01836
01837
01838 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
01839 if(e<2)
01840 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
01841 if(e>=2){
01842 s->divx_version= ver;
01843 s->divx_build= build;
01844 s->divx_packed= e==3 && last=='p';
01845 if(s->divx_packed && !s->showed_packed_warning) {
01846 av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n");
01847 s->showed_packed_warning=1;
01848 }
01849 }
01850
01851
01852 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
01853 if(e!=4)
01854 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
01855 if(e!=4){
01856 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
01857 if (e>1)
01858 build= (ver<<16) + (ver2<<8) + ver3;
01859 }
01860 if(e!=4){
01861 if(strcmp(buf, "ffmpeg")==0){
01862 s->lavc_build= 4600;
01863 }
01864 }
01865 if(e==4){
01866 s->lavc_build= build;
01867 }
01868
01869
01870 e=sscanf(buf, "XviD%d", &build);
01871 if(e==1){
01872 s->xvid_build= build;
01873 }
01874
01875 return 0;
01876 }
01877
01878 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
01879 int time_incr, time_increment;
01880
01881 s->pict_type = get_bits(gb, 2) + FF_I_TYPE;
01882 if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
01883 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
01884 s->low_delay=0;
01885 }
01886
01887 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
01888 if(s->partitioned_frame)
01889 s->decode_mb= mpeg4_decode_partitioned_mb;
01890 else
01891 s->decode_mb= mpeg4_decode_mb;
01892
01893 time_incr=0;
01894 while (get_bits1(gb) != 0)
01895 time_incr++;
01896
01897 check_marker(gb, "before time_increment");
01898
01899 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
01900 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
01901
01902 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
01903 if ( s->pict_type == FF_P_TYPE
01904 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
01905 if((show_bits(gb, s->time_increment_bits+6)&0x37) == 0x30) break;
01906 }else
01907 if((show_bits(gb, s->time_increment_bits+5)&0x1F) == 0x18) break;
01908 }
01909
01910 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
01911 }
01912
01913 if(IS_3IV1) time_increment= get_bits1(gb);
01914 else time_increment= get_bits(gb, s->time_increment_bits);
01915
01916 if(s->pict_type!=FF_B_TYPE){
01917 s->last_time_base= s->time_base;
01918 s->time_base+= time_incr;
01919 s->time= s->time_base*s->avctx->time_base.den + time_increment;
01920 if(s->workaround_bugs&FF_BUG_UMP4){
01921 if(s->time < s->last_non_b_time){
01922
01923
01924 s->time_base++;
01925 s->time+= s->avctx->time_base.den;
01926 }
01927 }
01928 s->pp_time= s->time - s->last_non_b_time;
01929 s->last_non_b_time= s->time;
01930 }else{
01931 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
01932 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
01933 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
01934
01935 return FRAME_SKIPPED;
01936 }
01937 ff_mpeg4_init_direct_mv(s);
01938
01939 if(s->t_frame==0) s->t_frame= s->pb_time;
01940 if(s->t_frame==0) s->t_frame=1;
01941 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
01942 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
01943 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
01944 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
01945 if(!s->progressive_sequence){
01946 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
01947 return FRAME_SKIPPED;
01948 }
01949 }
01950
01951 if(s->avctx->time_base.num)
01952 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
01953 else
01954 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
01955 if(s->avctx->debug&FF_DEBUG_PTS)
01956 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
01957
01958 check_marker(gb, "before vop_coded");
01959
01960
01961 if (get_bits1(gb) != 1){
01962 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
01963 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
01964 return FRAME_SKIPPED;
01965 }
01966 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE
01967 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
01968
01969 s->no_rounding = get_bits1(gb);
01970 } else {
01971 s->no_rounding = 0;
01972 }
01973
01974
01975 if (s->shape != RECT_SHAPE) {
01976 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) {
01977 int width, height, hor_spat_ref, ver_spat_ref;
01978
01979 width = get_bits(gb, 13);
01980 skip_bits1(gb);
01981 height = get_bits(gb, 13);
01982 skip_bits1(gb);
01983 hor_spat_ref = get_bits(gb, 13);
01984 skip_bits1(gb);
01985 ver_spat_ref = get_bits(gb, 13);
01986 }
01987 skip_bits1(gb);
01988
01989 if (get_bits1(gb) != 0) {
01990 skip_bits(gb, 8);
01991 }
01992 }
01993
01994
01995 if (s->shape != BIN_ONLY_SHAPE) {
01996 skip_bits_long(gb, s->cplx_estimation_trash_i);
01997 if(s->pict_type != FF_I_TYPE)
01998 skip_bits_long(gb, s->cplx_estimation_trash_p);
01999 if(s->pict_type == FF_B_TYPE)
02000 skip_bits_long(gb, s->cplx_estimation_trash_b);
02001
02002 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
02003 if(!s->progressive_sequence){
02004 s->top_field_first= get_bits1(gb);
02005 s->alternate_scan= get_bits1(gb);
02006 }else
02007 s->alternate_scan= 0;
02008 }
02009
02010 if(s->alternate_scan){
02011 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
02012 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
02013 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
02014 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
02015 } else{
02016 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
02017 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
02018 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
02019 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
02020 }
02021
02022 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
02023 mpeg4_decode_sprite_trajectory(s, gb);
02024 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
02025 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
02026 }
02027
02028 if (s->shape != BIN_ONLY_SHAPE) {
02029 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
02030 if(s->qscale==0){
02031 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
02032 return -1;
02033 }
02034
02035 if (s->pict_type != FF_I_TYPE) {
02036 s->f_code = get_bits(gb, 3);
02037 if(s->f_code==0){
02038 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
02039 return -1;
02040 }
02041 }else
02042 s->f_code=1;
02043
02044 if (s->pict_type == FF_B_TYPE) {
02045 s->b_code = get_bits(gb, 3);
02046 }else
02047 s->b_code=1;
02048
02049 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
02050 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",
02051 s->qscale, s->f_code, s->b_code,
02052 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
02053 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
02054 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
02055 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);
02056 }
02057
02058 if(!s->scalability){
02059 if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) {
02060 skip_bits1(gb);
02061 }
02062 }else{
02063 if(s->enhancement_type){
02064 int load_backward_shape= get_bits1(gb);
02065 if(load_backward_shape){
02066 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
02067 }
02068 }
02069 skip_bits(gb, 2);
02070 }
02071 }
02072
02073
02074 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==-1 && s->picture_number==0){
02075 av_log(s->avctx, AV_LOG_WARNING, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
02076 s->low_delay=1;
02077 }
02078
02079 s->picture_number++;
02080
02081 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
02082 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
02083
02084 if(s->workaround_bugs&FF_BUG_EDGE){
02085 s->h_edge_pos= s->width;
02086 s->v_edge_pos= s->height;
02087 }
02088 return 0;
02089 }
02090
02097 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
02098 {
02099 int startcode, v;
02100
02101
02102 align_get_bits(gb);
02103
02104 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){
02105 skip_bits(gb, 24);
02106 if(get_bits(gb, 8) == 0xF0)
02107 goto end;
02108 }
02109
02110 startcode = 0xff;
02111 for(;;) {
02112 if(get_bits_count(gb) >= gb->size_in_bits){
02113 if(gb->size_in_bits==8 && (s->divx_version>=0 || s->xvid_build>=0)){
02114 av_log(s->avctx, AV_LOG_WARNING, "frame skip %d\n", gb->size_in_bits);
02115 return FRAME_SKIPPED;
02116 }else
02117 return -1;
02118 }
02119
02120
02121 v = get_bits(gb, 8);
02122 startcode = ((startcode << 8) | v) & 0xffffffff;
02123
02124 if((startcode&0xFFFFFF00) != 0x100)
02125 continue;
02126
02127 if(s->avctx->debug&FF_DEBUG_STARTCODE){
02128 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
02129 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
02130 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
02131 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
02132 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
02133 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
02134 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
02135 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
02136 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
02137 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
02138 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
02139 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
02140 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
02141 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
02142 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
02143 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
02144 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
02145 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
02146 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
02147 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
02148 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
02149 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
02150 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
02151 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
02152 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
02153 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
02154 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
02155 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
02156 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
02157 }
02158
02159 if(startcode >= 0x120 && startcode <= 0x12F){
02160 if(decode_vol_header(s, gb) < 0)
02161 return -1;
02162 }
02163 else if(startcode == USER_DATA_STARTCODE){
02164 decode_user_data(s, gb);
02165 }
02166 else if(startcode == GOP_STARTCODE){
02167 mpeg4_decode_gop_header(s, gb);
02168 }
02169 else if(startcode == VOP_STARTCODE){
02170 break;
02171 }
02172
02173 align_get_bits(gb);
02174 startcode = 0xff;
02175 }
02176 end:
02177 if(s->flags& CODEC_FLAG_LOW_DELAY)
02178 s->low_delay=1;
02179 s->avctx->has_b_frames= !s->low_delay;
02180 return decode_vop_header(s, gb);
02181 }
02182
02183 static av_cold int decode_init(AVCodecContext *avctx)
02184 {
02185 MpegEncContext *s = avctx->priv_data;
02186 int ret;
02187 static int done = 0;
02188
02189 s->divx_version=
02190 s->divx_build=
02191 s->xvid_build=
02192 s->lavc_build= -1;
02193
02194 if((ret=ff_h263_decode_init(avctx)) < 0)
02195 return ret;
02196
02197 if (!done) {
02198 done = 1;
02199
02200 init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
02201 init_rl(&rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
02202 init_rl(&rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
02203 INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
02204 INIT_VLC_RL(rvlc_rl_inter, 1072);
02205 INIT_VLC_RL(rvlc_rl_intra, 1072);
02206 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 ,
02207 &ff_mpeg4_DCtab_lum[0][1], 2, 1,
02208 &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
02209 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 ,
02210 &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
02211 &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
02212 INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
02213 &sprite_trajectory_tab[0][1], 4, 2,
02214 &sprite_trajectory_tab[0][0], 4, 2, 128);
02215 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
02216 &mb_type_b_tab[0][1], 2, 1,
02217 &mb_type_b_tab[0][0], 2, 1, 16);
02218 }
02219
02220 s->h263_pred = 1;
02221 s->low_delay = 0;
02222 s->decode_mb= mpeg4_decode_mb;
02223 s->time_increment_bits = 4;
02224 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
02225
02226 return 0;
02227 }
02228
02229 AVCodec ff_mpeg4_decoder = {
02230 "mpeg4",
02231 AVMEDIA_TYPE_VIDEO,
02232 CODEC_ID_MPEG4,
02233 sizeof(MpegEncContext),
02234 decode_init,
02235 NULL,
02236 ff_h263_decode_end,
02237 ff_h263_decode_frame,
02238 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
02239 .flush= ff_mpeg_flush,
02240 .max_lowres= 3,
02241 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
02242 .pix_fmts= ff_hwaccel_pixfmt_list_420,
02243 };
02244
02245
02246 #if CONFIG_MPEG4_VDPAU_DECODER
02247 AVCodec ff_mpeg4_vdpau_decoder = {
02248 "mpeg4_vdpau",
02249 AVMEDIA_TYPE_VIDEO,
02250 CODEC_ID_MPEG4,
02251 sizeof(MpegEncContext),
02252 decode_init,
02253 NULL,
02254 ff_h263_decode_end,
02255 ff_h263_decode_frame,
02256 CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
02257 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
02258 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_VDPAU_MPEG4, PIX_FMT_NONE},
02259 };
02260 #endif