Mercurial > libavcodec.hg
comparison h263.c @ 10803:4605bd2fdb7f libavcodec
Split the mpeg4 encoder and decoder off h263.c
author | michael |
---|---|
date | Thu, 07 Jan 2010 23:53:49 +0000 |
parents | 00a3206c3e42 |
children | c03a8c6c755b |
comparison
equal
deleted
inserted
replaced
10802:4f614b69b4e5 | 10803:4605bd2fdb7f |
---|---|
35 #include <limits.h> | 35 #include <limits.h> |
36 | 36 |
37 #include "dsputil.h" | 37 #include "dsputil.h" |
38 #include "avcodec.h" | 38 #include "avcodec.h" |
39 #include "mpegvideo.h" | 39 #include "mpegvideo.h" |
40 #include "h263.h" | |
40 #include "h263data.h" | 41 #include "h263data.h" |
41 #include "mpeg4data.h" | |
42 #include "mathops.h" | 42 #include "mathops.h" |
43 #include "unary.h" | 43 #include "unary.h" |
44 #include "flv.h" | 44 #include "flv.h" |
45 #include "mpeg4video.h" | |
45 | 46 |
46 //#undef NDEBUG | 47 //#undef NDEBUG |
47 //#include <assert.h> | 48 //#include <assert.h> |
48 | 49 |
49 // The defines below define the number of bits that are read at once for | 50 // The defines below define the number of bits that are read at once for |
50 // reading vlc values. Changing these may improve speed and data cache needs | 51 // reading vlc values. Changing these may improve speed and data cache needs |
51 // be aware though that decreasing them may need the number of stages that is | 52 // be aware though that decreasing them may need the number of stages that is |
52 // passed to get_vlc* to be increased. | 53 // passed to get_vlc* to be increased. |
53 #define INTRA_MCBPC_VLC_BITS 6 | |
54 #define INTER_MCBPC_VLC_BITS 7 | |
55 #define CBPY_VLC_BITS 6 | |
56 #define MV_VLC_BITS 9 | 54 #define MV_VLC_BITS 9 |
57 #define DC_VLC_BITS 9 | |
58 #define SPRITE_TRAJ_VLC_BITS 6 | |
59 #define MB_TYPE_B_VLC_BITS 4 | |
60 #define TEX_VLC_BITS 9 | |
61 #define H263_MBTYPE_B_VLC_BITS 6 | 55 #define H263_MBTYPE_B_VLC_BITS 6 |
62 #define CBPC_B_VLC_BITS 3 | 56 #define CBPC_B_VLC_BITS 3 |
63 | 57 |
58 | |
64 #if CONFIG_ENCODERS | 59 #if CONFIG_ENCODERS |
65 //The uni_DCtab_* tables below contain unified bits+length tables to encode DC | |
66 //differences in mpeg4. Unified in the sense that the specification specifies | |
67 //this encoding in several steps. | |
68 static uint8_t uni_DCtab_lum_len[512]; | |
69 static uint8_t uni_DCtab_chrom_len[512]; | |
70 static uint16_t uni_DCtab_lum_bits[512]; | |
71 static uint16_t uni_DCtab_chrom_bits[512]; | |
72 | |
73 /** | 60 /** |
74 * Table of number of bits a motion vector component needs. | 61 * Table of number of bits a motion vector component needs. |
75 */ | 62 */ |
76 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; | 63 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
77 | 64 |
86 */ | 73 */ |
87 static uint8_t umv_fcode_tab[MAX_MV*2+1]; | 74 static uint8_t umv_fcode_tab[MAX_MV*2+1]; |
88 | 75 |
89 //unified encoding tables for run length encoding of coefficients | 76 //unified encoding tables for run length encoding of coefficients |
90 //unified in the sense that the specification specifies the encoding in several steps. | 77 //unified in the sense that the specification specifies the encoding in several steps. |
91 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; | |
92 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
93 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
94 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
95 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; | 78 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
96 static uint8_t uni_h263_inter_rl_len [64*64*2*2]; | 79 static uint8_t uni_h263_inter_rl_len [64*64*2*2]; |
97 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level)) | 80 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level)) |
98 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) | 81 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
99 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) | 82 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) |
100 | 83 |
101 /* mpeg4 | |
102 inter | |
103 max level: 24/6 | |
104 max run: 53/63 | |
105 | |
106 intra | |
107 max level: 53/16 | |
108 max run: 29/41 | |
109 */ | |
110 #endif | 84 #endif |
111 | 85 |
112 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3]; | 86 static uint8_t static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3]; |
113 | 87 |
114 #if 0 //3IV1 is quite rare and it slows things down a tiny bit | |
115 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1") | |
116 #else | |
117 #define IS_3IV1 0 | |
118 #endif | |
119 | 88 |
120 int h263_get_picture_format(int width, int height) | 89 int h263_get_picture_format(int width, int height) |
121 { | 90 { |
122 if (width == 128 && height == 96) | 91 if (width == 128 && height == 96) |
123 return 1; | 92 return 1; |
157 /** | 126 /** |
158 * Returns the 4 bit value that specifies the given aspect ratio. | 127 * Returns the 4 bit value that specifies the given aspect ratio. |
159 * This may be one of the standard aspect ratios or it specifies | 128 * This may be one of the standard aspect ratios or it specifies |
160 * that the aspect will be stored explicitly later. | 129 * that the aspect will be stored explicitly later. |
161 */ | 130 */ |
162 static av_const int aspect_to_info(AVRational aspect){ | 131 av_const int ff_h263_aspect_to_info(AVRational aspect){ |
163 int i; | 132 int i; |
164 | 133 |
165 if(aspect.num==0) aspect= (AVRational){1,1}; | 134 if(aspect.num==0) aspect= (AVRational){1,1}; |
166 | 135 |
167 for(i=1; i<6; i++){ | 136 for(i=1; i<6; i++){ |
168 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ | 137 if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){ |
169 return i; | 138 return i; |
170 } | 139 } |
171 } | 140 } |
172 | 141 |
173 return FF_ASPECT_EXTENDED; | 142 return FF_ASPECT_EXTENDED; |
263 /* This should be here if PLUSPTYPE */ | 232 /* This should be here if PLUSPTYPE */ |
264 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | 233 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
265 | 234 |
266 if (format == 7) { | 235 if (format == 7) { |
267 /* Custom Picture Format (CPFMT) */ | 236 /* Custom Picture Format (CPFMT) */ |
268 s->aspect_ratio_info= aspect_to_info(s->avctx->sample_aspect_ratio); | 237 s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio); |
269 | 238 |
270 put_bits(&s->pb,4,s->aspect_ratio_info); | 239 put_bits(&s->pb,4,s->aspect_ratio_info); |
271 put_bits(&s->pb,9,(s->width >> 2) - 1); | 240 put_bits(&s->pb,9,(s->width >> 2) - 1); |
272 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | 241 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
273 put_bits(&s->pb,9,(s->height >> 2)); | 242 put_bits(&s->pb,9,(s->height >> 2)); |
340 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | 309 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
341 } | 310 } |
342 } | 311 } |
343 | 312 |
344 /** | 313 /** |
345 * Returns the number of bits that encoding the 8x8 block in block would need. | |
346 * @param[in] block_last_index last index in scantable order that refers to a non zero element in block. | |
347 */ | |
348 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ | |
349 int last=0; | |
350 int j; | |
351 int rate=0; | |
352 | |
353 for(j=1; j<=block_last_index; j++){ | |
354 const int index= scantable[j]; | |
355 int level= block[index]; | |
356 if(level){ | |
357 level+= 64; | |
358 if((level&(~127)) == 0){ | |
359 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; | |
360 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; | |
361 }else | |
362 rate += s->ac_esc_length; | |
363 | |
364 last= j; | |
365 } | |
366 } | |
367 | |
368 return rate; | |
369 } | |
370 | |
371 | |
372 /** | |
373 * Restores the ac coefficients in block that have been changed by decide_ac_pred(). | |
374 * This function also restores s->block_last_index. | |
375 * @param[in,out] block MB coefficients, these will be restored | |
376 * @param[in] dir ac prediction direction for each 8x8 block | |
377 * @param[out] st scantable for each 8x8 block | |
378 * @param[in] zigzag_last_index index refering to the last non zero coefficient in zigzag order | |
379 */ | |
380 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], const int dir[6], uint8_t *st[6], const int zigzag_last_index[6]) | |
381 { | |
382 int i, n; | |
383 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); | |
384 | |
385 for(n=0; n<6; n++){ | |
386 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
387 | |
388 st[n]= s->intra_scantable.permutated; | |
389 if(dir[n]){ | |
390 /* top prediction */ | |
391 for(i=1; i<8; i++){ | |
392 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; | |
393 } | |
394 }else{ | |
395 /* left prediction */ | |
396 for(i=1; i<8; i++){ | |
397 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; | |
398 } | |
399 } | |
400 } | |
401 } | |
402 | |
403 /** | |
404 * Returns the optimal value (0 or 1) for the ac_pred element for the given MB in mpeg4. | |
405 * This function will also update s->block_last_index and s->ac_val. | |
406 * @param[in,out] block MB coefficients, these will be updated if 1 is returned | |
407 * @param[in] dir ac prediction direction for each 8x8 block | |
408 * @param[out] st scantable for each 8x8 block | |
409 * @param[out] zigzag_last_index index refering to the last non zero coefficient in zigzag order | |
410 */ | |
411 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], const int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
412 { | |
413 int score= 0; | |
414 int i, n; | |
415 int8_t * const qscale_table= s->current_picture.qscale_table; | |
416 | |
417 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); | |
418 | |
419 for(n=0; n<6; n++){ | |
420 int16_t *ac_val, *ac_val1; | |
421 | |
422 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated); | |
423 | |
424 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
425 ac_val1= ac_val; | |
426 if(dir[n]){ | |
427 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; | |
428 /* top prediction */ | |
429 ac_val-= s->block_wrap[n]*16; | |
430 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ | |
431 /* same qscale */ | |
432 for(i=1; i<8; i++){ | |
433 const int level= block[n][s->dsp.idct_permutation[i ]]; | |
434 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; | |
435 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; | |
436 ac_val1[i+8]= level; | |
437 } | |
438 }else{ | |
439 /* different qscale, we must rescale */ | |
440 for(i=1; i<8; i++){ | |
441 const int level= block[n][s->dsp.idct_permutation[i ]]; | |
442 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); | |
443 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; | |
444 ac_val1[i+8]= level; | |
445 } | |
446 } | |
447 st[n]= s->intra_h_scantable.permutated; | |
448 }else{ | |
449 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; | |
450 /* left prediction */ | |
451 ac_val-= 16; | |
452 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ | |
453 /* same qscale */ | |
454 for(i=1; i<8; i++){ | |
455 const int level= block[n][s->dsp.idct_permutation[i<<3]]; | |
456 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i]; | |
457 ac_val1[i ]= level; | |
458 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; | |
459 } | |
460 }else{ | |
461 /* different qscale, we must rescale */ | |
462 for(i=1; i<8; i++){ | |
463 const int level= block[n][s->dsp.idct_permutation[i<<3]]; | |
464 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); | |
465 ac_val1[i ]= level; | |
466 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; | |
467 } | |
468 } | |
469 st[n]= s->intra_v_scantable.permutated; | |
470 } | |
471 | |
472 for(i=63; i>0; i--) //FIXME optimize | |
473 if(block[n][ st[n][i] ]) break; | |
474 s->block_last_index[n]= i; | |
475 | |
476 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); | |
477 } | |
478 | |
479 if(score < 0){ | |
480 return 1; | |
481 }else{ | |
482 restore_ac_coeffs(s, block, dir, st, zigzag_last_index); | |
483 return 0; | |
484 } | |
485 } | |
486 | |
487 /** | |
488 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2) | 314 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2) |
489 */ | 315 */ |
490 void ff_clean_h263_qscales(MpegEncContext *s){ | 316 void ff_clean_h263_qscales(MpegEncContext *s){ |
491 int i; | 317 int i; |
492 int8_t * const qscale_table= s->current_picture.qscale_table; | 318 int8_t * const qscale_table= s->current_picture.qscale_table; |
511 } | 337 } |
512 } | 338 } |
513 } | 339 } |
514 } | 340 } |
515 | 341 |
516 /** | |
517 * modify mb_type & qscale so that encoding is acually possible in mpeg4 | |
518 */ | |
519 void ff_clean_mpeg4_qscales(MpegEncContext *s){ | |
520 int i; | |
521 int8_t * const qscale_table= s->current_picture.qscale_table; | |
522 | |
523 ff_clean_h263_qscales(s); | |
524 | |
525 if(s->pict_type== FF_B_TYPE){ | |
526 int odd=0; | |
527 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */ | |
528 | |
529 for(i=0; i<s->mb_num; i++){ | |
530 int mb_xy= s->mb_index2xy[i]; | |
531 odd += qscale_table[mb_xy]&1; | |
532 } | |
533 | |
534 if(2*odd > s->mb_num) odd=1; | |
535 else odd=0; | |
536 | |
537 for(i=0; i<s->mb_num; i++){ | |
538 int mb_xy= s->mb_index2xy[i]; | |
539 if((qscale_table[mb_xy]&1) != odd) | |
540 qscale_table[mb_xy]++; | |
541 if(qscale_table[mb_xy] > 31) | |
542 qscale_table[mb_xy]= 31; | |
543 } | |
544 | |
545 for(i=1; i<s->mb_num; i++){ | |
546 int mb_xy= s->mb_index2xy[i]; | |
547 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ | |
548 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; | |
549 } | |
550 } | |
551 } | |
552 } | |
553 | |
554 #endif //CONFIG_ENCODERS | 342 #endif //CONFIG_ENCODERS |
555 | 343 |
556 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0])) | 344 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0])) |
557 #define tab_bias (tab_size/2) | 345 #define tab_bias (tab_size/2) |
558 | 346 |
347 //used by mpeg4 and rv10 decoder | |
559 void ff_mpeg4_init_direct_mv(MpegEncContext *s){ | 348 void ff_mpeg4_init_direct_mv(MpegEncContext *s){ |
560 int i; | 349 int i; |
561 for(i=0; i<tab_size; i++){ | 350 for(i=0; i<tab_size; i++){ |
562 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; | 351 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; |
563 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; | 352 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; |
700 else | 489 else |
701 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | 490 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; |
702 } | 491 } |
703 } | 492 } |
704 | 493 |
705 /** | |
706 * predicts the dc. | |
707 * encoding quantized level -> quantized diff | |
708 * decoding quantized diff -> quantized level | |
709 * @param n block index (0-3 are luma, 4-5 are chroma) | |
710 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
711 */ | |
712 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) | |
713 { | |
714 int a, b, c, wrap, pred, scale, ret; | |
715 int16_t *dc_val; | |
716 | |
717 /* find prediction */ | |
718 if (n < 4) { | |
719 scale = s->y_dc_scale; | |
720 } else { | |
721 scale = s->c_dc_scale; | |
722 } | |
723 if(IS_3IV1) | |
724 scale= 8; | |
725 | |
726 wrap= s->block_wrap[n]; | |
727 dc_val = s->dc_val[0] + s->block_index[n]; | |
728 | |
729 /* B C | |
730 * A X | |
731 */ | |
732 a = dc_val[ - 1]; | |
733 b = dc_val[ - 1 - wrap]; | |
734 c = dc_val[ - wrap]; | |
735 | |
736 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */ | |
737 if(s->first_slice_line && n!=3){ | |
738 if(n!=2) b=c= 1024; | |
739 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024; | |
740 } | |
741 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){ | |
742 if(n==0 || n==4 || n==5) | |
743 b=1024; | |
744 } | |
745 | |
746 if (abs(a - b) < abs(b - c)) { | |
747 pred = c; | |
748 *dir_ptr = 1; /* top */ | |
749 } else { | |
750 pred = a; | |
751 *dir_ptr = 0; /* left */ | |
752 } | |
753 /* we assume pred is positive */ | |
754 pred = FASTDIV((pred + (scale >> 1)), scale); | |
755 | |
756 if(encoding){ | |
757 ret = level - pred; | |
758 }else{ | |
759 level += pred; | |
760 ret= level; | |
761 if(s->error_recognition>=3){ | |
762 if(level<0){ | |
763 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
764 return -1; | |
765 } | |
766 if(level*scale > 2048 + scale){ | |
767 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
768 return -1; | |
769 } | |
770 } | |
771 } | |
772 level *=scale; | |
773 if(level&(~2047)){ | |
774 if(level<0) | |
775 level=0; | |
776 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) | |
777 level=2047; | |
778 } | |
779 dc_val[0]= level; | |
780 | |
781 return ret; | |
782 } | |
783 | |
784 #if CONFIG_ENCODERS | 494 #if CONFIG_ENCODERS |
785 | 495 |
786 /** | |
787 * encodes the dc value. | |
788 * @param n block index (0-3 are luma, 4-5 are chroma) | |
789 */ | |
790 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) | |
791 { | |
792 #if 1 | |
793 level+=256; | |
794 if (n < 4) { | |
795 /* luminance */ | |
796 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); | |
797 } else { | |
798 /* chrominance */ | |
799 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); | |
800 } | |
801 #else | |
802 int size, v; | |
803 /* find number of bits */ | |
804 size = 0; | |
805 v = abs(level); | |
806 while (v) { | |
807 v >>= 1; | |
808 size++; | |
809 } | |
810 | |
811 if (n < 4) { | |
812 /* luminance */ | |
813 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
814 } else { | |
815 /* chrominance */ | |
816 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
817 } | |
818 | |
819 /* encode remaining bits */ | |
820 if (size > 0) { | |
821 if (level < 0) | |
822 level = (-level) ^ ((1 << size) - 1); | |
823 put_bits(&s->pb, size, level); | |
824 if (size > 8) | |
825 put_bits(&s->pb, 1, 1); | |
826 } | |
827 #endif | |
828 } | |
829 | |
830 static inline int mpeg4_get_dc_length(int level, int n){ | |
831 if (n < 4) { | |
832 return uni_DCtab_lum_len[level + 256]; | |
833 } else { | |
834 return uni_DCtab_chrom_len[level + 256]; | |
835 } | |
836 } | |
837 | |
838 /** | |
839 * encodes a 8x8 block | |
840 * @param n block index (0-3 are luma, 4-5 are chroma) | |
841 */ | |
842 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, | |
843 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) | |
844 { | |
845 int i, last_non_zero; | |
846 #if 0 //variables for the outcommented version | |
847 int code, sign, last; | |
848 #endif | |
849 const RLTable *rl; | |
850 uint32_t *bits_tab; | |
851 uint8_t *len_tab; | |
852 const int last_index = s->block_last_index[n]; | |
853 | |
854 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
855 /* mpeg4 based DC predictor */ | |
856 mpeg4_encode_dc(dc_pb, intra_dc, n); | |
857 if(last_index<1) return; | |
858 i = 1; | |
859 rl = &rl_intra; | |
860 bits_tab= uni_mpeg4_intra_rl_bits; | |
861 len_tab = uni_mpeg4_intra_rl_len; | |
862 } else { | |
863 if(last_index<0) return; | |
864 i = 0; | |
865 rl = &rl_inter; | |
866 bits_tab= uni_mpeg4_inter_rl_bits; | |
867 len_tab = uni_mpeg4_inter_rl_len; | |
868 } | |
869 | |
870 /* AC coefs */ | |
871 last_non_zero = i - 1; | |
872 #if 1 | |
873 for (; i < last_index; i++) { | |
874 int level = block[ scan_table[i] ]; | |
875 if (level) { | |
876 int run = i - last_non_zero - 1; | |
877 level+=64; | |
878 if((level&(~127)) == 0){ | |
879 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
880 put_bits(ac_pb, len_tab[index], bits_tab[index]); | |
881 }else{ //ESC3 | |
882 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); | |
883 } | |
884 last_non_zero = i; | |
885 } | |
886 } | |
887 /*if(i<=last_index)*/{ | |
888 int level = block[ scan_table[i] ]; | |
889 int run = i - last_non_zero - 1; | |
890 level+=64; | |
891 if((level&(~127)) == 0){ | |
892 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
893 put_bits(ac_pb, len_tab[index], bits_tab[index]); | |
894 }else{ //ESC3 | |
895 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); | |
896 } | |
897 } | |
898 #else | |
899 for (; i <= last_index; i++) { | |
900 const int slevel = block[ scan_table[i] ]; | |
901 if (slevel) { | |
902 int level; | |
903 int run = i - last_non_zero - 1; | |
904 last = (i == last_index); | |
905 sign = 0; | |
906 level = slevel; | |
907 if (level < 0) { | |
908 sign = 1; | |
909 level = -level; | |
910 } | |
911 code = get_rl_index(rl, last, run, level); | |
912 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
913 if (code == rl->n) { | |
914 int level1, run1; | |
915 level1 = level - rl->max_level[last][run]; | |
916 if (level1 < 1) | |
917 goto esc2; | |
918 code = get_rl_index(rl, last, run, level1); | |
919 if (code == rl->n) { | |
920 esc2: | |
921 put_bits(ac_pb, 1, 1); | |
922 if (level > MAX_LEVEL) | |
923 goto esc3; | |
924 run1 = run - rl->max_run[last][level] - 1; | |
925 if (run1 < 0) | |
926 goto esc3; | |
927 code = get_rl_index(rl, last, run1, level); | |
928 if (code == rl->n) { | |
929 esc3: | |
930 /* third escape */ | |
931 put_bits(ac_pb, 1, 1); | |
932 put_bits(ac_pb, 1, last); | |
933 put_bits(ac_pb, 6, run); | |
934 put_bits(ac_pb, 1, 1); | |
935 put_sbits(ac_pb, 12, slevel); | |
936 put_bits(ac_pb, 1, 1); | |
937 } else { | |
938 /* second escape */ | |
939 put_bits(ac_pb, 1, 0); | |
940 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
941 put_bits(ac_pb, 1, sign); | |
942 } | |
943 } else { | |
944 /* first escape */ | |
945 put_bits(ac_pb, 1, 0); | |
946 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
947 put_bits(ac_pb, 1, sign); | |
948 } | |
949 } else { | |
950 put_bits(ac_pb, 1, sign); | |
951 } | |
952 last_non_zero = i; | |
953 } | |
954 } | |
955 #endif | |
956 } | |
957 | |
958 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, | |
959 uint8_t *scan_table) | |
960 { | |
961 int i, last_non_zero; | |
962 uint8_t *len_tab; | |
963 const int last_index = s->block_last_index[n]; | |
964 int len=0; | |
965 | |
966 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
967 /* mpeg4 based DC predictor */ | |
968 len += mpeg4_get_dc_length(intra_dc, n); | |
969 if(last_index<1) return len; | |
970 i = 1; | |
971 len_tab = uni_mpeg4_intra_rl_len; | |
972 } else { | |
973 if(last_index<0) return 0; | |
974 i = 0; | |
975 len_tab = uni_mpeg4_inter_rl_len; | |
976 } | |
977 | |
978 /* AC coefs */ | |
979 last_non_zero = i - 1; | |
980 for (; i < last_index; i++) { | |
981 int level = block[ scan_table[i] ]; | |
982 if (level) { | |
983 int run = i - last_non_zero - 1; | |
984 level+=64; | |
985 if((level&(~127)) == 0){ | |
986 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
987 len += len_tab[index]; | |
988 }else{ //ESC3 | |
989 len += 7+2+1+6+1+12+1; | |
990 } | |
991 last_non_zero = i; | |
992 } | |
993 } | |
994 /*if(i<=last_index)*/{ | |
995 int level = block[ scan_table[i] ]; | |
996 int run = i - last_non_zero - 1; | |
997 level+=64; | |
998 if((level&(~127)) == 0){ | |
999 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
1000 len += len_tab[index]; | |
1001 }else{ //ESC3 | |
1002 len += 7+2+1+6+1+12+1; | |
1003 } | |
1004 } | |
1005 | |
1006 return len; | |
1007 } | |
1008 | |
1009 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ | |
1010 int l, bit_size, code; | |
1011 | |
1012 if (val == 0) { | |
1013 return mvtab[0][1]; | |
1014 } else { | |
1015 bit_size = f_code - 1; | |
1016 /* modulo encoding */ | |
1017 l= INT_BIT - 6 - bit_size; | |
1018 val = (val<<l)>>l; | |
1019 val--; | |
1020 code = (val >> bit_size) + 1; | |
1021 | |
1022 return mvtab[code][1] + 1 + bit_size; | |
1023 } | |
1024 } | |
1025 | |
1026 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ | |
1027 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
1028 skip_put_bits(&s->pb, | |
1029 h263_get_motion_length(s, x, f_code) | |
1030 +h263_get_motion_length(s, y, f_code)); | |
1031 }else{ | |
1032 ff_h263_encode_motion(s, x, f_code); | |
1033 ff_h263_encode_motion(s, y, f_code); | |
1034 } | |
1035 } | |
1036 | |
1037 static inline int get_p_cbp(MpegEncContext * s, | |
1038 DCTELEM block[6][64], | |
1039 int motion_x, int motion_y){ | |
1040 int cbp, i; | |
1041 | |
1042 if(s->flags & CODEC_FLAG_CBP_RD){ | |
1043 int best_cbpy_score= INT_MAX; | |
1044 int best_cbpc_score= INT_MAX; | |
1045 int cbpc = (-1), cbpy= (-1); | |
1046 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0); | |
1047 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); | |
1048 | |
1049 for(i=0; i<4; i++){ | |
1050 int score= inter_MCBPC_bits[i + offset] * lambda; | |
1051 if(i&1) score += s->coded_score[5]; | |
1052 if(i&2) score += s->coded_score[4]; | |
1053 | |
1054 if(score < best_cbpc_score){ | |
1055 best_cbpc_score= score; | |
1056 cbpc= i; | |
1057 } | |
1058 } | |
1059 | |
1060 for(i=0; i<16; i++){ | |
1061 int score= cbpy_tab[i ^ 0xF][1] * lambda; | |
1062 if(i&1) score += s->coded_score[3]; | |
1063 if(i&2) score += s->coded_score[2]; | |
1064 if(i&4) score += s->coded_score[1]; | |
1065 if(i&8) score += s->coded_score[0]; | |
1066 | |
1067 if(score < best_cbpy_score){ | |
1068 best_cbpy_score= score; | |
1069 cbpy= i; | |
1070 } | |
1071 } | |
1072 cbp= cbpc + 4*cbpy; | |
1073 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){ | |
1074 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) | |
1075 cbp= 0; | |
1076 } | |
1077 | |
1078 for (i = 0; i < 6; i++) { | |
1079 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ | |
1080 s->block_last_index[i]= -1; | |
1081 s->dsp.clear_block(s->block[i]); | |
1082 } | |
1083 } | |
1084 }else{ | |
1085 cbp= 0; | |
1086 for (i = 0; i < 6; i++) { | |
1087 if (s->block_last_index[i] >= 0) | |
1088 cbp |= 1 << (5 - i); | |
1089 } | |
1090 } | |
1091 return cbp; | |
1092 } | |
1093 | |
1094 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], | |
1095 int motion_x, int motion_y, int mb_type){ | |
1096 int cbp=0, i; | |
1097 | |
1098 if(s->flags & CODEC_FLAG_CBP_RD){ | |
1099 int score=0; | |
1100 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); | |
1101 | |
1102 for(i=0; i<6; i++){ | |
1103 if(s->coded_score[i] < 0){ | |
1104 score += s->coded_score[i]; | |
1105 cbp |= 1 << (5 - i); | |
1106 } | |
1107 } | |
1108 | |
1109 if(cbp){ | |
1110 int zero_score= -6; | |
1111 if ((motion_x | motion_y | s->dquant | mb_type) == 0){ | |
1112 zero_score-= 4; //2*MV + mb_type + cbp bit | |
1113 } | |
1114 | |
1115 zero_score*= lambda; | |
1116 if(zero_score <= score){ | |
1117 cbp=0; | |
1118 } | |
1119 } | |
1120 | |
1121 for (i = 0; i < 6; i++) { | |
1122 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ | |
1123 s->block_last_index[i]= -1; | |
1124 s->dsp.clear_block(s->block[i]); | |
1125 } | |
1126 } | |
1127 }else{ | |
1128 for (i = 0; i < 6; i++) { | |
1129 if (s->block_last_index[i] >= 0) | |
1130 cbp |= 1 << (5 - i); | |
1131 } | |
1132 } | |
1133 return cbp; | |
1134 } | |
1135 | |
1136 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], | |
1137 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){ | |
1138 int i; | |
1139 | |
1140 if(scan_table){ | |
1141 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
1142 for (i = 0; i < 6; i++) { | |
1143 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); | |
1144 } | |
1145 }else{ | |
1146 /* encode each block */ | |
1147 for (i = 0; i < 6; i++) { | |
1148 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); | |
1149 } | |
1150 } | |
1151 }else{ | |
1152 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
1153 for (i = 0; i < 6; i++) { | |
1154 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated)); | |
1155 } | |
1156 }else{ | |
1157 /* encode each block */ | |
1158 for (i = 0; i < 6; i++) { | |
1159 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb); | |
1160 } | |
1161 } | |
1162 } | |
1163 } | |
1164 | |
1165 static const int dquant_code[5]= {1,0,9,2,3}; | 496 static const int dquant_code[5]= {1,0,9,2,3}; |
1166 | |
1167 void mpeg4_encode_mb(MpegEncContext * s, | |
1168 DCTELEM block[6][64], | |
1169 int motion_x, int motion_y) | |
1170 { | |
1171 int cbpc, cbpy, pred_x, pred_y; | |
1172 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; | |
1173 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb; | |
1174 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2 : &s->pb; | |
1175 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; | |
1176 | |
1177 if (!s->mb_intra) { | |
1178 int i, cbp; | |
1179 | |
1180 if(s->pict_type==FF_B_TYPE){ | |
1181 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ | |
1182 int mb_type= mb_type_table[s->mv_dir]; | |
1183 | |
1184 if(s->mb_x==0){ | |
1185 for(i=0; i<2; i++){ | |
1186 s->last_mv[i][0][0]= | |
1187 s->last_mv[i][0][1]= | |
1188 s->last_mv[i][1][0]= | |
1189 s->last_mv[i][1][1]= 0; | |
1190 } | |
1191 } | |
1192 | |
1193 assert(s->dquant>=-2 && s->dquant<=2); | |
1194 assert((s->dquant&1)==0); | |
1195 assert(mb_type>=0); | |
1196 | |
1197 /* nothing to do if this MB was skipped in the next P Frame */ | |
1198 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... | |
1199 s->skip_count++; | |
1200 s->mv[0][0][0]= | |
1201 s->mv[0][0][1]= | |
1202 s->mv[1][0][0]= | |
1203 s->mv[1][0][1]= 0; | |
1204 s->mv_dir= MV_DIR_FORWARD; //doesn't matter | |
1205 s->qscale -= s->dquant; | |
1206 // s->mb_skipped=1; | |
1207 | |
1208 return; | |
1209 } | |
1210 | |
1211 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); | |
1212 | |
1213 if ((cbp | motion_x | motion_y | mb_type) ==0) { | |
1214 /* direct MB with MV={0,0} */ | |
1215 assert(s->dquant==0); | |
1216 | |
1217 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ | |
1218 | |
1219 if(interleaved_stats){ | |
1220 s->misc_bits++; | |
1221 s->last_bits++; | |
1222 } | |
1223 s->skip_count++; | |
1224 return; | |
1225 } | |
1226 | |
1227 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ | |
1228 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge | |
1229 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) | |
1230 if(cbp) put_bits(&s->pb, 6, cbp); | |
1231 | |
1232 if(cbp && mb_type){ | |
1233 if(s->dquant) | |
1234 put_bits(&s->pb, 2, (s->dquant>>2)+3); | |
1235 else | |
1236 put_bits(&s->pb, 1, 0); | |
1237 }else | |
1238 s->qscale -= s->dquant; | |
1239 | |
1240 if(!s->progressive_sequence){ | |
1241 if(cbp) | |
1242 put_bits(&s->pb, 1, s->interlaced_dct); | |
1243 if(mb_type) // not direct mode | |
1244 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD); | |
1245 } | |
1246 | |
1247 if(interleaved_stats){ | |
1248 s->misc_bits+= get_bits_diff(s); | |
1249 } | |
1250 | |
1251 if(mb_type == 0){ | |
1252 assert(s->mv_dir & MV_DIRECT); | |
1253 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1); | |
1254 s->b_count++; | |
1255 s->f_count++; | |
1256 }else{ | |
1257 assert(mb_type > 0 && mb_type < 4); | |
1258 if(s->mv_type != MV_TYPE_FIELD){ | |
1259 if(s->mv_dir & MV_DIR_FORWARD){ | |
1260 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], | |
1261 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
1262 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; | |
1263 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; | |
1264 s->f_count++; | |
1265 } | |
1266 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1267 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], | |
1268 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
1269 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; | |
1270 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; | |
1271 s->b_count++; | |
1272 } | |
1273 }else{ | |
1274 if(s->mv_dir & MV_DIR_FORWARD){ | |
1275 put_bits(&s->pb, 1, s->field_select[0][0]); | |
1276 put_bits(&s->pb, 1, s->field_select[0][1]); | |
1277 } | |
1278 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1279 put_bits(&s->pb, 1, s->field_select[1][0]); | |
1280 put_bits(&s->pb, 1, s->field_select[1][1]); | |
1281 } | |
1282 if(s->mv_dir & MV_DIR_FORWARD){ | |
1283 for(i=0; i<2; i++){ | |
1284 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , | |
1285 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); | |
1286 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
1287 s->last_mv[0][i][1]= s->mv[0][i][1]*2; | |
1288 } | |
1289 s->f_count++; | |
1290 } | |
1291 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1292 for(i=0; i<2; i++){ | |
1293 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , | |
1294 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); | |
1295 s->last_mv[1][i][0]= s->mv[1][i][0]; | |
1296 s->last_mv[1][i][1]= s->mv[1][i][1]*2; | |
1297 } | |
1298 s->b_count++; | |
1299 } | |
1300 } | |
1301 } | |
1302 | |
1303 if(interleaved_stats){ | |
1304 s->mv_bits+= get_bits_diff(s); | |
1305 } | |
1306 | |
1307 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); | |
1308 | |
1309 if(interleaved_stats){ | |
1310 s->p_tex_bits+= get_bits_diff(s); | |
1311 } | |
1312 | |
1313 }else{ /* s->pict_type==FF_B_TYPE */ | |
1314 cbp= get_p_cbp(s, block, motion_x, motion_y); | |
1315 | |
1316 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { | |
1317 /* check if the B frames can skip it too, as we must skip it if we skip here | |
1318 why didn't they just compress the skip-mb bits instead of reusing them ?! */ | |
1319 if(s->max_b_frames>0){ | |
1320 int i; | |
1321 int x,y, offset; | |
1322 uint8_t *p_pic; | |
1323 | |
1324 x= s->mb_x*16; | |
1325 y= s->mb_y*16; | |
1326 if(x+16 > s->width) x= s->width-16; | |
1327 if(y+16 > s->height) y= s->height-16; | |
1328 | |
1329 offset= x + y*s->linesize; | |
1330 p_pic= s->new_picture.data[0] + offset; | |
1331 | |
1332 s->mb_skipped=1; | |
1333 for(i=0; i<s->max_b_frames; i++){ | |
1334 uint8_t *b_pic; | |
1335 int diff; | |
1336 Picture *pic= s->reordered_input_picture[i+1]; | |
1337 | |
1338 if(pic==NULL || pic->pict_type!=FF_B_TYPE) break; | |
1339 | |
1340 b_pic= pic->data[0] + offset; | |
1341 if(pic->type != FF_BUFFER_TYPE_SHARED) | |
1342 b_pic+= INPLACE_OFFSET; | |
1343 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); | |
1344 if(diff>s->qscale*70){ //FIXME check that 70 is optimal | |
1345 s->mb_skipped=0; | |
1346 break; | |
1347 } | |
1348 } | |
1349 }else | |
1350 s->mb_skipped=1; | |
1351 | |
1352 if(s->mb_skipped==1){ | |
1353 /* skip macroblock */ | |
1354 put_bits(&s->pb, 1, 1); | |
1355 | |
1356 if(interleaved_stats){ | |
1357 s->misc_bits++; | |
1358 s->last_bits++; | |
1359 } | |
1360 s->skip_count++; | |
1361 | |
1362 return; | |
1363 } | |
1364 } | |
1365 | |
1366 put_bits(&s->pb, 1, 0); /* mb coded */ | |
1367 cbpc = cbp & 3; | |
1368 cbpy = cbp >> 2; | |
1369 cbpy ^= 0xf; | |
1370 if(s->mv_type==MV_TYPE_16X16){ | |
1371 if(s->dquant) cbpc+= 8; | |
1372 put_bits(&s->pb, | |
1373 inter_MCBPC_bits[cbpc], | |
1374 inter_MCBPC_code[cbpc]); | |
1375 | |
1376 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1377 if(s->dquant) | |
1378 put_bits(pb2, 2, dquant_code[s->dquant+2]); | |
1379 | |
1380 if(!s->progressive_sequence){ | |
1381 if(cbp) | |
1382 put_bits(pb2, 1, s->interlaced_dct); | |
1383 put_bits(pb2, 1, 0); | |
1384 } | |
1385 | |
1386 if(interleaved_stats){ | |
1387 s->misc_bits+= get_bits_diff(s); | |
1388 } | |
1389 | |
1390 /* motion vectors: 16x16 mode */ | |
1391 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); | |
1392 | |
1393 ff_h263_encode_motion_vector(s, motion_x - pred_x, | |
1394 motion_y - pred_y, s->f_code); | |
1395 }else if(s->mv_type==MV_TYPE_FIELD){ | |
1396 if(s->dquant) cbpc+= 8; | |
1397 put_bits(&s->pb, | |
1398 inter_MCBPC_bits[cbpc], | |
1399 inter_MCBPC_code[cbpc]); | |
1400 | |
1401 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1402 if(s->dquant) | |
1403 put_bits(pb2, 2, dquant_code[s->dquant+2]); | |
1404 | |
1405 assert(!s->progressive_sequence); | |
1406 if(cbp) | |
1407 put_bits(pb2, 1, s->interlaced_dct); | |
1408 put_bits(pb2, 1, 1); | |
1409 | |
1410 if(interleaved_stats){ | |
1411 s->misc_bits+= get_bits_diff(s); | |
1412 } | |
1413 | |
1414 /* motion vectors: 16x8 interlaced mode */ | |
1415 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); | |
1416 pred_y /=2; | |
1417 | |
1418 put_bits(&s->pb, 1, s->field_select[0][0]); | |
1419 put_bits(&s->pb, 1, s->field_select[0][1]); | |
1420 | |
1421 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, | |
1422 s->mv[0][0][1] - pred_y, s->f_code); | |
1423 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, | |
1424 s->mv[0][1][1] - pred_y, s->f_code); | |
1425 }else{ | |
1426 assert(s->mv_type==MV_TYPE_8X8); | |
1427 put_bits(&s->pb, | |
1428 inter_MCBPC_bits[cbpc+16], | |
1429 inter_MCBPC_code[cbpc+16]); | |
1430 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1431 | |
1432 if(!s->progressive_sequence){ | |
1433 if(cbp) | |
1434 put_bits(pb2, 1, s->interlaced_dct); | |
1435 } | |
1436 | |
1437 if(interleaved_stats){ | |
1438 s->misc_bits+= get_bits_diff(s); | |
1439 } | |
1440 | |
1441 for(i=0; i<4; i++){ | |
1442 /* motion vectors: 8x8 mode*/ | |
1443 h263_pred_motion(s, i, 0, &pred_x, &pred_y); | |
1444 | |
1445 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, | |
1446 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); | |
1447 } | |
1448 } | |
1449 | |
1450 if(interleaved_stats){ | |
1451 s->mv_bits+= get_bits_diff(s); | |
1452 } | |
1453 | |
1454 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); | |
1455 | |
1456 if(interleaved_stats){ | |
1457 s->p_tex_bits+= get_bits_diff(s); | |
1458 } | |
1459 s->f_count++; | |
1460 } | |
1461 } else { | |
1462 int cbp; | |
1463 int dc_diff[6]; //dc values with the dc prediction subtracted | |
1464 int dir[6]; //prediction direction | |
1465 int zigzag_last_index[6]; | |
1466 uint8_t *scan_table[6]; | |
1467 int i; | |
1468 | |
1469 for(i=0; i<6; i++){ | |
1470 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); | |
1471 } | |
1472 | |
1473 if(s->flags & CODEC_FLAG_AC_PRED){ | |
1474 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | |
1475 }else{ | |
1476 for(i=0; i<6; i++) | |
1477 scan_table[i]= s->intra_scantable.permutated; | |
1478 } | |
1479 | |
1480 /* compute cbp */ | |
1481 cbp = 0; | |
1482 for (i = 0; i < 6; i++) { | |
1483 if (s->block_last_index[i] >= 1) | |
1484 cbp |= 1 << (5 - i); | |
1485 } | |
1486 | |
1487 cbpc = cbp & 3; | |
1488 if (s->pict_type == FF_I_TYPE) { | |
1489 if(s->dquant) cbpc+=4; | |
1490 put_bits(&s->pb, | |
1491 intra_MCBPC_bits[cbpc], | |
1492 intra_MCBPC_code[cbpc]); | |
1493 } else { | |
1494 if(s->dquant) cbpc+=8; | |
1495 put_bits(&s->pb, 1, 0); /* mb coded */ | |
1496 put_bits(&s->pb, | |
1497 inter_MCBPC_bits[cbpc + 4], | |
1498 inter_MCBPC_code[cbpc + 4]); | |
1499 } | |
1500 put_bits(pb2, 1, s->ac_pred); | |
1501 cbpy = cbp >> 2; | |
1502 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1503 if(s->dquant) | |
1504 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); | |
1505 | |
1506 if(!s->progressive_sequence){ | |
1507 put_bits(dc_pb, 1, s->interlaced_dct); | |
1508 } | |
1509 | |
1510 if(interleaved_stats){ | |
1511 s->misc_bits+= get_bits_diff(s); | |
1512 } | |
1513 | |
1514 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb); | |
1515 | |
1516 if(interleaved_stats){ | |
1517 s->i_tex_bits+= get_bits_diff(s); | |
1518 } | |
1519 s->i_count++; | |
1520 | |
1521 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ | |
1522 if(s->ac_pred) | |
1523 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | |
1524 } | |
1525 } | |
1526 | 497 |
1527 /** | 498 /** |
1528 * encodes a 8x8 block. | 499 * encodes a 8x8 block. |
1529 * @param block the 8x8 block | 500 * @param block the 8x8 block |
1530 * @param n block index (0-3 are luma, 4-5 are chroma) | 501 * @param n block index (0-3 are luma, 4-5 are chroma) |
2153 } | 1124 } |
2154 | 1125 |
2155 #if CONFIG_ENCODERS | 1126 #if CONFIG_ENCODERS |
2156 | 1127 |
2157 /***************************************************/ | 1128 /***************************************************/ |
2158 /** | |
2159 * add mpeg4 stuffing bits (01...1) | |
2160 */ | |
2161 void ff_mpeg4_stuffing(PutBitContext * pbc) | |
2162 { | |
2163 int length; | |
2164 put_bits(pbc, 1, 0); | |
2165 length= (-put_bits_count(pbc))&7; | |
2166 if(length) put_bits(pbc, length, (1<<length)-1); | |
2167 } | |
2168 | |
2169 /* must be called before writing the header */ | |
2170 void ff_set_mpeg4_time(MpegEncContext * s){ | |
2171 if(s->pict_type==FF_B_TYPE){ | |
2172 ff_mpeg4_init_direct_mv(s); | |
2173 }else{ | |
2174 s->last_time_base= s->time_base; | |
2175 s->time_base= s->time/s->avctx->time_base.den; | |
2176 } | |
2177 } | |
2178 | |
2179 static void mpeg4_encode_gop_header(MpegEncContext * s){ | |
2180 int hours, minutes, seconds; | |
2181 int64_t time; | |
2182 | |
2183 put_bits(&s->pb, 16, 0); | |
2184 put_bits(&s->pb, 16, GOP_STARTCODE); | |
2185 | |
2186 time= s->current_picture_ptr->pts; | |
2187 if(s->reordered_input_picture[1]) | |
2188 time= FFMIN(time, s->reordered_input_picture[1]->pts); | |
2189 time= time*s->avctx->time_base.num; | |
2190 | |
2191 seconds= time/s->avctx->time_base.den; | |
2192 minutes= seconds/60; seconds %= 60; | |
2193 hours= minutes/60; minutes %= 60; | |
2194 hours%=24; | |
2195 | |
2196 put_bits(&s->pb, 5, hours); | |
2197 put_bits(&s->pb, 6, minutes); | |
2198 put_bits(&s->pb, 1, 1); | |
2199 put_bits(&s->pb, 6, seconds); | |
2200 | |
2201 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); | |
2202 put_bits(&s->pb, 1, 0); //broken link == NO | |
2203 | |
2204 s->last_time_base= time / s->avctx->time_base.den; | |
2205 | |
2206 ff_mpeg4_stuffing(&s->pb); | |
2207 } | |
2208 | |
2209 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
2210 int profile_and_level_indication; | |
2211 int vo_ver_id; | |
2212 | |
2213 if(s->avctx->profile != FF_PROFILE_UNKNOWN){ | |
2214 profile_and_level_indication = s->avctx->profile << 4; | |
2215 }else if(s->max_b_frames || s->quarter_sample){ | |
2216 profile_and_level_indication= 0xF0; // adv simple | |
2217 }else{ | |
2218 profile_and_level_indication= 0x00; // simple | |
2219 } | |
2220 | |
2221 if(s->avctx->level != FF_LEVEL_UNKNOWN){ | |
2222 profile_and_level_indication |= s->avctx->level; | |
2223 }else{ | |
2224 profile_and_level_indication |= 1; //level 1 | |
2225 } | |
2226 | |
2227 if(profile_and_level_indication>>4 == 0xF){ | |
2228 vo_ver_id= 5; | |
2229 }else{ | |
2230 vo_ver_id= 1; | |
2231 } | |
2232 | |
2233 //FIXME levels | |
2234 | |
2235 put_bits(&s->pb, 16, 0); | |
2236 put_bits(&s->pb, 16, VOS_STARTCODE); | |
2237 | |
2238 put_bits(&s->pb, 8, profile_and_level_indication); | |
2239 | |
2240 put_bits(&s->pb, 16, 0); | |
2241 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
2242 | |
2243 put_bits(&s->pb, 1, 1); | |
2244 put_bits(&s->pb, 4, vo_ver_id); | |
2245 put_bits(&s->pb, 3, 1); //priority | |
2246 | |
2247 put_bits(&s->pb, 4, 1); //visual obj type== video obj | |
2248 | |
2249 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME | |
2250 | |
2251 ff_mpeg4_stuffing(&s->pb); | |
2252 } | |
2253 | |
2254 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
2255 { | |
2256 int vo_ver_id; | |
2257 | |
2258 if (!CONFIG_MPEG4_ENCODER) return; | |
2259 | |
2260 if(s->max_b_frames || s->quarter_sample){ | |
2261 vo_ver_id= 5; | |
2262 s->vo_type= ADV_SIMPLE_VO_TYPE; | |
2263 }else{ | |
2264 vo_ver_id= 1; | |
2265 s->vo_type= SIMPLE_VO_TYPE; | |
2266 } | |
2267 | |
2268 put_bits(&s->pb, 16, 0); | |
2269 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ | |
2270 put_bits(&s->pb, 16, 0); | |
2271 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ | |
2272 | |
2273 put_bits(&s->pb, 1, 0); /* random access vol */ | |
2274 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ | |
2275 if(s->workaround_bugs & FF_BUG_MS) { | |
2276 put_bits(&s->pb, 1, 0); /* is obj layer id= no */ | |
2277 } else { | |
2278 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ | |
2279 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
2280 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
2281 } | |
2282 | |
2283 s->aspect_ratio_info= aspect_to_info(s->avctx->sample_aspect_ratio); | |
2284 | |
2285 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
2286 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ | |
2287 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
2288 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
2289 } | |
2290 | |
2291 if(s->workaround_bugs & FF_BUG_MS) { // | |
2292 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ | |
2293 } else { | |
2294 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ | |
2295 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ | |
2296 put_bits(&s->pb, 1, s->low_delay); | |
2297 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ | |
2298 } | |
2299 | |
2300 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ | |
2301 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2302 | |
2303 put_bits(&s->pb, 16, s->avctx->time_base.den); | |
2304 if (s->time_increment_bits < 1) | |
2305 s->time_increment_bits = 1; | |
2306 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2307 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
2308 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2309 put_bits(&s->pb, 13, s->width); /* vol width */ | |
2310 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2311 put_bits(&s->pb, 13, s->height); /* vol height */ | |
2312 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2313 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); | |
2314 put_bits(&s->pb, 1, 1); /* obmc disable */ | |
2315 if (vo_ver_id == 1) { | |
2316 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ | |
2317 }else{ | |
2318 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ | |
2319 } | |
2320 | |
2321 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | |
2322 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | |
2323 | |
2324 if(s->mpeg_quant){ | |
2325 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
2326 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
2327 } | |
2328 | |
2329 if (vo_ver_id != 1) | |
2330 put_bits(&s->pb, 1, s->quarter_sample); | |
2331 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ | |
2332 s->resync_marker= s->rtp_mode; | |
2333 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
2334 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
2335 if(s->data_partitioning){ | |
2336 put_bits(&s->pb, 1, 0); /* no rvlc */ | |
2337 } | |
2338 | |
2339 if (vo_ver_id != 1){ | |
2340 put_bits(&s->pb, 1, 0); /* newpred */ | |
2341 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
2342 } | |
2343 put_bits(&s->pb, 1, 0); /* scalability */ | |
2344 | |
2345 ff_mpeg4_stuffing(&s->pb); | |
2346 | |
2347 /* user data */ | |
2348 if(!(s->flags & CODEC_FLAG_BITEXACT)){ | |
2349 put_bits(&s->pb, 16, 0); | |
2350 put_bits(&s->pb, 16, 0x1B2); /* user_data */ | |
2351 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); | |
2352 } | |
2353 } | |
2354 | |
2355 /* write mpeg4 VOP header */ | |
2356 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2357 { | |
2358 int time_incr; | |
2359 int time_div, time_mod; | |
2360 | |
2361 if(s->pict_type==FF_I_TYPE){ | |
2362 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ | |
2363 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy | |
2364 mpeg4_encode_visual_object_header(s); | |
2365 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy | |
2366 mpeg4_encode_vol_header(s, 0, 0); | |
2367 } | |
2368 if(!(s->workaround_bugs & FF_BUG_MS)) | |
2369 mpeg4_encode_gop_header(s); | |
2370 } | |
2371 | |
2372 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; | |
2373 | |
2374 put_bits(&s->pb, 16, 0); /* vop header */ | |
2375 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ | |
2376 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | |
2377 | |
2378 assert(s->time>=0); | |
2379 time_div= s->time/s->avctx->time_base.den; | |
2380 time_mod= s->time%s->avctx->time_base.den; | |
2381 time_incr= time_div - s->last_time_base; | |
2382 assert(time_incr >= 0); | |
2383 while(time_incr--) | |
2384 put_bits(&s->pb, 1, 1); | |
2385 | |
2386 put_bits(&s->pb, 1, 0); | |
2387 | |
2388 put_bits(&s->pb, 1, 1); /* marker */ | |
2389 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ | |
2390 put_bits(&s->pb, 1, 1); /* marker */ | |
2391 put_bits(&s->pb, 1, 1); /* vop coded */ | |
2392 if ( s->pict_type == FF_P_TYPE | |
2393 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
2394 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ | |
2395 } | |
2396 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
2397 if(!s->progressive_sequence){ | |
2398 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); | |
2399 put_bits(&s->pb, 1, s->alternate_scan); | |
2400 } | |
2401 //FIXME sprite stuff | |
2402 | |
2403 put_bits(&s->pb, 5, s->qscale); | |
2404 | |
2405 if (s->pict_type != FF_I_TYPE) | |
2406 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ | |
2407 if (s->pict_type == FF_B_TYPE) | |
2408 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ | |
2409 } | |
2410 | |
2411 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) | 1129 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
2412 { | 1130 { |
2413 int range, l, bit_size, sign, code, bits; | 1131 int range, l, bit_size, sign, code, bits; |
2414 | 1132 |
2415 if (val == 0) { | 1133 if (val == 0) { |
2477 for(mv=0; mv<MAX_MV*2+1; mv++){ | 1195 for(mv=0; mv<MAX_MV*2+1; mv++){ |
2478 umv_fcode_tab[mv]= 1; | 1196 umv_fcode_tab[mv]= 1; |
2479 } | 1197 } |
2480 } | 1198 } |
2481 | 1199 |
2482 static void init_uni_dc_tab(void) | |
2483 { | |
2484 int level, uni_code, uni_len; | |
2485 | |
2486 for(level=-256; level<256; level++){ | |
2487 int size, v, l; | |
2488 /* find number of bits */ | |
2489 size = 0; | |
2490 v = abs(level); | |
2491 while (v) { | |
2492 v >>= 1; | |
2493 size++; | |
2494 } | |
2495 | |
2496 if (level < 0) | |
2497 l= (-level) ^ ((1 << size) - 1); | |
2498 else | |
2499 l= level; | |
2500 | |
2501 /* luminance */ | |
2502 uni_code= DCtab_lum[size][0]; | |
2503 uni_len = DCtab_lum[size][1]; | |
2504 | |
2505 if (size > 0) { | |
2506 uni_code<<=size; uni_code|=l; | |
2507 uni_len+=size; | |
2508 if (size > 8){ | |
2509 uni_code<<=1; uni_code|=1; | |
2510 uni_len++; | |
2511 } | |
2512 } | |
2513 uni_DCtab_lum_bits[level+256]= uni_code; | |
2514 uni_DCtab_lum_len [level+256]= uni_len; | |
2515 | |
2516 /* chrominance */ | |
2517 uni_code= DCtab_chrom[size][0]; | |
2518 uni_len = DCtab_chrom[size][1]; | |
2519 | |
2520 if (size > 0) { | |
2521 uni_code<<=size; uni_code|=l; | |
2522 uni_len+=size; | |
2523 if (size > 8){ | |
2524 uni_code<<=1; uni_code|=1; | |
2525 uni_len++; | |
2526 } | |
2527 } | |
2528 uni_DCtab_chrom_bits[level+256]= uni_code; | |
2529 uni_DCtab_chrom_len [level+256]= uni_len; | |
2530 | |
2531 } | |
2532 } | |
2533 | |
2534 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ | |
2535 int slevel, run, last; | |
2536 | |
2537 assert(MAX_LEVEL >= 64); | |
2538 assert(MAX_RUN >= 63); | |
2539 | |
2540 for(slevel=-64; slevel<64; slevel++){ | |
2541 if(slevel==0) continue; | |
2542 for(run=0; run<64; run++){ | |
2543 for(last=0; last<=1; last++){ | |
2544 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); | |
2545 int level= slevel < 0 ? -slevel : slevel; | |
2546 int sign= slevel < 0 ? 1 : 0; | |
2547 int bits, len, code; | |
2548 int level1, run1; | |
2549 | |
2550 len_tab[index]= 100; | |
2551 | |
2552 /* ESC0 */ | |
2553 code= get_rl_index(rl, last, run, level); | |
2554 bits= rl->table_vlc[code][0]; | |
2555 len= rl->table_vlc[code][1]; | |
2556 bits=bits*2+sign; len++; | |
2557 | |
2558 if(code!=rl->n && len < len_tab[index]){ | |
2559 bits_tab[index]= bits; | |
2560 len_tab [index]= len; | |
2561 } | |
2562 /* ESC1 */ | |
2563 bits= rl->table_vlc[rl->n][0]; | |
2564 len= rl->table_vlc[rl->n][1]; | |
2565 bits=bits*2; len++; //esc1 | |
2566 level1= level - rl->max_level[last][run]; | |
2567 if(level1>0){ | |
2568 code= get_rl_index(rl, last, run, level1); | |
2569 bits<<= rl->table_vlc[code][1]; | |
2570 len += rl->table_vlc[code][1]; | |
2571 bits += rl->table_vlc[code][0]; | |
2572 bits=bits*2+sign; len++; | |
2573 | |
2574 if(code!=rl->n && len < len_tab[index]){ | |
2575 bits_tab[index]= bits; | |
2576 len_tab [index]= len; | |
2577 } | |
2578 } | |
2579 /* ESC2 */ | |
2580 bits= rl->table_vlc[rl->n][0]; | |
2581 len= rl->table_vlc[rl->n][1]; | |
2582 bits=bits*4+2; len+=2; //esc2 | |
2583 run1 = run - rl->max_run[last][level] - 1; | |
2584 if(run1>=0){ | |
2585 code= get_rl_index(rl, last, run1, level); | |
2586 bits<<= rl->table_vlc[code][1]; | |
2587 len += rl->table_vlc[code][1]; | |
2588 bits += rl->table_vlc[code][0]; | |
2589 bits=bits*2+sign; len++; | |
2590 | |
2591 if(code!=rl->n && len < len_tab[index]){ | |
2592 bits_tab[index]= bits; | |
2593 len_tab [index]= len; | |
2594 } | |
2595 } | |
2596 /* ESC3 */ | |
2597 bits= rl->table_vlc[rl->n][0]; | |
2598 len = rl->table_vlc[rl->n][1]; | |
2599 bits=bits*4+3; len+=2; //esc3 | |
2600 bits=bits*2+last; len++; | |
2601 bits=bits*64+run; len+=6; | |
2602 bits=bits*2+1; len++; //marker | |
2603 bits=bits*4096+(slevel&0xfff); len+=12; | |
2604 bits=bits*2+1; len++; //marker | |
2605 | |
2606 if(len < len_tab[index]){ | |
2607 bits_tab[index]= bits; | |
2608 len_tab [index]= len; | |
2609 } | |
2610 } | |
2611 } | |
2612 } | |
2613 } | |
2614 | |
2615 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ | 1200 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
2616 int slevel, run, last; | 1201 int slevel, run, last; |
2617 | 1202 |
2618 assert(MAX_LEVEL >= 64); | 1203 assert(MAX_LEVEL >= 64); |
2619 assert(MAX_RUN >= 63); | 1204 assert(MAX_RUN >= 63); |
2660 static int done = 0; | 1245 static int done = 0; |
2661 | 1246 |
2662 if (!done) { | 1247 if (!done) { |
2663 done = 1; | 1248 done = 1; |
2664 | 1249 |
2665 init_uni_dc_tab(); | |
2666 | |
2667 init_rl(&rl_inter, static_rl_table_store[0]); | 1250 init_rl(&rl_inter, static_rl_table_store[0]); |
2668 init_rl(&rl_intra, static_rl_table_store[1]); | 1251 init_rl(&rl_intra_aic, static_rl_table_store[1]); |
2669 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2670 | |
2671 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len); | |
2672 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len); | |
2673 | 1252 |
2674 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); | 1253 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); |
2675 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); | 1254 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); |
2676 | 1255 |
2677 init_mv_penalty_and_fcode(s); | 1256 init_mv_penalty_and_fcode(s); |
2688 | 1267 |
2689 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME | 1268 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
2690 switch(s->codec_id){ | 1269 switch(s->codec_id){ |
2691 case CODEC_ID_MPEG4: | 1270 case CODEC_ID_MPEG4: |
2692 s->fcode_tab= fcode_tab; | 1271 s->fcode_tab= fcode_tab; |
2693 s->min_qcoeff= -2048; | |
2694 s->max_qcoeff= 2047; | |
2695 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; | |
2696 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
2697 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
2698 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
2699 s->luma_dc_vlc_length= uni_DCtab_lum_len; | |
2700 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
2701 s->ac_esc_length= 7+2+1+6+1+12+1; | |
2702 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; | |
2703 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
2704 | |
2705 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ | |
2706 | |
2707 s->avctx->extradata= av_malloc(1024); | |
2708 init_put_bits(&s->pb, s->avctx->extradata, 1024); | |
2709 | |
2710 if(!(s->workaround_bugs & FF_BUG_MS)) | |
2711 mpeg4_encode_visual_object_header(s); | |
2712 mpeg4_encode_vol_header(s, 0, 0); | |
2713 | |
2714 // ff_mpeg4_stuffing(&s->pb); ? | |
2715 flush_put_bits(&s->pb); | |
2716 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; | |
2717 } | |
2718 | |
2719 break; | 1272 break; |
2720 case CODEC_ID_H263P: | 1273 case CODEC_ID_H263P: |
2721 if(s->umvplus) | 1274 if(s->umvplus) |
2722 s->fcode_tab= umv_fcode_tab; | 1275 s->fcode_tab= umv_fcode_tab; |
2723 if(s->modified_quant){ | 1276 if(s->modified_quant){ |
2747 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | 1300 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
2748 } | 1301 } |
2749 } | 1302 } |
2750 #endif //CONFIG_ENCODERS | 1303 #endif //CONFIG_ENCODERS |
2751 | 1304 |
2752 /** | |
2753 * predicts the ac. | |
2754 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2755 * @param dir the ac prediction direction | |
2756 */ | |
2757 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, | |
2758 int dir) | |
2759 { | |
2760 int i; | |
2761 int16_t *ac_val, *ac_val1; | |
2762 int8_t * const qscale_table= s->current_picture.qscale_table; | |
2763 | |
2764 /* find prediction */ | |
2765 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
2766 ac_val1 = ac_val; | |
2767 if (s->ac_pred) { | |
2768 if (dir == 0) { | |
2769 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; | |
2770 /* left prediction */ | |
2771 ac_val -= 16; | |
2772 | |
2773 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ | |
2774 /* same qscale */ | |
2775 for(i=1;i<8;i++) { | |
2776 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; | |
2777 } | |
2778 }else{ | |
2779 /* different qscale, we must rescale */ | |
2780 for(i=1;i<8;i++) { | |
2781 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); | |
2782 } | |
2783 } | |
2784 } else { | |
2785 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; | |
2786 /* top prediction */ | |
2787 ac_val -= 16 * s->block_wrap[n]; | |
2788 | |
2789 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ | |
2790 /* same qscale */ | |
2791 for(i=1;i<8;i++) { | |
2792 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; | |
2793 } | |
2794 }else{ | |
2795 /* different qscale, we must rescale */ | |
2796 for(i=1;i<8;i++) { | |
2797 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); | |
2798 } | |
2799 } | |
2800 } | |
2801 } | |
2802 /* left copy */ | |
2803 for(i=1;i<8;i++) | |
2804 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; | |
2805 | |
2806 /* top copy */ | |
2807 for(i=1;i<8;i++) | |
2808 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; | |
2809 | |
2810 } | |
2811 | |
2812 /***********************************************/ | 1305 /***********************************************/ |
2813 /* decoding */ | 1306 /* decoding */ |
2814 | 1307 |
2815 static VLC intra_MCBPC_vlc; | 1308 VLC intra_MCBPC_vlc; |
2816 static VLC inter_MCBPC_vlc; | 1309 VLC inter_MCBPC_vlc; |
2817 static VLC cbpy_vlc; | 1310 VLC cbpy_vlc; |
2818 static VLC mv_vlc; | 1311 static VLC mv_vlc; |
2819 static VLC dc_lum, dc_chrom; | |
2820 static VLC sprite_trajectory; | |
2821 static VLC mb_type_b_vlc; | |
2822 static VLC h263_mbtype_b_vlc; | 1312 static VLC h263_mbtype_b_vlc; |
2823 static VLC cbpc_b_vlc; | 1313 static VLC cbpc_b_vlc; |
2824 | 1314 |
2825 /* init vlcs */ | 1315 /* init vlcs */ |
2826 | 1316 |
2843 &cbpy_tab[0][0], 2, 1, 64); | 1333 &cbpy_tab[0][0], 2, 1, 64); |
2844 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, | 1334 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, |
2845 &mvtab[0][1], 2, 1, | 1335 &mvtab[0][1], 2, 1, |
2846 &mvtab[0][0], 2, 1, 538); | 1336 &mvtab[0][0], 2, 1, 538); |
2847 init_rl(&rl_inter, static_rl_table_store[0]); | 1337 init_rl(&rl_inter, static_rl_table_store[0]); |
2848 init_rl(&rl_intra, static_rl_table_store[1]); | 1338 init_rl(&rl_intra_aic, static_rl_table_store[1]); |
2849 init_rl(&rvlc_rl_inter, static_rl_table_store[3]); | |
2850 init_rl(&rvlc_rl_intra, static_rl_table_store[4]); | |
2851 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2852 INIT_VLC_RL(rl_inter, 554); | 1339 INIT_VLC_RL(rl_inter, 554); |
2853 INIT_VLC_RL(rl_intra, 554); | |
2854 INIT_VLC_RL(rvlc_rl_inter, 1072); | |
2855 INIT_VLC_RL(rvlc_rl_intra, 1072); | |
2856 INIT_VLC_RL(rl_intra_aic, 554); | 1340 INIT_VLC_RL(rl_intra_aic, 554); |
2857 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */, | |
2858 &DCtab_lum[0][1], 2, 1, | |
2859 &DCtab_lum[0][0], 2, 1, 512); | |
2860 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, | |
2861 &DCtab_chrom[0][1], 2, 1, | |
2862 &DCtab_chrom[0][0], 2, 1, 512); | |
2863 INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15, | |
2864 &sprite_trajectory_tab[0][1], 4, 2, | |
2865 &sprite_trajectory_tab[0][0], 4, 2, 128); | |
2866 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, | |
2867 &mb_type_b_tab[0][1], 2, 1, | |
2868 &mb_type_b_tab[0][0], 2, 1, 16); | |
2869 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, | 1341 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, |
2870 &h263_mbtype_b_tab[0][1], 2, 1, | 1342 &h263_mbtype_b_tab[0][1], 2, 1, |
2871 &h263_mbtype_b_tab[0][0], 2, 1, 80); | 1343 &h263_mbtype_b_tab[0][0], 2, 1, 80); |
2872 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, | 1344 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, |
2873 &cbpc_b_tab[0][1], 2, 1, | 1345 &cbpc_b_tab[0][1], 2, 1, |
2972 int i; | 1444 int i; |
2973 for(i=0;i<n;i++) | 1445 for(i=0;i<n;i++) |
2974 tab[i] = val; | 1446 tab[i] = val; |
2975 } | 1447 } |
2976 | 1448 |
2977 #if CONFIG_ENCODERS | |
2978 | |
2979 void ff_mpeg4_init_partitions(MpegEncContext *s) | |
2980 { | |
2981 uint8_t *start= put_bits_ptr(&s->pb); | |
2982 uint8_t *end= s->pb.buf_end; | |
2983 int size= end - start; | |
2984 int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start; | |
2985 int tex_size= (size - 2*pb_size)&(~3); | |
2986 | |
2987 set_put_bits_buffer_size(&s->pb, pb_size); | |
2988 init_put_bits(&s->tex_pb, start + pb_size , tex_size); | |
2989 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); | |
2990 } | |
2991 | |
2992 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
2993 { | |
2994 const int pb2_len = put_bits_count(&s->pb2 ); | |
2995 const int tex_pb_len= put_bits_count(&s->tex_pb); | |
2996 const int bits= put_bits_count(&s->pb); | |
2997 | |
2998 if(s->pict_type==FF_I_TYPE){ | |
2999 put_bits(&s->pb, 19, DC_MARKER); | |
3000 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
3001 s->i_tex_bits+= tex_pb_len; | |
3002 }else{ | |
3003 put_bits(&s->pb, 17, MOTION_MARKER); | |
3004 s->misc_bits+=17 + pb2_len; | |
3005 s->mv_bits+= bits - s->last_bits; | |
3006 s->p_tex_bits+= tex_pb_len; | |
3007 } | |
3008 | |
3009 flush_put_bits(&s->pb2); | |
3010 flush_put_bits(&s->tex_pb); | |
3011 | |
3012 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); | |
3013 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); | |
3014 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); | |
3015 s->last_bits= put_bits_count(&s->pb); | |
3016 } | |
3017 | |
3018 #endif //CONFIG_ENCODERS | |
3019 | |
3020 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){ | |
3021 switch(s->pict_type){ | |
3022 case FF_I_TYPE: | |
3023 return 16; | |
3024 case FF_P_TYPE: | |
3025 case FF_S_TYPE: | |
3026 return s->f_code+15; | |
3027 case FF_B_TYPE: | |
3028 return FFMAX3(s->f_code, s->b_code, 2) + 15; | |
3029 default: | |
3030 return -1; | |
3031 } | |
3032 } | |
3033 | |
3034 #if CONFIG_ENCODERS | |
3035 | |
3036 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) | |
3037 { | |
3038 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
3039 | |
3040 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); | |
3041 put_bits(&s->pb, 1, 1); | |
3042 | |
3043 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); | |
3044 put_bits(&s->pb, s->quant_precision, s->qscale); | |
3045 put_bits(&s->pb, 1, 0); /* no HEC */ | |
3046 } | |
3047 | |
3048 #endif //CONFIG_ENCODERS | |
3049 | |
3050 /** | |
3051 * check if the next stuff is a resync marker or the end. | |
3052 * @return 0 if not | |
3053 */ | |
3054 static inline int mpeg4_is_resync(MpegEncContext *s){ | |
3055 int bits_count= get_bits_count(&s->gb); | |
3056 int v= show_bits(&s->gb, 16); | |
3057 | |
3058 if(s->workaround_bugs&FF_BUG_NO_PADDING){ | |
3059 return 0; | |
3060 } | |
3061 | |
3062 while(v<=0xFF){ | |
3063 if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame) | |
3064 break; | |
3065 skip_bits(&s->gb, 8+s->pict_type); | |
3066 bits_count+= 8+s->pict_type; | |
3067 v= show_bits(&s->gb, 16); | |
3068 } | |
3069 | |
3070 if(bits_count + 8 >= s->gb.size_in_bits){ | |
3071 v>>=8; | |
3072 v|= 0x7F >> (7-(bits_count&7)); | |
3073 | |
3074 if(v==0x7F) | |
3075 return 1; | |
3076 }else{ | |
3077 if(v == ff_mpeg4_resync_prefix[bits_count&7]){ | |
3078 int len; | |
3079 GetBitContext gb= s->gb; | |
3080 | |
3081 skip_bits(&s->gb, 1); | |
3082 align_get_bits(&s->gb); | |
3083 | |
3084 for(len=0; len<32; len++){ | |
3085 if(get_bits1(&s->gb)) break; | |
3086 } | |
3087 | |
3088 s->gb= gb; | |
3089 | |
3090 if(len>=ff_mpeg4_get_video_packet_prefix_length(s)) | |
3091 return 1; | |
3092 } | |
3093 } | |
3094 return 0; | |
3095 } | |
3096 | |
3097 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb) | |
3098 { | |
3099 int i; | |
3100 int a= 2<<s->sprite_warping_accuracy; | |
3101 int rho= 3-s->sprite_warping_accuracy; | |
3102 int r=16/a; | |
3103 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes | |
3104 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; | |
3105 int sprite_ref[4][2]; | |
3106 int virtual_ref[2][2]; | |
3107 int w2, h2, w3, h3; | |
3108 int alpha=0, beta=0; | |
3109 int w= s->width; | |
3110 int h= s->height; | |
3111 int min_ab; | |
3112 | |
3113 for(i=0; i<s->num_sprite_warping_points; i++){ | |
3114 int length; | |
3115 int x=0, y=0; | |
3116 | |
3117 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); | |
3118 if(length){ | |
3119 x= get_xbits(gb, length); | |
3120 } | |
3121 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */ | |
3122 | |
3123 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); | |
3124 if(length){ | |
3125 y=get_xbits(gb, length); | |
3126 } | |
3127 skip_bits1(gb); /* marker bit */ | |
3128 s->sprite_traj[i][0]= d[i][0]= x; | |
3129 s->sprite_traj[i][1]= d[i][1]= y; | |
3130 } | |
3131 for(; i<4; i++) | |
3132 s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0; | |
3133 | |
3134 while((1<<alpha)<w) alpha++; | |
3135 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' | |
3136 w2= 1<<alpha; | |
3137 h2= 1<<beta; | |
3138 | |
3139 // Note, the 4th point isn't used for GMC | |
3140 if(s->divx_version==500 && s->divx_build==413){ | |
3141 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
3142 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
3143 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
3144 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
3145 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
3146 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
3147 } else { | |
3148 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
3149 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
3150 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
3151 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
3152 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
3153 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
3154 } | |
3155 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]); | |
3156 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ | |
3157 | |
3158 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...) | |
3159 // perhaps it should be reordered to be more readable ... | |
3160 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides | |
3161 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form | |
3162 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) | |
3163 + 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); | |
3164 virtual_ref[0][1]= 16*vop_ref[0][1] | |
3165 + 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); | |
3166 virtual_ref[1][0]= 16*vop_ref[0][0] | |
3167 + 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); | |
3168 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) | |
3169 + 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); | |
3170 | |
3171 switch(s->num_sprite_warping_points) | |
3172 { | |
3173 case 0: | |
3174 s->sprite_offset[0][0]= 0; | |
3175 s->sprite_offset[0][1]= 0; | |
3176 s->sprite_offset[1][0]= 0; | |
3177 s->sprite_offset[1][1]= 0; | |
3178 s->sprite_delta[0][0]= a; | |
3179 s->sprite_delta[0][1]= 0; | |
3180 s->sprite_delta[1][0]= 0; | |
3181 s->sprite_delta[1][1]= a; | |
3182 s->sprite_shift[0]= 0; | |
3183 s->sprite_shift[1]= 0; | |
3184 break; | |
3185 case 1: //GMC only | |
3186 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0]; | |
3187 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1]; | |
3188 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2); | |
3189 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); | |
3190 s->sprite_delta[0][0]= a; | |
3191 s->sprite_delta[0][1]= 0; | |
3192 s->sprite_delta[1][0]= 0; | |
3193 s->sprite_delta[1][1]= a; | |
3194 s->sprite_shift[0]= 0; | |
3195 s->sprite_shift[1]= 0; | |
3196 break; | |
3197 case 2: | |
3198 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) | |
3199 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) | |
3200 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
3201 + (1<<(alpha+rho-1)); | |
3202 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) | |
3203 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) | |
3204 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
3205 + (1<<(alpha+rho-1)); | |
3206 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
3207 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
3208 +2*w2*r*sprite_ref[0][0] | |
3209 - 16*w2 | |
3210 + (1<<(alpha+rho+1))); | |
3211 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) | |
3212 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) | |
3213 +2*w2*r*sprite_ref[0][1] | |
3214 - 16*w2 | |
3215 + (1<<(alpha+rho+1))); | |
3216 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
3217 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
3218 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
3219 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
3220 | |
3221 s->sprite_shift[0]= alpha+rho; | |
3222 s->sprite_shift[1]= alpha+rho+2; | |
3223 break; | |
3224 case 3: | |
3225 min_ab= FFMIN(alpha, beta); | |
3226 w3= w2>>min_ab; | |
3227 h3= h2>>min_ab; | |
3228 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
3229 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
3230 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
3231 + (1<<(alpha+beta+rho-min_ab-1)); | |
3232 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
3233 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
3234 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
3235 + (1<<(alpha+beta+rho-min_ab-1)); | |
3236 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
3237 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
3238 + 2*w2*h3*r*sprite_ref[0][0] | |
3239 - 16*w2*h3 | |
3240 + (1<<(alpha+beta+rho-min_ab+1)); | |
3241 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
3242 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
3243 + 2*w2*h3*r*sprite_ref[0][1] | |
3244 - 16*w2*h3 | |
3245 + (1<<(alpha+beta+rho-min_ab+1)); | |
3246 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
3247 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
3248 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
3249 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
3250 | |
3251 s->sprite_shift[0]= alpha + beta + rho - min_ab; | |
3252 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2; | |
3253 break; | |
3254 } | |
3255 /* try to simplify the situation */ | |
3256 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] | |
3257 && s->sprite_delta[0][1] == 0 | |
3258 && s->sprite_delta[1][0] == 0 | |
3259 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
3260 { | |
3261 s->sprite_offset[0][0]>>=s->sprite_shift[0]; | |
3262 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
3263 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
3264 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
3265 s->sprite_delta[0][0]= a; | |
3266 s->sprite_delta[0][1]= 0; | |
3267 s->sprite_delta[1][0]= 0; | |
3268 s->sprite_delta[1][1]= a; | |
3269 s->sprite_shift[0]= 0; | |
3270 s->sprite_shift[1]= 0; | |
3271 s->real_sprite_warping_points=1; | |
3272 } | |
3273 else{ | |
3274 int shift_y= 16 - s->sprite_shift[0]; | |
3275 int shift_c= 16 - s->sprite_shift[1]; | |
3276 for(i=0; i<2; i++){ | |
3277 s->sprite_offset[0][i]<<= shift_y; | |
3278 s->sprite_offset[1][i]<<= shift_c; | |
3279 s->sprite_delta[0][i]<<= shift_y; | |
3280 s->sprite_delta[1][i]<<= shift_y; | |
3281 s->sprite_shift[i]= 16; | |
3282 } | |
3283 s->real_sprite_warping_points= s->num_sprite_warping_points; | |
3284 } | |
3285 } | |
3286 | |
3287 /** | |
3288 * decodes the next video packet. | |
3289 * @return <0 if something went wrong | |
3290 */ | |
3291 static int mpeg4_decode_video_packet_header(MpegEncContext *s) | |
3292 { | |
3293 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
3294 int header_extension=0, mb_num, len; | |
3295 | |
3296 /* is there enough space left for a video packet + header */ | |
3297 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1; | |
3298 | |
3299 for(len=0; len<32; len++){ | |
3300 if(get_bits1(&s->gb)) break; | |
3301 } | |
3302 | |
3303 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){ | |
3304 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); | |
3305 return -1; | |
3306 } | |
3307 | |
3308 if(s->shape != RECT_SHAPE){ | |
3309 header_extension= get_bits1(&s->gb); | |
3310 //FIXME more stuff here | |
3311 } | |
3312 | |
3313 mb_num= get_bits(&s->gb, mb_num_bits); | |
3314 if(mb_num>=s->mb_num){ | |
3315 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); | |
3316 return -1; | |
3317 } | |
3318 if(s->pict_type == FF_B_TYPE){ | |
3319 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; | |
3320 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded | |
3321 } | |
3322 | |
3323 s->mb_x= mb_num % s->mb_width; | |
3324 s->mb_y= mb_num / s->mb_width; | |
3325 | |
3326 if(s->shape != BIN_ONLY_SHAPE){ | |
3327 int qscale= get_bits(&s->gb, s->quant_precision); | |
3328 if(qscale) | |
3329 s->chroma_qscale=s->qscale= qscale; | |
3330 } | |
3331 | |
3332 if(s->shape == RECT_SHAPE){ | |
3333 header_extension= get_bits1(&s->gb); | |
3334 } | |
3335 if(header_extension){ | |
3336 int time_increment; | |
3337 int time_incr=0; | |
3338 | |
3339 while (get_bits1(&s->gb) != 0) | |
3340 time_incr++; | |
3341 | |
3342 check_marker(&s->gb, "before time_increment in video packed header"); | |
3343 time_increment= get_bits(&s->gb, s->time_increment_bits); | |
3344 check_marker(&s->gb, "before vop_coding_type in video packed header"); | |
3345 | |
3346 skip_bits(&s->gb, 2); /* vop coding type */ | |
3347 //FIXME not rect stuff here | |
3348 | |
3349 if(s->shape != BIN_ONLY_SHAPE){ | |
3350 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ | |
3351 //FIXME don't just ignore everything | |
3352 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
3353 mpeg4_decode_sprite_trajectory(s, &s->gb); | |
3354 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); | |
3355 } | |
3356 | |
3357 //FIXME reduced res stuff here | |
3358 | |
3359 if (s->pict_type != FF_I_TYPE) { | |
3360 int f_code = get_bits(&s->gb, 3); /* fcode_for */ | |
3361 if(f_code==0){ | |
3362 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); | |
3363 } | |
3364 } | |
3365 if (s->pict_type == FF_B_TYPE) { | |
3366 int b_code = get_bits(&s->gb, 3); | |
3367 if(b_code==0){ | |
3368 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); | |
3369 } | |
3370 } | |
3371 } | |
3372 } | |
3373 //FIXME new-pred stuff | |
3374 | |
3375 return 0; | |
3376 } | |
3377 | |
3378 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
3379 { | |
3380 int c_wrap, c_xy, l_wrap, l_xy; | |
3381 | |
3382 l_wrap= s->b8_stride; | |
3383 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1; | |
3384 c_wrap= s->mb_stride; | |
3385 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; | |
3386 | |
3387 #if 0 | |
3388 /* clean DC */ | |
3389 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); | |
3390 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
3391 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1); | |
3392 #endif | |
3393 | |
3394 /* clean AC */ | |
3395 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); | |
3396 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3397 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3398 | |
3399 /* clean MV */ | |
3400 // we can't clear the MVs as they might be needed by a b frame | |
3401 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); | |
3402 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
3403 s->last_mv[0][0][0]= | |
3404 s->last_mv[0][0][1]= | |
3405 s->last_mv[1][0][0]= | |
3406 s->last_mv[1][0][1]= 0; | |
3407 } | |
3408 | |
3409 /** | 1449 /** |
3410 * finds the next resync_marker | 1450 * finds the next resync_marker |
3411 * @param p pointer to buffer to scan | 1451 * @param p pointer to buffer to scan |
3412 * @param end pointer to the end of the buffer | 1452 * @param end pointer to the end of the buffer |
3413 * @return pointer to the next resync_marker, or end if none was found | 1453 * @return pointer to the next resync_marker, or end if none was found |
3471 } | 1511 } |
3472 | 1512 |
3473 return -1; | 1513 return -1; |
3474 } | 1514 } |
3475 | 1515 |
3476 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) | 1516 int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
3477 { | 1517 { |
3478 int code, val, sign, shift, l; | 1518 int code, val, sign, shift, l; |
3479 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); | 1519 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
3480 | 1520 |
3481 if (code == 0) | 1521 if (code == 0) |
3508 | 1548 |
3509 } | 1549 } |
3510 return val; | 1550 return val; |
3511 } | 1551 } |
3512 | 1552 |
3513 /** | |
3514 * gets the average motion vector for a GMC MB. | |
3515 * @param n either 0 for the x component or 1 for y | |
3516 * @returns the average MV for a GMC MB | |
3517 */ | |
3518 static inline int get_amv(MpegEncContext *s, int n){ | |
3519 int x, y, mb_v, sum, dx, dy, shift; | |
3520 int len = 1 << (s->f_code + 4); | |
3521 const int a= s->sprite_warping_accuracy; | |
3522 | |
3523 if(s->workaround_bugs & FF_BUG_AMV) | |
3524 len >>= s->quarter_sample; | |
3525 | |
3526 if(s->real_sprite_warping_points==1){ | |
3527 if(s->divx_version==500 && s->divx_build==413) | |
3528 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
3529 else | |
3530 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
3531 }else{ | |
3532 dx= s->sprite_delta[n][0]; | |
3533 dy= s->sprite_delta[n][1]; | |
3534 shift= s->sprite_shift[0]; | |
3535 if(n) dy -= 1<<(shift + a + 1); | |
3536 else dx -= 1<<(shift + a + 1); | |
3537 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
3538 | |
3539 sum=0; | |
3540 for(y=0; y<16; y++){ | |
3541 int v; | |
3542 | |
3543 v= mb_v + dy*y; | |
3544 //XXX FIXME optimize | |
3545 for(x=0; x<16; x++){ | |
3546 sum+= v>>shift; | |
3547 v+= dx; | |
3548 } | |
3549 } | |
3550 sum= RSHIFT(sum, a+8-s->quarter_sample); | |
3551 } | |
3552 | |
3553 if (sum < -len) sum= -len; | |
3554 else if (sum >= len) sum= len-1; | |
3555 | |
3556 return sum; | |
3557 } | |
3558 | |
3559 /** | |
3560 * decodes the dc value. | |
3561 * @param n block index (0-3 are luma, 4-5 are chroma) | |
3562 * @param dir_ptr the prediction direction will be stored here | |
3563 * @return the quantized dc | |
3564 */ | |
3565 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) | |
3566 { | |
3567 int level, code; | |
3568 | |
3569 if (n < 4) | |
3570 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); | |
3571 else | |
3572 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); | |
3573 if (code < 0 || code > 9 /* && s->nbit<9 */){ | |
3574 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); | |
3575 return -1; | |
3576 } | |
3577 if (code == 0) { | |
3578 level = 0; | |
3579 } else { | |
3580 if(IS_3IV1){ | |
3581 if(code==1) | |
3582 level= 2*get_bits1(&s->gb)-1; | |
3583 else{ | |
3584 if(get_bits1(&s->gb)) | |
3585 level = get_bits(&s->gb, code-1) + (1<<(code-1)); | |
3586 else | |
3587 level = -get_bits(&s->gb, code-1) - (1<<(code-1)); | |
3588 } | |
3589 }else{ | |
3590 level = get_xbits(&s->gb, code); | |
3591 } | |
3592 | |
3593 if (code > 8){ | |
3594 if(get_bits1(&s->gb)==0){ /* marker */ | |
3595 if(s->error_recognition>=2){ | |
3596 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); | |
3597 return -1; | |
3598 } | |
3599 } | |
3600 } | |
3601 } | |
3602 | |
3603 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); | |
3604 } | |
3605 | |
3606 /** | |
3607 * decodes first partition. | |
3608 * @return number of MBs decoded or <0 if an error occurred | |
3609 */ | |
3610 static int mpeg4_decode_partition_a(MpegEncContext *s){ | |
3611 int mb_num; | |
3612 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3613 | |
3614 /* decode first partition */ | |
3615 mb_num=0; | |
3616 s->first_slice_line=1; | |
3617 for(; s->mb_y<s->mb_height; s->mb_y++){ | |
3618 ff_init_block_index(s); | |
3619 for(; s->mb_x<s->mb_width; s->mb_x++){ | |
3620 const int xy= s->mb_x + s->mb_y*s->mb_stride; | |
3621 int cbpc; | |
3622 int dir=0; | |
3623 | |
3624 mb_num++; | |
3625 ff_update_block_index(s); | |
3626 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) | |
3627 s->first_slice_line=0; | |
3628 | |
3629 if(s->pict_type==FF_I_TYPE){ | |
3630 int i; | |
3631 | |
3632 do{ | |
3633 if(show_bits_long(&s->gb, 19)==DC_MARKER){ | |
3634 return mb_num-1; | |
3635 } | |
3636 | |
3637 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
3638 if (cbpc < 0){ | |
3639 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
3640 return -1; | |
3641 } | |
3642 }while(cbpc == 8); | |
3643 | |
3644 s->cbp_table[xy]= cbpc & 3; | |
3645 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3646 s->mb_intra = 1; | |
3647 | |
3648 if(cbpc & 4) { | |
3649 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); | |
3650 } | |
3651 s->current_picture.qscale_table[xy]= s->qscale; | |
3652 | |
3653 s->mbintra_table[xy]= 1; | |
3654 for(i=0; i<6; i++){ | |
3655 int dc_pred_dir; | |
3656 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
3657 if(dc < 0){ | |
3658 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | |
3659 return -1; | |
3660 } | |
3661 dir<<=1; | |
3662 if(dc_pred_dir) dir|=1; | |
3663 } | |
3664 s->pred_dir_table[xy]= dir; | |
3665 }else{ /* P/S_TYPE */ | |
3666 int mx, my, pred_x, pred_y, bits; | |
3667 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]]; | |
3668 const int stride= s->b8_stride*2; | |
3669 | |
3670 try_again: | |
3671 bits= show_bits(&s->gb, 17); | |
3672 if(bits==MOTION_MARKER){ | |
3673 return mb_num-1; | |
3674 } | |
3675 skip_bits1(&s->gb); | |
3676 if(bits&0x10000){ | |
3677 /* skip mb */ | |
3678 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
3679 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; | |
3680 mx= get_amv(s, 0); | |
3681 my= get_amv(s, 1); | |
3682 }else{ | |
3683 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; | |
3684 mx=my=0; | |
3685 } | |
3686 mot_val[0 ]= mot_val[2 ]= | |
3687 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3688 mot_val[1 ]= mot_val[3 ]= | |
3689 mot_val[1+stride]= mot_val[3+stride]= my; | |
3690 | |
3691 if(s->mbintra_table[xy]) | |
3692 ff_clean_intra_table_entries(s); | |
3693 continue; | |
3694 } | |
3695 | |
3696 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
3697 if (cbpc < 0){ | |
3698 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
3699 return -1; | |
3700 } | |
3701 if(cbpc == 20) | |
3702 goto try_again; | |
3703 | |
3704 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant | |
3705 | |
3706 s->mb_intra = ((cbpc & 4) != 0); | |
3707 | |
3708 if(s->mb_intra){ | |
3709 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3710 s->mbintra_table[xy]= 1; | |
3711 mot_val[0 ]= mot_val[2 ]= | |
3712 mot_val[0+stride]= mot_val[2+stride]= 0; | |
3713 mot_val[1 ]= mot_val[3 ]= | |
3714 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3715 }else{ | |
3716 if(s->mbintra_table[xy]) | |
3717 ff_clean_intra_table_entries(s); | |
3718 | |
3719 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
3720 s->mcsel= get_bits1(&s->gb); | |
3721 else s->mcsel= 0; | |
3722 | |
3723 if ((cbpc & 16) == 0) { | |
3724 /* 16x16 motion prediction */ | |
3725 | |
3726 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); | |
3727 if(!s->mcsel){ | |
3728 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3729 if (mx >= 0xffff) | |
3730 return -1; | |
3731 | |
3732 my = h263_decode_motion(s, pred_y, s->f_code); | |
3733 if (my >= 0xffff) | |
3734 return -1; | |
3735 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; | |
3736 } else { | |
3737 mx = get_amv(s, 0); | |
3738 my = get_amv(s, 1); | |
3739 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; | |
3740 } | |
3741 | |
3742 mot_val[0 ]= mot_val[2 ] = | |
3743 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3744 mot_val[1 ]= mot_val[3 ]= | |
3745 mot_val[1+stride]= mot_val[3+stride]= my; | |
3746 } else { | |
3747 int i; | |
3748 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; | |
3749 for(i=0;i<4;i++) { | |
3750 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y); | |
3751 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3752 if (mx >= 0xffff) | |
3753 return -1; | |
3754 | |
3755 my = h263_decode_motion(s, pred_y, s->f_code); | |
3756 if (my >= 0xffff) | |
3757 return -1; | |
3758 mot_val[0] = mx; | |
3759 mot_val[1] = my; | |
3760 } | |
3761 } | |
3762 } | |
3763 } | |
3764 } | |
3765 s->mb_x= 0; | |
3766 } | |
3767 | |
3768 return mb_num; | |
3769 } | |
3770 | |
3771 /** | |
3772 * decode second partition. | |
3773 * @return <0 if an error occurred | |
3774 */ | |
3775 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ | |
3776 int mb_num=0; | |
3777 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3778 | |
3779 s->mb_x= s->resync_mb_x; | |
3780 s->first_slice_line=1; | |
3781 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){ | |
3782 ff_init_block_index(s); | |
3783 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){ | |
3784 const int xy= s->mb_x + s->mb_y*s->mb_stride; | |
3785 | |
3786 mb_num++; | |
3787 ff_update_block_index(s); | |
3788 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) | |
3789 s->first_slice_line=0; | |
3790 | |
3791 if(s->pict_type==FF_I_TYPE){ | |
3792 int ac_pred= get_bits1(&s->gb); | |
3793 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3794 if(cbpy<0){ | |
3795 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
3796 return -1; | |
3797 } | |
3798 | |
3799 s->cbp_table[xy]|= cbpy<<2; | |
3800 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; | |
3801 }else{ /* P || S_TYPE */ | |
3802 if(IS_INTRA(s->current_picture.mb_type[xy])){ | |
3803 int dir=0,i; | |
3804 int ac_pred = get_bits1(&s->gb); | |
3805 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3806 | |
3807 if(cbpy<0){ | |
3808 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
3809 return -1; | |
3810 } | |
3811 | |
3812 if(s->cbp_table[xy] & 8) { | |
3813 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); | |
3814 } | |
3815 s->current_picture.qscale_table[xy]= s->qscale; | |
3816 | |
3817 for(i=0; i<6; i++){ | |
3818 int dc_pred_dir; | |
3819 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
3820 if(dc < 0){ | |
3821 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | |
3822 return -1; | |
3823 } | |
3824 dir<<=1; | |
3825 if(dc_pred_dir) dir|=1; | |
3826 } | |
3827 s->cbp_table[xy]&= 3; //remove dquant | |
3828 s->cbp_table[xy]|= cbpy<<2; | |
3829 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; | |
3830 s->pred_dir_table[xy]= dir; | |
3831 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ | |
3832 s->current_picture.qscale_table[xy]= s->qscale; | |
3833 s->cbp_table[xy]= 0; | |
3834 }else{ | |
3835 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3836 | |
3837 if(cbpy<0){ | |
3838 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
3839 return -1; | |
3840 } | |
3841 | |
3842 if(s->cbp_table[xy] & 8) { | |
3843 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); | |
3844 } | |
3845 s->current_picture.qscale_table[xy]= s->qscale; | |
3846 | |
3847 s->cbp_table[xy]&= 3; //remove dquant | |
3848 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3849 } | |
3850 } | |
3851 } | |
3852 if(mb_num >= mb_count) return 0; | |
3853 s->mb_x= 0; | |
3854 } | |
3855 return 0; | |
3856 } | |
3857 | |
3858 /** | |
3859 * decodes the first & second partition | |
3860 * @return <0 if error (and sets error type in the error_status_table) | |
3861 */ | |
3862 int ff_mpeg4_decode_partitions(MpegEncContext *s) | |
3863 { | |
3864 int mb_num; | |
3865 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; | |
3866 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END; | |
3867 | |
3868 mb_num= mpeg4_decode_partition_a(s); | |
3869 if(mb_num<0){ | |
3870 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); | |
3871 return -1; | |
3872 } | |
3873 | |
3874 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ | |
3875 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); | |
3876 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); | |
3877 return -1; | |
3878 } | |
3879 | |
3880 s->mb_num_left= mb_num; | |
3881 | |
3882 if(s->pict_type==FF_I_TYPE){ | |
3883 while(show_bits(&s->gb, 9) == 1) | |
3884 skip_bits(&s->gb, 9); | |
3885 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ | |
3886 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y); | |
3887 return -1; | |
3888 } | |
3889 }else{ | |
3890 while(show_bits(&s->gb, 10) == 1) | |
3891 skip_bits(&s->gb, 10); | |
3892 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ | |
3893 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y); | |
3894 return -1; | |
3895 } | |
3896 } | |
3897 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); | |
3898 | |
3899 if( mpeg4_decode_partition_b(s, mb_num) < 0){ | |
3900 if(s->pict_type==FF_P_TYPE) | |
3901 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR); | |
3902 return -1; | |
3903 }else{ | |
3904 if(s->pict_type==FF_P_TYPE) | |
3905 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END); | |
3906 } | |
3907 | |
3908 return 0; | |
3909 } | |
3910 | |
3911 /** | |
3912 * decodes a block. | |
3913 * @return <0 if an error occurred | |
3914 */ | |
3915 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
3916 int n, int coded, int intra, int rvlc) | |
3917 { | |
3918 int level, i, last, run; | |
3919 int dc_pred_dir; | |
3920 RLTable * rl; | |
3921 RL_VLC_ELEM * rl_vlc; | |
3922 const uint8_t * scan_table; | |
3923 int qmul, qadd; | |
3924 | |
3925 //Note intra & rvlc should be optimized away if this is inlined | |
3926 | |
3927 if(intra) { | |
3928 if(s->use_intra_dc_vlc){ | |
3929 /* DC coef */ | |
3930 if(s->partitioned_frame){ | |
3931 level = s->dc_val[0][ s->block_index[n] ]; | |
3932 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); | |
3933 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); | |
3934 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; | |
3935 }else{ | |
3936 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
3937 if (level < 0) | |
3938 return -1; | |
3939 } | |
3940 block[0] = level; | |
3941 i = 0; | |
3942 }else{ | |
3943 i = -1; | |
3944 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0); | |
3945 } | |
3946 if (!coded) | |
3947 goto not_coded; | |
3948 | |
3949 if(rvlc){ | |
3950 rl = &rvlc_rl_intra; | |
3951 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
3952 }else{ | |
3953 rl = &rl_intra; | |
3954 rl_vlc = rl_intra.rl_vlc[0]; | |
3955 } | |
3956 if (s->ac_pred) { | |
3957 if (dc_pred_dir == 0) | |
3958 scan_table = s->intra_v_scantable.permutated; /* left */ | |
3959 else | |
3960 scan_table = s->intra_h_scantable.permutated; /* top */ | |
3961 } else { | |
3962 scan_table = s->intra_scantable.permutated; | |
3963 } | |
3964 qmul=1; | |
3965 qadd=0; | |
3966 } else { | |
3967 i = -1; | |
3968 if (!coded) { | |
3969 s->block_last_index[n] = i; | |
3970 return 0; | |
3971 } | |
3972 if(rvlc) rl = &rvlc_rl_inter; | |
3973 else rl = &rl_inter; | |
3974 | |
3975 scan_table = s->intra_scantable.permutated; | |
3976 | |
3977 if(s->mpeg_quant){ | |
3978 qmul=1; | |
3979 qadd=0; | |
3980 if(rvlc){ | |
3981 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
3982 }else{ | |
3983 rl_vlc = rl_inter.rl_vlc[0]; | |
3984 } | |
3985 }else{ | |
3986 qmul = s->qscale << 1; | |
3987 qadd = (s->qscale - 1) | 1; | |
3988 if(rvlc){ | |
3989 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
3990 }else{ | |
3991 rl_vlc = rl_inter.rl_vlc[s->qscale]; | |
3992 } | |
3993 } | |
3994 } | |
3995 { | |
3996 OPEN_READER(re, &s->gb); | |
3997 for(;;) { | |
3998 UPDATE_CACHE(re, &s->gb); | |
3999 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); | |
4000 if (level==0) { | |
4001 /* escape */ | |
4002 if(rvlc){ | |
4003 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
4004 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); | |
4005 return -1; | |
4006 }; SKIP_CACHE(re, &s->gb, 1); | |
4007 | |
4008 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4009 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4010 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4011 UPDATE_CACHE(re, &s->gb); | |
4012 | |
4013 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
4014 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); | |
4015 return -1; | |
4016 }; SKIP_CACHE(re, &s->gb, 1); | |
4017 | |
4018 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); | |
4019 | |
4020 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ | |
4021 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); | |
4022 return -1; | |
4023 }; SKIP_CACHE(re, &s->gb, 5); | |
4024 | |
4025 level= level * qmul + qadd; | |
4026 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4027 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4028 | |
4029 i+= run + 1; | |
4030 if(last) i+=192; | |
4031 }else{ | |
4032 int cache; | |
4033 cache= GET_CACHE(re, &s->gb); | |
4034 | |
4035 if(IS_3IV1) | |
4036 cache ^= 0xC0000000; | |
4037 | |
4038 if (cache&0x80000000) { | |
4039 if (cache&0x40000000) { | |
4040 /* third escape */ | |
4041 SKIP_CACHE(re, &s->gb, 2); | |
4042 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4043 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4044 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4045 UPDATE_CACHE(re, &s->gb); | |
4046 | |
4047 if(IS_3IV1){ | |
4048 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12); | |
4049 }else{ | |
4050 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
4051 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); | |
4052 return -1; | |
4053 }; SKIP_CACHE(re, &s->gb, 1); | |
4054 | |
4055 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); | |
4056 | |
4057 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
4058 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); | |
4059 return -1; | |
4060 }; LAST_SKIP_CACHE(re, &s->gb, 1); | |
4061 | |
4062 SKIP_COUNTER(re, &s->gb, 1+12+1); | |
4063 } | |
4064 | |
4065 #if 0 | |
4066 if(s->error_recognition >= FF_ER_COMPLIANT){ | |
4067 const int abs_level= FFABS(level); | |
4068 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ | |
4069 const int run1= run - rl->max_run[last][abs_level] - 1; | |
4070 if(abs_level <= rl->max_level[last][run]){ | |
4071 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); | |
4072 return -1; | |
4073 } | |
4074 if(s->error_recognition > FF_ER_COMPLIANT){ | |
4075 if(abs_level <= rl->max_level[last][run]*2){ | |
4076 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); | |
4077 return -1; | |
4078 } | |
4079 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ | |
4080 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); | |
4081 return -1; | |
4082 } | |
4083 } | |
4084 } | |
4085 } | |
4086 #endif | |
4087 if (level>0) level= level * qmul + qadd; | |
4088 else level= level * qmul - qadd; | |
4089 | |
4090 if((unsigned)(level + 2048) > 4095){ | |
4091 if(s->error_recognition > FF_ER_COMPLIANT){ | |
4092 if(level > 2560 || level<-2560){ | |
4093 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
4094 return -1; | |
4095 } | |
4096 } | |
4097 level= level<0 ? -2048 : 2047; | |
4098 } | |
4099 | |
4100 i+= run + 1; | |
4101 if(last) i+=192; | |
4102 } else { | |
4103 /* second escape */ | |
4104 #if MIN_CACHE_BITS < 20 | |
4105 LAST_SKIP_BITS(re, &s->gb, 2); | |
4106 UPDATE_CACHE(re, &s->gb); | |
4107 #else | |
4108 SKIP_BITS(re, &s->gb, 2); | |
4109 #endif | |
4110 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); | |
4111 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing | |
4112 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4113 LAST_SKIP_BITS(re, &s->gb, 1); | |
4114 } | |
4115 } else { | |
4116 /* first escape */ | |
4117 #if MIN_CACHE_BITS < 19 | |
4118 LAST_SKIP_BITS(re, &s->gb, 1); | |
4119 UPDATE_CACHE(re, &s->gb); | |
4120 #else | |
4121 SKIP_BITS(re, &s->gb, 1); | |
4122 #endif | |
4123 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); | |
4124 i+= run; | |
4125 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4126 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4127 LAST_SKIP_BITS(re, &s->gb, 1); | |
4128 } | |
4129 } | |
4130 } else { | |
4131 i+= run; | |
4132 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4133 LAST_SKIP_BITS(re, &s->gb, 1); | |
4134 } | |
4135 if (i > 62){ | |
4136 i-= 192; | |
4137 if(i&(~63)){ | |
4138 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); | |
4139 return -1; | |
4140 } | |
4141 | |
4142 block[scan_table[i]] = level; | |
4143 break; | |
4144 } | |
4145 | |
4146 block[scan_table[i]] = level; | |
4147 } | |
4148 CLOSE_READER(re, &s->gb); | |
4149 } | |
4150 not_coded: | |
4151 if (intra) { | |
4152 if(!s->use_intra_dc_vlc){ | |
4153 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); | |
4154 | |
4155 i -= i>>31; //if(i == -1) i=0; | |
4156 } | |
4157 | |
4158 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
4159 if (s->ac_pred) { | |
4160 i = 63; /* XXX: not optimal */ | |
4161 } | |
4162 } | |
4163 s->block_last_index[n] = i; | |
4164 return 0; | |
4165 } | |
4166 | |
4167 /** | |
4168 * decode partition C of one MB. | |
4169 * @return <0 if an error occurred | |
4170 */ | |
4171 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) | |
4172 { | |
4173 int cbp, mb_type; | |
4174 const int xy= s->mb_x + s->mb_y*s->mb_stride; | |
4175 | |
4176 mb_type= s->current_picture.mb_type[xy]; | |
4177 cbp = s->cbp_table[xy]; | |
4178 | |
4179 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; | |
4180 | |
4181 if(s->current_picture.qscale_table[xy] != s->qscale){ | |
4182 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); | |
4183 } | |
4184 | |
4185 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { | |
4186 int i; | |
4187 for(i=0; i<4; i++){ | |
4188 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0]; | |
4189 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; | |
4190 } | |
4191 s->mb_intra = IS_INTRA(mb_type); | |
4192 | |
4193 if (IS_SKIP(mb_type)) { | |
4194 /* skip mb */ | |
4195 for(i=0;i<6;i++) | |
4196 s->block_last_index[i] = -1; | |
4197 s->mv_dir = MV_DIR_FORWARD; | |
4198 s->mv_type = MV_TYPE_16X16; | |
4199 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
4200 s->mcsel=1; | |
4201 s->mb_skipped = 0; | |
4202 }else{ | |
4203 s->mcsel=0; | |
4204 s->mb_skipped = 1; | |
4205 } | |
4206 }else if(s->mb_intra){ | |
4207 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); | |
4208 }else if(!s->mb_intra){ | |
4209 // s->mcsel= 0; //FIXME do we need to init that | |
4210 | |
4211 s->mv_dir = MV_DIR_FORWARD; | |
4212 if (IS_8X8(mb_type)) { | |
4213 s->mv_type = MV_TYPE_8X8; | |
4214 } else { | |
4215 s->mv_type = MV_TYPE_16X16; | |
4216 } | |
4217 } | |
4218 } else { /* I-Frame */ | |
4219 s->mb_intra = 1; | |
4220 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); | |
4221 } | |
4222 | |
4223 if (!IS_SKIP(mb_type)) { | |
4224 int i; | |
4225 s->dsp.clear_blocks(s->block[0]); | |
4226 /* decode each block */ | |
4227 for (i = 0; i < 6; i++) { | |
4228 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ | |
4229 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); | |
4230 return -1; | |
4231 } | |
4232 cbp+=cbp; | |
4233 } | |
4234 } | |
4235 | |
4236 /* per-MB end of slice check */ | |
4237 | |
4238 if(--s->mb_num_left <= 0){ | |
4239 if(mpeg4_is_resync(s)) | |
4240 return SLICE_END; | |
4241 else | |
4242 return SLICE_NOEND; | |
4243 }else{ | |
4244 if(mpeg4_is_resync(s)){ | |
4245 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; | |
4246 if(s->cbp_table[xy+delta]) | |
4247 return SLICE_END; | |
4248 } | |
4249 return SLICE_OK; | |
4250 } | |
4251 } | |
4252 | 1553 |
4253 /* Decodes RVLC of H.263+ UMV */ | 1554 /* Decodes RVLC of H.263+ UMV */ |
4254 static int h263p_decode_umotion(MpegEncContext * s, int pred) | 1555 static int h263p_decode_umotion(MpegEncContext * s, int pred) |
4255 { | 1556 { |
4256 int code = 0, sign; | 1557 int code = 0, sign; |
4800 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; | 2101 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; |
4801 } | 2102 } |
4802 | 2103 |
4803 if(v==0) | 2104 if(v==0) |
4804 return SLICE_END; | 2105 return SLICE_END; |
4805 } | |
4806 | |
4807 return SLICE_OK; | |
4808 } | |
4809 | |
4810 int ff_mpeg4_decode_mb(MpegEncContext *s, | |
4811 DCTELEM block[6][64]) | |
4812 { | |
4813 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
4814 int16_t *mot_val; | |
4815 static int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
4816 const int xy= s->mb_x + s->mb_y * s->mb_stride; | |
4817 | |
4818 assert(s->h263_pred); | |
4819 | |
4820 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { | |
4821 do{ | |
4822 if (get_bits1(&s->gb)) { | |
4823 /* skip mb */ | |
4824 s->mb_intra = 0; | |
4825 for(i=0;i<6;i++) | |
4826 s->block_last_index[i] = -1; | |
4827 s->mv_dir = MV_DIR_FORWARD; | |
4828 s->mv_type = MV_TYPE_16X16; | |
4829 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
4830 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; | |
4831 s->mcsel=1; | |
4832 s->mv[0][0][0]= get_amv(s, 0); | |
4833 s->mv[0][0][1]= get_amv(s, 1); | |
4834 | |
4835 s->mb_skipped = 0; | |
4836 }else{ | |
4837 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; | |
4838 s->mcsel=0; | |
4839 s->mv[0][0][0] = 0; | |
4840 s->mv[0][0][1] = 0; | |
4841 s->mb_skipped = 1; | |
4842 } | |
4843 goto end; | |
4844 } | |
4845 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
4846 if (cbpc < 0){ | |
4847 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
4848 return -1; | |
4849 } | |
4850 }while(cbpc == 20); | |
4851 | |
4852 s->dsp.clear_blocks(s->block[0]); | |
4853 dquant = cbpc & 8; | |
4854 s->mb_intra = ((cbpc & 4) != 0); | |
4855 if (s->mb_intra) goto intra; | |
4856 | |
4857 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
4858 s->mcsel= get_bits1(&s->gb); | |
4859 else s->mcsel= 0; | |
4860 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; | |
4861 | |
4862 cbp = (cbpc & 3) | (cbpy << 2); | |
4863 if (dquant) { | |
4864 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); | |
4865 } | |
4866 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE))) | |
4867 s->interlaced_dct= get_bits1(&s->gb); | |
4868 | |
4869 s->mv_dir = MV_DIR_FORWARD; | |
4870 if ((cbpc & 16) == 0) { | |
4871 if(s->mcsel){ | |
4872 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; | |
4873 /* 16x16 global motion prediction */ | |
4874 s->mv_type = MV_TYPE_16X16; | |
4875 mx= get_amv(s, 0); | |
4876 my= get_amv(s, 1); | |
4877 s->mv[0][0][0] = mx; | |
4878 s->mv[0][0][1] = my; | |
4879 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ | |
4880 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; | |
4881 /* 16x8 field motion prediction */ | |
4882 s->mv_type= MV_TYPE_FIELD; | |
4883 | |
4884 s->field_select[0][0]= get_bits1(&s->gb); | |
4885 s->field_select[0][1]= get_bits1(&s->gb); | |
4886 | |
4887 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); | |
4888 | |
4889 for(i=0; i<2; i++){ | |
4890 mx = h263_decode_motion(s, pred_x, s->f_code); | |
4891 if (mx >= 0xffff) | |
4892 return -1; | |
4893 | |
4894 my = h263_decode_motion(s, pred_y/2, s->f_code); | |
4895 if (my >= 0xffff) | |
4896 return -1; | |
4897 | |
4898 s->mv[0][i][0] = mx; | |
4899 s->mv[0][i][1] = my; | |
4900 } | |
4901 }else{ | |
4902 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; | |
4903 /* 16x16 motion prediction */ | |
4904 s->mv_type = MV_TYPE_16X16; | |
4905 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); | |
4906 mx = h263_decode_motion(s, pred_x, s->f_code); | |
4907 | |
4908 if (mx >= 0xffff) | |
4909 return -1; | |
4910 | |
4911 my = h263_decode_motion(s, pred_y, s->f_code); | |
4912 | |
4913 if (my >= 0xffff) | |
4914 return -1; | |
4915 s->mv[0][0][0] = mx; | |
4916 s->mv[0][0][1] = my; | |
4917 } | |
4918 } else { | |
4919 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; | |
4920 s->mv_type = MV_TYPE_8X8; | |
4921 for(i=0;i<4;i++) { | |
4922 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); | |
4923 mx = h263_decode_motion(s, pred_x, s->f_code); | |
4924 if (mx >= 0xffff) | |
4925 return -1; | |
4926 | |
4927 my = h263_decode_motion(s, pred_y, s->f_code); | |
4928 if (my >= 0xffff) | |
4929 return -1; | |
4930 s->mv[0][i][0] = mx; | |
4931 s->mv[0][i][1] = my; | |
4932 mot_val[0] = mx; | |
4933 mot_val[1] = my; | |
4934 } | |
4935 } | |
4936 } else if(s->pict_type==FF_B_TYPE) { | |
4937 int modb1; // first bit of modb | |
4938 int modb2; // second bit of modb | |
4939 int mb_type; | |
4940 | |
4941 s->mb_intra = 0; //B-frames never contain intra blocks | |
4942 s->mcsel=0; // ... true gmc blocks | |
4943 | |
4944 if(s->mb_x==0){ | |
4945 for(i=0; i<2; i++){ | |
4946 s->last_mv[i][0][0]= | |
4947 s->last_mv[i][0][1]= | |
4948 s->last_mv[i][1][0]= | |
4949 s->last_mv[i][1][1]= 0; | |
4950 } | |
4951 } | |
4952 | |
4953 /* if we skipped it in the future P Frame than skip it now too */ | |
4954 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC | |
4955 | |
4956 if(s->mb_skipped){ | |
4957 /* skip mb */ | |
4958 for(i=0;i<6;i++) | |
4959 s->block_last_index[i] = -1; | |
4960 | |
4961 s->mv_dir = MV_DIR_FORWARD; | |
4962 s->mv_type = MV_TYPE_16X16; | |
4963 s->mv[0][0][0] = 0; | |
4964 s->mv[0][0][1] = 0; | |
4965 s->mv[1][0][0] = 0; | |
4966 s->mv[1][0][1] = 0; | |
4967 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; | |
4968 goto end; | |
4969 } | |
4970 | |
4971 modb1= get_bits1(&s->gb); | |
4972 if(modb1){ | |
4973 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded | |
4974 cbp=0; | |
4975 }else{ | |
4976 modb2= get_bits1(&s->gb); | |
4977 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1); | |
4978 if(mb_type<0){ | |
4979 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n"); | |
4980 return -1; | |
4981 } | |
4982 mb_type= mb_type_b_map[ mb_type ]; | |
4983 if(modb2) cbp= 0; | |
4984 else{ | |
4985 s->dsp.clear_blocks(s->block[0]); | |
4986 cbp= get_bits(&s->gb, 6); | |
4987 } | |
4988 | |
4989 if ((!IS_DIRECT(mb_type)) && cbp) { | |
4990 if(get_bits1(&s->gb)){ | |
4991 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); | |
4992 } | |
4993 } | |
4994 | |
4995 if(!s->progressive_sequence){ | |
4996 if(cbp) | |
4997 s->interlaced_dct= get_bits1(&s->gb); | |
4998 | |
4999 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){ | |
5000 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; | |
5001 mb_type &= ~MB_TYPE_16x16; | |
5002 | |
5003 if(USES_LIST(mb_type, 0)){ | |
5004 s->field_select[0][0]= get_bits1(&s->gb); | |
5005 s->field_select[0][1]= get_bits1(&s->gb); | |
5006 } | |
5007 if(USES_LIST(mb_type, 1)){ | |
5008 s->field_select[1][0]= get_bits1(&s->gb); | |
5009 s->field_select[1][1]= get_bits1(&s->gb); | |
5010 } | |
5011 } | |
5012 } | |
5013 | |
5014 s->mv_dir = 0; | |
5015 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ | |
5016 s->mv_type= MV_TYPE_16X16; | |
5017 | |
5018 if(USES_LIST(mb_type, 0)){ | |
5019 s->mv_dir = MV_DIR_FORWARD; | |
5020 | |
5021 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
5022 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
5023 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
5024 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
5025 } | |
5026 | |
5027 if(USES_LIST(mb_type, 1)){ | |
5028 s->mv_dir |= MV_DIR_BACKWARD; | |
5029 | |
5030 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
5031 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
5032 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
5033 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
5034 } | |
5035 }else if(!IS_DIRECT(mb_type)){ | |
5036 s->mv_type= MV_TYPE_FIELD; | |
5037 | |
5038 if(USES_LIST(mb_type, 0)){ | |
5039 s->mv_dir = MV_DIR_FORWARD; | |
5040 | |
5041 for(i=0; i<2; i++){ | |
5042 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
5043 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
5044 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
5045 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
5046 } | |
5047 } | |
5048 | |
5049 if(USES_LIST(mb_type, 1)){ | |
5050 s->mv_dir |= MV_DIR_BACKWARD; | |
5051 | |
5052 for(i=0; i<2; i++){ | |
5053 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
5054 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
5055 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
5056 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
5057 } | |
5058 } | |
5059 } | |
5060 } | |
5061 | |
5062 if(IS_DIRECT(mb_type)){ | |
5063 if(IS_SKIP(mb_type)) | |
5064 mx=my=0; | |
5065 else{ | |
5066 mx = h263_decode_motion(s, 0, 1); | |
5067 my = h263_decode_motion(s, 0, 1); | |
5068 } | |
5069 | |
5070 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
5071 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); | |
5072 } | |
5073 s->current_picture.mb_type[xy]= mb_type; | |
5074 } else { /* I-Frame */ | |
5075 do{ | |
5076 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
5077 if (cbpc < 0){ | |
5078 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
5079 return -1; | |
5080 } | |
5081 }while(cbpc == 8); | |
5082 | |
5083 dquant = cbpc & 4; | |
5084 s->mb_intra = 1; | |
5085 intra: | |
5086 s->ac_pred = get_bits1(&s->gb); | |
5087 if(s->ac_pred) | |
5088 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; | |
5089 else | |
5090 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
5091 | |
5092 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
5093 if(cbpy<0){ | |
5094 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
5095 return -1; | |
5096 } | |
5097 cbp = (cbpc & 3) | (cbpy << 2); | |
5098 | |
5099 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; | |
5100 | |
5101 if (dquant) { | |
5102 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); | |
5103 } | |
5104 | |
5105 if(!s->progressive_sequence) | |
5106 s->interlaced_dct= get_bits1(&s->gb); | |
5107 | |
5108 s->dsp.clear_blocks(s->block[0]); | |
5109 /* decode each block */ | |
5110 for (i = 0; i < 6; i++) { | |
5111 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) | |
5112 return -1; | |
5113 cbp+=cbp; | |
5114 } | |
5115 goto end; | |
5116 } | |
5117 | |
5118 /* decode each block */ | |
5119 for (i = 0; i < 6; i++) { | |
5120 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) | |
5121 return -1; | |
5122 cbp+=cbp; | |
5123 } | |
5124 end: | |
5125 | |
5126 /* per-MB end of slice check */ | |
5127 if(s->codec_id==CODEC_ID_MPEG4){ | |
5128 if(mpeg4_is_resync(s)){ | |
5129 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; | |
5130 if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta]) | |
5131 return SLICE_OK; | |
5132 return SLICE_END; | |
5133 } | |
5134 } | 2106 } |
5135 | 2107 |
5136 return SLICE_OK; | 2108 return SLICE_OK; |
5137 } | 2109 } |
5138 | 2110 |
5292 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { | 2264 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
5293 /* aspected dimensions */ | 2265 /* aspected dimensions */ |
5294 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); | 2266 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
5295 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | 2267 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); |
5296 }else{ | 2268 }else{ |
5297 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; | 2269 s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info]; |
5298 } | 2270 } |
5299 } else { | 2271 } else { |
5300 width = h263_format[format][0]; | 2272 width = h263_format[format][0]; |
5301 height = h263_format[format][1]; | 2273 height = h263_format[format][1]; |
5302 s->avctx->sample_aspect_ratio= (AVRational){12,11}; | 2274 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
5401 } | 2373 } |
5402 | 2374 |
5403 return 0; | 2375 return 0; |
5404 } | 2376 } |
5405 | 2377 |
5406 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ | 2378 |
5407 int hours, minutes, seconds; | |
5408 | |
5409 hours= get_bits(gb, 5); | |
5410 minutes= get_bits(gb, 6); | |
5411 skip_bits1(gb); | |
5412 seconds= get_bits(gb, 6); | |
5413 | |
5414 s->time_base= seconds + 60*(minutes + 60*hours); | |
5415 | |
5416 skip_bits1(gb); | |
5417 skip_bits1(gb); | |
5418 | |
5419 return 0; | |
5420 } | |
5421 | |
5422 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){ | |
5423 int width, height, vo_ver_id; | |
5424 | |
5425 /* vol header */ | |
5426 skip_bits(gb, 1); /* random access */ | |
5427 s->vo_type= get_bits(gb, 8); | |
5428 if (get_bits1(gb) != 0) { /* is_ol_id */ | |
5429 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */ | |
5430 skip_bits(gb, 3); /* vo_priority */ | |
5431 } else { | |
5432 vo_ver_id = 1; | |
5433 } | |
5434 s->aspect_ratio_info= get_bits(gb, 4); | |
5435 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ | |
5436 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width | |
5437 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height | |
5438 }else{ | |
5439 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; | |
5440 } | |
5441 | |
5442 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */ | |
5443 int chroma_format= get_bits(gb, 2); | |
5444 if(chroma_format!=CHROMA_420){ | |
5445 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); | |
5446 } | |
5447 s->low_delay= get_bits1(gb); | |
5448 if(get_bits1(gb)){ /* vbv parameters */ | |
5449 get_bits(gb, 15); /* first_half_bitrate */ | |
5450 skip_bits1(gb); /* marker */ | |
5451 get_bits(gb, 15); /* latter_half_bitrate */ | |
5452 skip_bits1(gb); /* marker */ | |
5453 get_bits(gb, 15); /* first_half_vbv_buffer_size */ | |
5454 skip_bits1(gb); /* marker */ | |
5455 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ | |
5456 get_bits(gb, 11); /* first_half_vbv_occupancy */ | |
5457 skip_bits1(gb); /* marker */ | |
5458 get_bits(gb, 15); /* latter_half_vbv_occupancy */ | |
5459 skip_bits1(gb); /* marker */ | |
5460 } | |
5461 }else{ | |
5462 // set low delay flag only once the smartest? low delay detection won't be overriden | |
5463 if(s->picture_number==0) | |
5464 s->low_delay=0; | |
5465 } | |
5466 | |
5467 s->shape = get_bits(gb, 2); /* vol shape */ | |
5468 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n"); | |
5469 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ | |
5470 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n"); | |
5471 skip_bits(gb, 4); //video_object_layer_shape_extension | |
5472 } | |
5473 | |
5474 check_marker(gb, "before time_increment_resolution"); | |
5475 | |
5476 s->avctx->time_base.den = get_bits(gb, 16); | |
5477 if(!s->avctx->time_base.den){ | |
5478 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n"); | |
5479 return -1; | |
5480 } | |
5481 | |
5482 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; | |
5483 if (s->time_increment_bits < 1) | |
5484 s->time_increment_bits = 1; | |
5485 | |
5486 check_marker(gb, "before fixed_vop_rate"); | |
5487 | |
5488 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ | |
5489 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits); | |
5490 }else | |
5491 s->avctx->time_base.num = 1; | |
5492 | |
5493 s->t_frame=0; | |
5494 | |
5495 if (s->shape != BIN_ONLY_SHAPE) { | |
5496 if (s->shape == RECT_SHAPE) { | |
5497 skip_bits1(gb); /* marker */ | |
5498 width = get_bits(gb, 13); | |
5499 skip_bits1(gb); /* marker */ | |
5500 height = get_bits(gb, 13); | |
5501 skip_bits1(gb); /* marker */ | |
5502 if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */ | |
5503 s->width = width; | |
5504 s->height = height; | |
5505 } | |
5506 } | |
5507 | |
5508 s->progressive_sequence= | |
5509 s->progressive_frame= get_bits1(gb)^1; | |
5510 s->interlaced_dct=0; | |
5511 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) | |
5512 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */ | |
5513 if (vo_ver_id == 1) { | |
5514 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */ | |
5515 } else { | |
5516 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */ | |
5517 } | |
5518 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n"); | |
5519 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){ | |
5520 if(s->vol_sprite_usage==STATIC_SPRITE){ | |
5521 s->sprite_width = get_bits(gb, 13); | |
5522 skip_bits1(gb); /* marker */ | |
5523 s->sprite_height= get_bits(gb, 13); | |
5524 skip_bits1(gb); /* marker */ | |
5525 s->sprite_left = get_bits(gb, 13); | |
5526 skip_bits1(gb); /* marker */ | |
5527 s->sprite_top = get_bits(gb, 13); | |
5528 skip_bits1(gb); /* marker */ | |
5529 } | |
5530 s->num_sprite_warping_points= get_bits(gb, 6); | |
5531 if(s->num_sprite_warping_points > 3){ | |
5532 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points); | |
5533 s->num_sprite_warping_points= 0; | |
5534 return -1; | |
5535 } | |
5536 s->sprite_warping_accuracy = get_bits(gb, 2); | |
5537 s->sprite_brightness_change= get_bits1(gb); | |
5538 if(s->vol_sprite_usage==STATIC_SPRITE) | |
5539 s->low_latency_sprite= get_bits1(gb); | |
5540 } | |
5541 // FIXME sadct disable bit if verid!=1 && shape not rect | |
5542 | |
5543 if (get_bits1(gb) == 1) { /* not_8_bit */ | |
5544 s->quant_precision = get_bits(gb, 4); /* quant_precision */ | |
5545 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */ | |
5546 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision); | |
5547 } else { | |
5548 s->quant_precision = 5; | |
5549 } | |
5550 | |
5551 // FIXME a bunch of grayscale shape things | |
5552 | |
5553 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ | |
5554 int i, v; | |
5555 | |
5556 /* load default matrixes */ | |
5557 for(i=0; i<64; i++){ | |
5558 int j= s->dsp.idct_permutation[i]; | |
5559 v= ff_mpeg4_default_intra_matrix[i]; | |
5560 s->intra_matrix[j]= v; | |
5561 s->chroma_intra_matrix[j]= v; | |
5562 | |
5563 v= ff_mpeg4_default_non_intra_matrix[i]; | |
5564 s->inter_matrix[j]= v; | |
5565 s->chroma_inter_matrix[j]= v; | |
5566 } | |
5567 | |
5568 /* load custom intra matrix */ | |
5569 if(get_bits1(gb)){ | |
5570 int last=0; | |
5571 for(i=0; i<64; i++){ | |
5572 int j; | |
5573 v= get_bits(gb, 8); | |
5574 if(v==0) break; | |
5575 | |
5576 last= v; | |
5577 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; | |
5578 s->intra_matrix[j]= v; | |
5579 s->chroma_intra_matrix[j]= v; | |
5580 } | |
5581 | |
5582 /* replicate last value */ | |
5583 for(; i<64; i++){ | |
5584 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; | |
5585 s->intra_matrix[j]= last; | |
5586 s->chroma_intra_matrix[j]= last; | |
5587 } | |
5588 } | |
5589 | |
5590 /* load custom non intra matrix */ | |
5591 if(get_bits1(gb)){ | |
5592 int last=0; | |
5593 for(i=0; i<64; i++){ | |
5594 int j; | |
5595 v= get_bits(gb, 8); | |
5596 if(v==0) break; | |
5597 | |
5598 last= v; | |
5599 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; | |
5600 s->inter_matrix[j]= v; | |
5601 s->chroma_inter_matrix[j]= v; | |
5602 } | |
5603 | |
5604 /* replicate last value */ | |
5605 for(; i<64; i++){ | |
5606 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; | |
5607 s->inter_matrix[j]= last; | |
5608 s->chroma_inter_matrix[j]= last; | |
5609 } | |
5610 } | |
5611 | |
5612 // FIXME a bunch of grayscale shape things | |
5613 } | |
5614 | |
5615 if(vo_ver_id != 1) | |
5616 s->quarter_sample= get_bits1(gb); | |
5617 else s->quarter_sample=0; | |
5618 | |
5619 if(!get_bits1(gb)){ | |
5620 int pos= get_bits_count(gb); | |
5621 int estimation_method= get_bits(gb, 2); | |
5622 if(estimation_method<2){ | |
5623 if(!get_bits1(gb)){ | |
5624 s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque | |
5625 s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent | |
5626 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae | |
5627 s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae | |
5628 s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update | |
5629 s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling | |
5630 } | |
5631 if(!get_bits1(gb)){ | |
5632 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks | |
5633 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks | |
5634 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks | |
5635 s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks | |
5636 } | |
5637 if(!check_marker(gb, "in complexity estimation part 1")){ | |
5638 skip_bits_long(gb, pos - get_bits_count(gb)); | |
5639 goto no_cplx_est; | |
5640 } | |
5641 if(!get_bits1(gb)){ | |
5642 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs | |
5643 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines | |
5644 s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms | |
5645 s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits | |
5646 } | |
5647 if(!get_bits1(gb)){ | |
5648 s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm | |
5649 s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm | |
5650 s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q | |
5651 s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q | |
5652 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2 | |
5653 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4 | |
5654 } | |
5655 if(!check_marker(gb, "in complexity estimation part 2")){ | |
5656 skip_bits_long(gb, pos - get_bits_count(gb)); | |
5657 goto no_cplx_est; | |
5658 } | |
5659 if(estimation_method==1){ | |
5660 s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct | |
5661 s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel | |
5662 } | |
5663 }else | |
5664 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method); | |
5665 }else{ | |
5666 no_cplx_est: | |
5667 s->cplx_estimation_trash_i= | |
5668 s->cplx_estimation_trash_p= | |
5669 s->cplx_estimation_trash_b= 0; | |
5670 } | |
5671 | |
5672 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */ | |
5673 | |
5674 s->data_partitioning= get_bits1(gb); | |
5675 if(s->data_partitioning){ | |
5676 s->rvlc= get_bits1(gb); | |
5677 } | |
5678 | |
5679 if(vo_ver_id != 1) { | |
5680 s->new_pred= get_bits1(gb); | |
5681 if(s->new_pred){ | |
5682 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n"); | |
5683 skip_bits(gb, 2); /* requested upstream message type */ | |
5684 skip_bits1(gb); /* newpred segment type */ | |
5685 } | |
5686 s->reduced_res_vop= get_bits1(gb); | |
5687 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n"); | |
5688 } | |
5689 else{ | |
5690 s->new_pred=0; | |
5691 s->reduced_res_vop= 0; | |
5692 } | |
5693 | |
5694 s->scalability= get_bits1(gb); | |
5695 | |
5696 if (s->scalability) { | |
5697 GetBitContext bak= *gb; | |
5698 int ref_layer_id; | |
5699 int ref_layer_sampling_dir; | |
5700 int h_sampling_factor_n; | |
5701 int h_sampling_factor_m; | |
5702 int v_sampling_factor_n; | |
5703 int v_sampling_factor_m; | |
5704 | |
5705 s->hierachy_type= get_bits1(gb); | |
5706 ref_layer_id= get_bits(gb, 4); | |
5707 ref_layer_sampling_dir= get_bits1(gb); | |
5708 h_sampling_factor_n= get_bits(gb, 5); | |
5709 h_sampling_factor_m= get_bits(gb, 5); | |
5710 v_sampling_factor_n= get_bits(gb, 5); | |
5711 v_sampling_factor_m= get_bits(gb, 5); | |
5712 s->enhancement_type= get_bits1(gb); | |
5713 | |
5714 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 | |
5715 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ | |
5716 /* illegal scalability header (VERY broken encoder), | |
5717 * trying to workaround */ | |
5718 s->scalability=0; | |
5719 *gb= bak; | |
5720 }else | |
5721 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); | |
5722 | |
5723 // bin shape stuff FIXME | |
5724 } | |
5725 } | |
5726 return 0; | |
5727 } | |
5728 | |
5729 /** | |
5730 * decodes the user data stuff in the header. | |
5731 * Also initializes divx/xvid/lavc_version/build. | |
5732 */ | |
5733 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){ | |
5734 char buf[256]; | |
5735 int i; | |
5736 int e; | |
5737 int ver = 0, build = 0, ver2 = 0, ver3 = 0; | |
5738 char last; | |
5739 | |
5740 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){ | |
5741 if(show_bits(gb, 23) == 0) break; | |
5742 buf[i]= get_bits(gb, 8); | |
5743 } | |
5744 buf[i]=0; | |
5745 | |
5746 /* divx detection */ | |
5747 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last); | |
5748 if(e<2) | |
5749 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last); | |
5750 if(e>=2){ | |
5751 s->divx_version= ver; | |
5752 s->divx_build= build; | |
5753 s->divx_packed= e==3 && last=='p'; | |
5754 if(s->divx_packed && !s->showed_packed_warning) { | |
5755 av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n"); | |
5756 s->showed_packed_warning=1; | |
5757 } | |
5758 } | |
5759 | |
5760 /* ffmpeg detection */ | |
5761 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3; | |
5762 if(e!=4) | |
5763 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); | |
5764 if(e!=4){ | |
5765 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1; | |
5766 if (e>1) | |
5767 build= (ver<<16) + (ver2<<8) + ver3; | |
5768 } | |
5769 if(e!=4){ | |
5770 if(strcmp(buf, "ffmpeg")==0){ | |
5771 s->lavc_build= 4600; | |
5772 } | |
5773 } | |
5774 if(e==4){ | |
5775 s->lavc_build= build; | |
5776 } | |
5777 | |
5778 /* Xvid detection */ | |
5779 e=sscanf(buf, "XviD%d", &build); | |
5780 if(e==1){ | |
5781 s->xvid_build= build; | |
5782 } | |
5783 | |
5784 return 0; | |
5785 } | |
5786 | |
5787 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){ | |
5788 int time_incr, time_increment; | |
5789 | |
5790 s->pict_type = get_bits(gb, 2) + FF_I_TYPE; /* pict type: I = 0 , P = 1 */ | |
5791 if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ | |
5792 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n"); | |
5793 s->low_delay=0; | |
5794 } | |
5795 | |
5796 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; | |
5797 if(s->partitioned_frame) | |
5798 s->decode_mb= mpeg4_decode_partitioned_mb; | |
5799 else | |
5800 s->decode_mb= ff_mpeg4_decode_mb; | |
5801 | |
5802 time_incr=0; | |
5803 while (get_bits1(gb) != 0) | |
5804 time_incr++; | |
5805 | |
5806 check_marker(gb, "before time_increment"); | |
5807 | |
5808 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){ | |
5809 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n"); | |
5810 | |
5811 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
5812 if ( s->pict_type == FF_P_TYPE | |
5813 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
5814 if((show_bits(gb, s->time_increment_bits+6)&0x37) == 0x30) break; | |
5815 }else | |
5816 if((show_bits(gb, s->time_increment_bits+5)&0x1F) == 0x18) break; | |
5817 } | |
5818 | |
5819 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); | |
5820 } | |
5821 | |
5822 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further | |
5823 else time_increment= get_bits(gb, s->time_increment_bits); | |
5824 | |
5825 if(s->pict_type!=FF_B_TYPE){ | |
5826 s->last_time_base= s->time_base; | |
5827 s->time_base+= time_incr; | |
5828 s->time= s->time_base*s->avctx->time_base.den + time_increment; | |
5829 if(s->workaround_bugs&FF_BUG_UMP4){ | |
5830 if(s->time < s->last_non_b_time){ | |
5831 /* header is not mpeg-4-compatible, broken encoder, | |
5832 * trying to workaround */ | |
5833 s->time_base++; | |
5834 s->time+= s->avctx->time_base.den; | |
5835 } | |
5836 } | |
5837 s->pp_time= s->time - s->last_non_b_time; | |
5838 s->last_non_b_time= s->time; | |
5839 }else{ | |
5840 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment; | |
5841 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); | |
5842 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
5843 /* messed up order, maybe after seeking? skipping current b-frame */ | |
5844 return FRAME_SKIPPED; | |
5845 } | |
5846 ff_mpeg4_init_direct_mv(s); | |
5847 | |
5848 if(s->t_frame==0) s->t_frame= s->pb_time; | |
5849 if(s->t_frame==0) s->t_frame=1; // 1/0 protection | |
5850 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) | |
5851 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
5852 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) | |
5853 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
5854 if(!s->progressive_sequence){ | |
5855 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) | |
5856 return FRAME_SKIPPED; | |
5857 } | |
5858 } | |
5859 | |
5860 if(s->avctx->time_base.num) | |
5861 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num; | |
5862 else | |
5863 s->current_picture_ptr->pts= AV_NOPTS_VALUE; | |
5864 if(s->avctx->debug&FF_DEBUG_PTS) | |
5865 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts); | |
5866 | |
5867 check_marker(gb, "before vop_coded"); | |
5868 | |
5869 /* vop coded */ | |
5870 if (get_bits1(gb) != 1){ | |
5871 if(s->avctx->debug&FF_DEBUG_PICT_INFO) | |
5872 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n"); | |
5873 return FRAME_SKIPPED; | |
5874 } | |
5875 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE | |
5876 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { | |
5877 /* rounding type for motion estimation */ | |
5878 s->no_rounding = get_bits1(gb); | |
5879 } else { | |
5880 s->no_rounding = 0; | |
5881 } | |
5882 //FIXME reduced res stuff | |
5883 | |
5884 if (s->shape != RECT_SHAPE) { | |
5885 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) { | |
5886 int width, height, hor_spat_ref, ver_spat_ref; | |
5887 | |
5888 width = get_bits(gb, 13); | |
5889 skip_bits1(gb); /* marker */ | |
5890 height = get_bits(gb, 13); | |
5891 skip_bits1(gb); /* marker */ | |
5892 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */ | |
5893 skip_bits1(gb); /* marker */ | |
5894 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ | |
5895 } | |
5896 skip_bits1(gb); /* change_CR_disable */ | |
5897 | |
5898 if (get_bits1(gb) != 0) { | |
5899 skip_bits(gb, 8); /* constant_alpha_value */ | |
5900 } | |
5901 } | |
5902 //FIXME complexity estimation stuff | |
5903 | |
5904 if (s->shape != BIN_ONLY_SHAPE) { | |
5905 skip_bits_long(gb, s->cplx_estimation_trash_i); | |
5906 if(s->pict_type != FF_I_TYPE) | |
5907 skip_bits_long(gb, s->cplx_estimation_trash_p); | |
5908 if(s->pict_type == FF_B_TYPE) | |
5909 skip_bits_long(gb, s->cplx_estimation_trash_b); | |
5910 | |
5911 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ]; | |
5912 if(!s->progressive_sequence){ | |
5913 s->top_field_first= get_bits1(gb); | |
5914 s->alternate_scan= get_bits1(gb); | |
5915 }else | |
5916 s->alternate_scan= 0; | |
5917 } | |
5918 | |
5919 if(s->alternate_scan){ | |
5920 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); | |
5921 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
5922 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
5923 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
5924 } else{ | |
5925 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); | |
5926 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
5927 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
5928 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
5929 } | |
5930 | |
5931 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ | |
5932 mpeg4_decode_sprite_trajectory(s, gb); | |
5933 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n"); | |
5934 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n"); | |
5935 } | |
5936 | |
5937 if (s->shape != BIN_ONLY_SHAPE) { | |
5938 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision); | |
5939 if(s->qscale==0){ | |
5940 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n"); | |
5941 return -1; // makes no sense to continue, as there is nothing left from the image then | |
5942 } | |
5943 | |
5944 if (s->pict_type != FF_I_TYPE) { | |
5945 s->f_code = get_bits(gb, 3); /* fcode_for */ | |
5946 if(s->f_code==0){ | |
5947 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n"); | |
5948 return -1; // makes no sense to continue, as the MV decoding will break very quickly | |
5949 } | |
5950 }else | |
5951 s->f_code=1; | |
5952 | |
5953 if (s->pict_type == FF_B_TYPE) { | |
5954 s->b_code = get_bits(gb, 3); | |
5955 }else | |
5956 s->b_code=1; | |
5957 | |
5958 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
5959 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", | |
5960 s->qscale, s->f_code, s->b_code, | |
5961 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")), | |
5962 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, | |
5963 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, | |
5964 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); | |
5965 } | |
5966 | |
5967 if(!s->scalability){ | |
5968 if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) { | |
5969 skip_bits1(gb); // vop shape coding type | |
5970 } | |
5971 }else{ | |
5972 if(s->enhancement_type){ | |
5973 int load_backward_shape= get_bits1(gb); | |
5974 if(load_backward_shape){ | |
5975 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); | |
5976 } | |
5977 } | |
5978 skip_bits(gb, 2); //ref_select_code | |
5979 } | |
5980 } | |
5981 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/ | |
5982 // note we cannot detect divx5 without b-frames easily (although it's buggy too) | |
5983 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){ | |
5984 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n"); | |
5985 s->low_delay=1; | |
5986 } | |
5987 | |
5988 s->picture_number++; // better than pic number==0 always ;) | |
5989 | |
5990 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support | |
5991 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
5992 | |
5993 if(s->workaround_bugs&FF_BUG_EDGE){ | |
5994 s->h_edge_pos= s->width; | |
5995 s->v_edge_pos= s->height; | |
5996 } | |
5997 return 0; | |
5998 } | |
5999 | |
6000 /** | |
6001 * decode mpeg4 headers | |
6002 * @return <0 if no VOP found (or a damaged one) | |
6003 * FRAME_SKIPPED if a not coded VOP is found | |
6004 * 0 if a VOP is found | |
6005 */ | |
6006 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb) | |
6007 { | |
6008 int startcode, v; | |
6009 | |
6010 /* search next start code */ | |
6011 align_get_bits(gb); | |
6012 | |
6013 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){ | |
6014 skip_bits(gb, 24); | |
6015 if(get_bits(gb, 8) == 0xF0) | |
6016 goto end; | |
6017 } | |
6018 | |
6019 startcode = 0xff; | |
6020 for(;;) { | |
6021 if(get_bits_count(gb) >= gb->size_in_bits){ | |
6022 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){ | |
6023 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits); | |
6024 return FRAME_SKIPPED; //divx bug | |
6025 }else | |
6026 return -1; //end of stream | |
6027 } | |
6028 | |
6029 /* use the bits after the test */ | |
6030 v = get_bits(gb, 8); | |
6031 startcode = ((startcode << 8) | v) & 0xffffffff; | |
6032 | |
6033 if((startcode&0xFFFFFF00) != 0x100) | |
6034 continue; //no startcode | |
6035 | |
6036 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
6037 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode); | |
6038 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start"); | |
6039 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start"); | |
6040 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); | |
6041 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start"); | |
6042 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); | |
6043 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start"); | |
6044 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End"); | |
6045 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data"); | |
6046 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start"); | |
6047 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error"); | |
6048 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start"); | |
6049 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start"); | |
6050 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start"); | |
6051 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start"); | |
6052 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start"); | |
6053 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start"); | |
6054 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start"); | |
6055 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start"); | |
6056 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start"); | |
6057 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start"); | |
6058 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start"); | |
6059 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start"); | |
6060 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start"); | |
6061 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start"); | |
6062 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start"); | |
6063 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved"); | |
6064 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start"); | |
6065 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); | |
6066 } | |
6067 | |
6068 if(startcode >= 0x120 && startcode <= 0x12F){ | |
6069 if(decode_vol_header(s, gb) < 0) | |
6070 return -1; | |
6071 } | |
6072 else if(startcode == USER_DATA_STARTCODE){ | |
6073 decode_user_data(s, gb); | |
6074 } | |
6075 else if(startcode == GOP_STARTCODE){ | |
6076 mpeg4_decode_gop_header(s, gb); | |
6077 } | |
6078 else if(startcode == VOP_STARTCODE){ | |
6079 break; | |
6080 } | |
6081 | |
6082 align_get_bits(gb); | |
6083 startcode = 0xff; | |
6084 } | |
6085 end: | |
6086 if(s->flags& CODEC_FLAG_LOW_DELAY) | |
6087 s->low_delay=1; | |
6088 s->avctx->has_b_frames= !s->low_delay; | |
6089 return decode_vop_header(s, gb); | |
6090 } |