2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
5 * Copyright (c) 2001 Juan J. Sierralta P.
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * ac prediction encoding, b-frame support, error resilience, optimizations,
23 * qpel decoding, gmc decoding, interlaced decoding,
24 * by Michael Niedermayer <michaelni@gmx.at>
38 #include "mpegvideo.h"
40 #include "mpeg4data.h"
45 #define INTRA_MCBPC_VLC_BITS 6
46 #define INTER_MCBPC_VLC_BITS 7
47 #define CBPY_VLC_BITS 6
50 #define SPRITE_TRAJ_VLC_BITS 6
51 #define MB_TYPE_B_VLC_BITS 4
52 #define TEX_VLC_BITS 9
53 #define H263_MBTYPE_B_VLC_BITS 6
54 #define CBPC_B_VLC_BITS 3
56 #ifdef CONFIG_ENCODERS
57 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59 static void h263p_encode_umotion(MpegEncContext * s, int val);
60 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61 int n, int dc, uint8_t *scan_table,
62 PutBitContext *dc_pb, PutBitContext *ac_pb);
65 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
66 static int h263p_decode_umotion(MpegEncContext * s, int pred);
67 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
69 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
70 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
71 int n, int coded, int intra, int rvlc);
72 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
74 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
75 #ifdef CONFIG_ENCODERS
76 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
77 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
78 #endif //CONFIG_ENCODERS
79 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
80 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82 #ifdef CONFIG_ENCODERS
83 static uint8_t uni_DCtab_lum_len[512];
84 static uint8_t uni_DCtab_chrom_len[512];
85 static uint16_t uni_DCtab_lum_bits[512];
86 static uint16_t uni_DCtab_chrom_bits[512];
88 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
89 static uint8_t fcode_tab[MAX_MV*2+1];
90 static uint8_t umv_fcode_tab[MAX_MV*2+1];
92 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
93 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
94 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
95 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
96 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
97 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
98 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
100 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
113 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
114 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
119 int h263_get_picture_format(int width, int height)
123 if (width == 128 && height == 96)
125 else if (width == 176 && height == 144)
127 else if (width == 352 && height == 288)
129 else if (width == 704 && height == 576)
131 else if (width == 1408 && height == 1152)
138 #ifdef CONFIG_ENCODERS
140 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
143 if(aspect.num==0) aspect= (AVRational){1,1};
146 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
147 s->aspect_ratio_info=i;
152 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
155 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
159 align_put_bits(&s->pb);
161 put_bits(&s->pb, 17, 1);
162 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
163 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
164 s->avctx->time_base.den) & 0xff); /* TemporalReference */
165 if (s->width == 352 && s->height == 288)
167 else if (s->width == 176 && s->height == 144)
169 else if (s->width == 128 && s->height == 96)
171 else if (s->width == 320 && s->height == 240)
173 else if (s->width == 160 && s->height == 120)
175 else if (s->width <= 255 && s->height <= 255)
176 format = 0; /* use 1 byte width & height */
178 format = 1; /* use 2 bytes width & height */
179 put_bits(&s->pb, 3, format); /* PictureSize */
181 put_bits(&s->pb, 8, s->width);
182 put_bits(&s->pb, 8, s->height);
183 } else if (format == 1) {
184 put_bits(&s->pb, 16, s->width);
185 put_bits(&s->pb, 16, s->height);
187 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
188 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
189 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
190 put_bits(&s->pb, 1, 0); /* ExtraInformation */
194 s->c_dc_scale_table= ff_aic_dc_scale_table;
197 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
201 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
203 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
204 int best_clock_code=1;
206 int best_error= INT_MAX;
211 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
212 div= clip(1, div, 127);
213 error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
214 if(error < best_error){
221 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
222 coded_frame_rate= 1800000;
223 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
225 align_put_bits(&s->pb);
227 /* Update the pointer to last GOB */
228 s->ptr_lastgob = pbBufPtr(&s->pb);
229 put_bits(&s->pb, 22, 0x20); /* PSC */
230 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
231 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
232 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
234 put_bits(&s->pb, 1, 1); /* marker */
235 put_bits(&s->pb, 1, 0); /* h263 id */
236 put_bits(&s->pb, 1, 0); /* split screen off */
237 put_bits(&s->pb, 1, 0); /* camera off */
238 put_bits(&s->pb, 1, 0); /* freeze picture release off */
240 format = h263_get_picture_format(s->width, s->height);
243 put_bits(&s->pb, 3, format);
244 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
245 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
246 of H.263v1 UMV implies to check the predicted MV after
247 calculation of the current MB to see if we're on the limits */
248 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
249 put_bits(&s->pb, 1, 0); /* SAC: off */
250 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
251 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
252 put_bits(&s->pb, 5, s->qscale);
253 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
257 /* H.263 Plus PTYPE */
259 put_bits(&s->pb, 3, 7);
260 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
262 put_bits(&s->pb,3,6); /* Custom Source Format */
264 put_bits(&s->pb, 3, format);
266 put_bits(&s->pb,1, s->custom_pcf);
267 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
268 put_bits(&s->pb,1,0); /* SAC: off */
269 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
270 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
271 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
272 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
273 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
274 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
275 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
276 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
277 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278 put_bits(&s->pb,3,0); /* Reserved */
280 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
282 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
283 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
284 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
285 put_bits(&s->pb,2,0); /* Reserved */
286 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
288 /* This should be here if PLUSPTYPE */
289 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
292 /* Custom Picture Format (CPFMT) */
293 aspect_to_info(s, s->avctx->sample_aspect_ratio);
295 put_bits(&s->pb,4,s->aspect_ratio_info);
296 put_bits(&s->pb,9,(s->width >> 2) - 1);
297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298 put_bits(&s->pb,9,(s->height >> 2));
299 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
300 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
301 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
306 put_bits(&s->pb, 1, best_clock_code);
307 put_bits(&s->pb, 7, best_divisor);
309 put_bits(&s->pb, 2, (temp_ref>>8)&3);
312 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
314 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
315 //FIXME check actual requested range
316 put_bits(&s->pb,2,1); /* unlimited */
317 if(s->h263_slice_structured)
318 put_bits(&s->pb,2,0); /* no weird submodes */
320 put_bits(&s->pb, 5, s->qscale);
323 put_bits(&s->pb, 1, 0); /* no PEI */
325 if(s->h263_slice_structured){
326 put_bits(&s->pb, 1, 1);
328 assert(s->mb_x == 0 && s->mb_y == 0);
329 ff_h263_encode_mba(s);
331 put_bits(&s->pb, 1, 1);
336 s->c_dc_scale_table= ff_aic_dc_scale_table;
339 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344 * Encodes a group of blocks header.
346 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
348 put_bits(&s->pb, 17, 1); /* GBSC */
350 if(s->h263_slice_structured){
351 put_bits(&s->pb, 1, 1);
353 ff_h263_encode_mba(s);
356 put_bits(&s->pb, 1, 1);
357 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
358 put_bits(&s->pb, 1, 1);
359 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
361 int gob_number= mb_line / s->gob_index;
363 put_bits(&s->pb, 5, gob_number); /* GN */
364 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
365 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
369 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
374 for(j=1; j<=block_last_index; j++){
375 const int index= scantable[j];
376 int level= block[index];
379 if((level&(~127)) == 0){
380 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
381 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
383 rate += s->ac_esc_length;
393 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
397 int8_t * const qscale_table= s->current_picture.qscale_table;
399 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
402 int16_t *ac_val, *ac_val1;
404 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
406 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
409 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
411 ac_val-= s->block_wrap[n]*16;
412 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
415 const int level= block[n][s->dsp.idct_permutation[i ]];
416 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
417 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
421 /* different qscale, we must rescale */
423 const int level= block[n][s->dsp.idct_permutation[i ]];
424 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
425 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
429 st[n]= s->intra_h_scantable.permutated;
431 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
432 /* left prediction */
434 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
437 const int level= block[n][s->dsp.idct_permutation[i<<3]];
438 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
440 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
443 /* different qscale, we must rescale */
445 const int level= block[n][s->dsp.idct_permutation[i<<3]];
446 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
448 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
451 st[n]= s->intra_v_scantable.permutated;
454 for(i=63; i>0; i--) //FIXME optimize
455 if(block[n][ st[n][i] ]) break;
456 s->block_last_index[n]= i;
458 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
464 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
467 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
470 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
472 st[n]= s->intra_scantable.permutated;
476 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
479 /* left prediction */
481 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
488 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
490 void ff_clean_h263_qscales(MpegEncContext *s){
492 int8_t * const qscale_table= s->current_picture.qscale_table;
494 for(i=1; i<s->mb_num; i++){
495 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
496 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
498 for(i=s->mb_num-2; i>=0; i--){
499 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
500 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
503 if(s->codec_id != CODEC_ID_H263P){
504 for(i=1; i<s->mb_num; i++){
505 int mb_xy= s->mb_index2xy[i];
507 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
508 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
509 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
516 * modify mb_type & qscale so that encoding is acually possible in mpeg4
518 void ff_clean_mpeg4_qscales(MpegEncContext *s){
520 int8_t * const qscale_table= s->current_picture.qscale_table;
522 ff_clean_h263_qscales(s);
524 if(s->pict_type== B_TYPE){
526 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
528 for(i=0; i<s->mb_num; i++){
529 int mb_xy= s->mb_index2xy[i];
530 odd += qscale_table[mb_xy]&1;
533 if(2*odd > s->mb_num) odd=1;
536 for(i=0; i<s->mb_num; i++){
537 int mb_xy= s->mb_index2xy[i];
538 if((qscale_table[mb_xy]&1) != odd)
539 qscale_table[mb_xy]++;
540 if(qscale_table[mb_xy] > 31)
541 qscale_table[mb_xy]= 31;
544 for(i=1; i<s->mb_num; i++){
545 int mb_xy= s->mb_index2xy[i];
546 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
547 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
548 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
554 #endif //CONFIG_ENCODERS
556 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
557 #define tab_bias (tab_size/2)
559 static void ff_mpeg4_init_direct_mv(MpegEncContext *s){
561 for(i=0; i<tab_size; i++){
562 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;
567 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
568 int xy= s->block_index[i];
569 uint16_t time_pp= s->pp_time;
570 uint16_t time_pb= s->pb_time;
573 p_mx= s->next_picture.motion_val[0][xy][0];
574 if((unsigned)(p_mx + tab_bias) < tab_size){
575 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
576 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
577 : s->direct_scale_mv[1][p_mx + tab_bias];
579 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
580 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
581 : p_mx*(time_pb - time_pp)/time_pp;
583 p_my= s->next_picture.motion_val[0][xy][1];
584 if((unsigned)(p_my + tab_bias) < tab_size){
585 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
586 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
587 : s->direct_scale_mv[1][p_my + tab_bias];
589 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
590 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
591 : p_my*(time_pb - time_pp)/time_pp;
600 * @return the mb_type
602 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
603 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
604 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
605 uint16_t time_pp= s->pp_time;
606 uint16_t time_pb= s->pb_time;
609 //FIXME avoid divides
610 // try special case with shifts for 1 and 3 B-frames?
612 if(IS_8X8(colocated_mb_type)){
613 s->mv_type = MV_TYPE_8X8;
615 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
617 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
618 } else if(IS_INTERLACED(colocated_mb_type)){
619 s->mv_type = MV_TYPE_FIELD;
621 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
622 s->field_select[0][i]= field_select;
623 s->field_select[1][i]= i;
624 if(s->top_field_first){
625 time_pp= s->pp_field_time - field_select + i;
626 time_pb= s->pb_field_time - field_select + i;
628 time_pp= s->pp_field_time + field_select - i;
629 time_pb= s->pb_field_time + field_select - i;
631 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
632 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
633 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
634 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
635 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
636 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
638 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
640 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
641 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
642 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
643 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
644 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
645 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
646 s->mv_type= MV_TYPE_16X16;
648 s->mv_type= MV_TYPE_8X8;
649 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
653 void ff_h263_update_motion_val(MpegEncContext * s){
654 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
655 //FIXME a lot of that is only needed for !low_delay
656 const int wrap = s->b8_stride;
657 const int xy = s->block_index[0];
659 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
661 if(s->mv_type != MV_TYPE_8X8){
662 int motion_x, motion_y;
666 } else if (s->mv_type == MV_TYPE_16X16) {
667 motion_x = s->mv[0][0][0];
668 motion_y = s->mv[0][0][1];
669 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
671 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
672 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
673 motion_x = (motion_x>>1) | (motion_x&1);
675 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
676 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
678 s->current_picture.ref_index[0][xy ]=
679 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
680 s->current_picture.ref_index[0][xy + wrap ]=
681 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
684 /* no update if 8X8 because it has been done during parsing */
685 s->current_picture.motion_val[0][xy][0] = motion_x;
686 s->current_picture.motion_val[0][xy][1] = motion_y;
687 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
688 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
689 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
690 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
691 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
692 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
695 if(s->encoding){ //FIXME encoding MUST be cleaned up
696 if (s->mv_type == MV_TYPE_8X8)
697 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
699 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
701 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
705 #ifdef CONFIG_ENCODERS
707 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
708 int l, bit_size, code;
713 bit_size = f_code - 1;
714 /* modulo encoding */
715 l= INT_BIT - 6 - bit_size;
718 code = (val >> bit_size) + 1;
720 return mvtab[code][1] + 1 + bit_size;
724 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
725 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
726 skip_put_bits(&s->pb,
727 h263_get_motion_length(s, x, f_code)
728 +h263_get_motion_length(s, y, f_code));
730 ff_h263_encode_motion(s, x, f_code);
731 ff_h263_encode_motion(s, y, f_code);
735 static inline int get_p_cbp(MpegEncContext * s,
736 DCTELEM block[6][64],
737 int motion_x, int motion_y){
740 if(s->flags & CODEC_FLAG_CBP_RD){
741 int best_cbpy_score= INT_MAX;
742 int best_cbpc_score= INT_MAX;
743 int cbpc = (-1), cbpy= (-1);
744 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
745 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
748 int score= inter_MCBPC_bits[i + offset] * lambda;
749 if(i&1) score += s->coded_score[5];
750 if(i&2) score += s->coded_score[4];
752 if(score < best_cbpc_score){
753 best_cbpc_score= score;
759 int score= cbpy_tab[i ^ 0xF][1] * lambda;
760 if(i&1) score += s->coded_score[3];
761 if(i&2) score += s->coded_score[2];
762 if(i&4) score += s->coded_score[1];
763 if(i&8) score += s->coded_score[0];
765 if(score < best_cbpy_score){
766 best_cbpy_score= score;
771 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
772 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
776 for (i = 0; i < 6; i++) {
777 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
778 s->block_last_index[i]= -1;
779 memset(s->block[i], 0, sizeof(DCTELEM)*64);
784 for (i = 0; i < 6; i++) {
785 if (s->block_last_index[i] >= 0)
792 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
793 int motion_x, int motion_y, int mb_type){
796 if(s->flags & CODEC_FLAG_CBP_RD){
798 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
801 if(s->coded_score[i] < 0){
802 score += s->coded_score[i];
809 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
810 zero_score-= 4; //2*MV + mb_type + cbp bit
814 if(zero_score <= score){
819 for (i = 0; i < 6; i++) {
820 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
821 s->block_last_index[i]= -1;
822 memset(s->block[i], 0, sizeof(DCTELEM)*64);
826 for (i = 0; i < 6; i++) {
827 if (s->block_last_index[i] >= 0)
834 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
835 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
839 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
840 for (i = 0; i < 6; i++) {
841 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
844 /* encode each block */
845 for (i = 0; i < 6; i++) {
846 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
850 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
851 for (i = 0; i < 6; i++) {
852 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
855 /* encode each block */
856 for (i = 0; i < 6; i++) {
857 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
863 void mpeg4_encode_mb(MpegEncContext * s,
864 DCTELEM block[6][64],
865 int motion_x, int motion_y)
867 int cbpc, cbpy, pred_x, pred_y;
868 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
869 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
870 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
871 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
872 const int dquant_code[5]= {1,0,9,2,3};
874 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
878 if(s->pict_type==B_TYPE){
879 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
880 int mb_type= mb_type_table[s->mv_dir];
887 s->last_mv[i][1][1]= 0;
891 assert(s->dquant>=-2 && s->dquant<=2);
892 assert((s->dquant&1)==0);
895 /* nothing to do if this MB was skipped in the next P Frame */
896 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
902 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
903 s->qscale -= s->dquant;
909 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
911 if ((cbp | motion_x | motion_y | mb_type) ==0) {
912 /* direct MB with MV={0,0} */
913 assert(s->dquant==0);
915 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
917 if(interleaved_stats){
925 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
926 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
927 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
928 if(cbp) put_bits(&s->pb, 6, cbp);
932 put_bits(&s->pb, 2, (s->dquant>>2)+3);
934 put_bits(&s->pb, 1, 0);
936 s->qscale -= s->dquant;
938 if(!s->progressive_sequence){
940 put_bits(&s->pb, 1, s->interlaced_dct);
941 if(mb_type) // not direct mode
942 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
945 if(interleaved_stats){
946 s->misc_bits+= get_bits_diff(s);
950 assert(s->mv_dir & MV_DIRECT);
951 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
955 assert(mb_type > 0 && mb_type < 4);
956 if(s->mv_type != MV_TYPE_FIELD){
957 if(s->mv_dir & MV_DIR_FORWARD){
958 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
959 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
960 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
961 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
964 if(s->mv_dir & MV_DIR_BACKWARD){
965 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
966 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
967 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
968 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
972 if(s->mv_dir & MV_DIR_FORWARD){
973 put_bits(&s->pb, 1, s->field_select[0][0]);
974 put_bits(&s->pb, 1, s->field_select[0][1]);
976 if(s->mv_dir & MV_DIR_BACKWARD){
977 put_bits(&s->pb, 1, s->field_select[1][0]);
978 put_bits(&s->pb, 1, s->field_select[1][1]);
980 if(s->mv_dir & MV_DIR_FORWARD){
982 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
983 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
984 s->last_mv[0][i][0]= s->mv[0][i][0];
985 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
989 if(s->mv_dir & MV_DIR_BACKWARD){
991 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
992 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
993 s->last_mv[1][i][0]= s->mv[1][i][0];
994 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1001 if(interleaved_stats){
1002 s->mv_bits+= get_bits_diff(s);
1005 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1007 if(interleaved_stats){
1008 s->p_tex_bits+= get_bits_diff(s);
1011 }else{ /* s->pict_type==B_TYPE */
1012 cbp= get_p_cbp(s, block, motion_x, motion_y);
1014 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1015 /* check if the B frames can skip it too, as we must skip it if we skip here
1016 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1017 if(s->max_b_frames>0){
1024 if(x+16 > s->width) x= s->width-16;
1025 if(y+16 > s->height) y= s->height-16;
1027 offset= x + y*s->linesize;
1028 p_pic= s->new_picture.data[0] + offset;
1031 for(i=0; i<s->max_b_frames; i++){
1034 Picture *pic= s->reordered_input_picture[i+1];
1036 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1038 b_pic= pic->data[0] + offset;
1039 if(pic->type != FF_BUFFER_TYPE_SHARED)
1040 b_pic+= INPLACE_OFFSET;
1041 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1042 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1050 if(s->mb_skipped==1){
1051 /* skip macroblock */
1052 put_bits(&s->pb, 1, 1);
1054 if(interleaved_stats){
1064 put_bits(&s->pb, 1, 0); /* mb coded */
1068 if(s->mv_type==MV_TYPE_16X16){
1069 if(s->dquant) cbpc+= 8;
1071 inter_MCBPC_bits[cbpc],
1072 inter_MCBPC_code[cbpc]);
1074 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1076 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1078 if(!s->progressive_sequence){
1080 put_bits(pb2, 1, s->interlaced_dct);
1081 put_bits(pb2, 1, 0);
1084 if(interleaved_stats){
1085 s->misc_bits+= get_bits_diff(s);
1088 /* motion vectors: 16x16 mode */
1089 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1091 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1092 motion_y - pred_y, s->f_code);
1093 }else if(s->mv_type==MV_TYPE_FIELD){
1094 if(s->dquant) cbpc+= 8;
1096 inter_MCBPC_bits[cbpc],
1097 inter_MCBPC_code[cbpc]);
1099 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1101 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1103 assert(!s->progressive_sequence);
1105 put_bits(pb2, 1, s->interlaced_dct);
1106 put_bits(pb2, 1, 1);
1108 if(interleaved_stats){
1109 s->misc_bits+= get_bits_diff(s);
1112 /* motion vectors: 16x8 interlaced mode */
1113 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1116 put_bits(&s->pb, 1, s->field_select[0][0]);
1117 put_bits(&s->pb, 1, s->field_select[0][1]);
1119 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1120 s->mv[0][0][1] - pred_y, s->f_code);
1121 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1122 s->mv[0][1][1] - pred_y, s->f_code);
1124 assert(s->mv_type==MV_TYPE_8X8);
1126 inter_MCBPC_bits[cbpc+16],
1127 inter_MCBPC_code[cbpc+16]);
1128 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1130 if(!s->progressive_sequence){
1132 put_bits(pb2, 1, s->interlaced_dct);
1135 if(interleaved_stats){
1136 s->misc_bits+= get_bits_diff(s);
1140 /* motion vectors: 8x8 mode*/
1141 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1143 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1144 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1148 if(interleaved_stats){
1149 s->mv_bits+= get_bits_diff(s);
1152 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1154 if(interleaved_stats){
1155 s->p_tex_bits+= get_bits_diff(s);
1161 int dc_diff[6]; //dc values with the dc prediction subtracted
1162 int dir[6]; //prediction direction
1163 int zigzag_last_index[6];
1164 uint8_t *scan_table[6];
1168 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1171 if(s->flags & CODEC_FLAG_AC_PRED){
1172 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1174 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1177 scan_table[i]= s->intra_scantable.permutated;
1182 for (i = 0; i < 6; i++) {
1183 if (s->block_last_index[i] >= 1)
1184 cbp |= 1 << (5 - i);
1188 if (s->pict_type == I_TYPE) {
1189 if(s->dquant) cbpc+=4;
1191 intra_MCBPC_bits[cbpc],
1192 intra_MCBPC_code[cbpc]);
1194 if(s->dquant) cbpc+=8;
1195 put_bits(&s->pb, 1, 0); /* mb coded */
1197 inter_MCBPC_bits[cbpc + 4],
1198 inter_MCBPC_code[cbpc + 4]);
1200 put_bits(pb2, 1, s->ac_pred);
1202 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1204 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1206 if(!s->progressive_sequence){
1207 put_bits(dc_pb, 1, s->interlaced_dct);
1210 if(interleaved_stats){
1211 s->misc_bits+= get_bits_diff(s);
1214 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1216 if(interleaved_stats){
1217 s->i_tex_bits+= get_bits_diff(s);
1221 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1223 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1227 void h263_encode_mb(MpegEncContext * s,
1228 DCTELEM block[6][64],
1229 int motion_x, int motion_y)
1231 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1233 int16_t rec_intradc[6];
1234 uint16_t *dc_ptr[6];
1235 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1236 const int dquant_code[5]= {1,0,9,2,3};
1238 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1241 cbp= get_p_cbp(s, block, motion_x, motion_y);
1243 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1244 /* skip macroblock */
1245 put_bits(&s->pb, 1, 1);
1246 if(interleaved_stats){
1254 put_bits(&s->pb, 1, 0); /* mb coded */
1258 if(s->alt_inter_vlc==0 || cbpc!=3)
1260 if(s->dquant) cbpc+= 8;
1261 if(s->mv_type==MV_TYPE_16X16){
1263 inter_MCBPC_bits[cbpc],
1264 inter_MCBPC_code[cbpc]);
1266 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1268 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1270 if(interleaved_stats){
1271 s->misc_bits+= get_bits_diff(s);
1274 /* motion vectors: 16x16 mode */
1275 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1278 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1279 motion_y - pred_y, 1);
1282 h263p_encode_umotion(s, motion_x - pred_x);
1283 h263p_encode_umotion(s, motion_y - pred_y);
1284 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1285 /* To prevent Start Code emulation */
1286 put_bits(&s->pb,1,1);
1290 inter_MCBPC_bits[cbpc+16],
1291 inter_MCBPC_code[cbpc+16]);
1292 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1294 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1296 if(interleaved_stats){
1297 s->misc_bits+= get_bits_diff(s);
1301 /* motion vectors: 8x8 mode*/
1302 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1304 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1305 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1307 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1308 motion_y - pred_y, 1);
1311 h263p_encode_umotion(s, motion_x - pred_x);
1312 h263p_encode_umotion(s, motion_y - pred_y);
1313 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1314 /* To prevent Start Code emulation */
1315 put_bits(&s->pb,1,1);
1320 if(interleaved_stats){
1321 s->mv_bits+= get_bits_diff(s);
1324 assert(s->mb_intra);
1329 for(i=0; i<6; i++) {
1330 int16_t level = block[i][0];
1333 if(i<4) scale= s->y_dc_scale;
1334 else scale= s->c_dc_scale;
1336 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1340 level = (level + (scale>>1))/scale;
1342 level = (level - (scale>>1))/scale;
1344 /* AIC can change CBP */
1345 if (level == 0 && s->block_last_index[i] == 0)
1346 s->block_last_index[i] = -1;
1348 if(!s->modified_quant){
1351 else if (level > 127)
1355 block[i][0] = level;
1356 /* Reconstruction */
1357 rec_intradc[i] = scale*level + pred_dc;
1359 rec_intradc[i] |= 1;
1360 //if ((rec_intradc[i] % 2) == 0)
1361 // rec_intradc[i]++;
1363 if (rec_intradc[i] < 0)
1365 else if (rec_intradc[i] > 2047)
1366 rec_intradc[i] = 2047;
1368 /* Update AC/DC tables */
1369 *dc_ptr[i] = rec_intradc[i];
1370 if (s->block_last_index[i] >= 0)
1371 cbp |= 1 << (5 - i);
1374 for(i=0; i<6; i++) {
1376 if (s->block_last_index[i] >= 1)
1377 cbp |= 1 << (5 - i);
1382 if (s->pict_type == I_TYPE) {
1383 if(s->dquant) cbpc+=4;
1385 intra_MCBPC_bits[cbpc],
1386 intra_MCBPC_code[cbpc]);
1388 if(s->dquant) cbpc+=8;
1389 put_bits(&s->pb, 1, 0); /* mb coded */
1391 inter_MCBPC_bits[cbpc + 4],
1392 inter_MCBPC_code[cbpc + 4]);
1395 /* XXX: currently, we do not try to use ac prediction */
1396 put_bits(&s->pb, 1, 0); /* no AC prediction */
1399 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1401 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1403 if(interleaved_stats){
1404 s->misc_bits+= get_bits_diff(s);
1408 for(i=0; i<6; i++) {
1409 /* encode each block */
1410 h263_encode_block(s, block[i], i);
1412 /* Update INTRADC for decoding */
1413 if (s->h263_aic && s->mb_intra) {
1414 block[i][0] = rec_intradc[i];
1419 if(interleaved_stats){
1421 s->p_tex_bits+= get_bits_diff(s);
1424 s->i_tex_bits+= get_bits_diff(s);
1431 void ff_h263_loop_filter(MpegEncContext * s){
1433 const int linesize = s->linesize;
1434 const int uvlinesize= s->uvlinesize;
1435 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1436 uint8_t *dest_y = s->dest[0];
1437 uint8_t *dest_cb= s->dest[1];
1438 uint8_t *dest_cr= s->dest[2];
1440 // if(s->pict_type==B_TYPE && !s->readable) return;
1446 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1448 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1449 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1454 int qp_dt, qp_t, qp_tc;
1456 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1459 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1467 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1468 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1469 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1471 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1472 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1476 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1479 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1482 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1485 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1486 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1487 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1488 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1494 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1495 if(s->mb_y + 1 == s->mb_height)
1496 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1501 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1504 qp_lc= s->current_picture.qscale_table[xy-1];
1507 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1508 if(s->mb_y + 1 == s->mb_height){
1509 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1510 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1511 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1512 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1518 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1520 int x, y, wrap, a, c, pred_dc, scale;
1523 /* find prediction */
1525 x = 2 * s->mb_x + (n & 1);
1526 y = 2 * s->mb_y + ((n & 2) >> 1);
1527 wrap = s->b8_stride;
1528 dc_val = s->dc_val[0];
1529 scale = s->y_dc_scale;
1533 wrap = s->mb_stride;
1534 dc_val = s->dc_val[n - 4 + 1];
1535 scale = s->c_dc_scale;
1540 a = dc_val[(x - 1) + (y) * wrap];
1541 c = dc_val[(x) + (y - 1) * wrap];
1543 /* No prediction outside GOB boundary */
1544 if(s->first_slice_line && n!=3){
1546 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1549 /* just DC prediction */
1550 if (a != 1024 && c != 1024)
1551 pred_dc = (a + c) >> 1;
1557 /* we assume pred is positive */
1558 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1559 *dc_val_ptr = &dc_val[x + y * wrap];
1563 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1565 int x, y, wrap, a, c, pred_dc, scale, i;
1566 int16_t *dc_val, *ac_val, *ac_val1;
1568 /* find prediction */
1570 x = 2 * s->mb_x + (n & 1);
1571 y = 2 * s->mb_y + (n>> 1);
1572 wrap = s->b8_stride;
1573 dc_val = s->dc_val[0];
1574 ac_val = s->ac_val[0][0];
1575 scale = s->y_dc_scale;
1579 wrap = s->mb_stride;
1580 dc_val = s->dc_val[n - 4 + 1];
1581 ac_val = s->ac_val[n - 4 + 1][0];
1582 scale = s->c_dc_scale;
1585 ac_val += ((y) * wrap + (x)) * 16;
1591 a = dc_val[(x - 1) + (y) * wrap];
1592 c = dc_val[(x) + (y - 1) * wrap];
1594 /* No prediction outside GOB boundary */
1595 if(s->first_slice_line && n!=3){
1597 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1602 if (s->h263_aic_dir) {
1603 /* left prediction */
1607 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1612 /* top prediction */
1614 ac_val -= 16 * wrap;
1616 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1622 /* just DC prediction */
1623 if (a != 1024 && c != 1024)
1624 pred_dc = (a + c) >> 1;
1631 /* we assume pred is positive */
1632 block[0]=block[0]*scale + pred_dc;
1639 /* Update AC/DC tables */
1640 dc_val[(x) + (y) * wrap] = block[0];
1644 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1647 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1650 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1654 int16_t *A, *B, *C, (*mot_val)[2];
1655 static const int off[4]= {2, 1, 1, -1};
1657 wrap = s->b8_stride;
1658 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1661 /* special case for first (slice) line */
1662 if (s->first_slice_line && block<3) {
1663 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1664 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1665 if(block==0){ //most common case
1666 if(s->mb_x == s->resync_mb_x){ //rare
1668 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1669 C = mot_val[off[block] - wrap];
1674 *px = mid_pred(A[0], 0, C[0]);
1675 *py = mid_pred(A[1], 0, C[1]);
1682 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1683 C = mot_val[off[block] - wrap];
1684 *px = mid_pred(A[0], 0, C[0]);
1685 *py = mid_pred(A[1], 0, C[1]);
1690 }else{ /* block==2*/
1691 B = mot_val[ - wrap];
1692 C = mot_val[off[block] - wrap];
1693 if(s->mb_x == s->resync_mb_x) //rare
1696 *px = mid_pred(A[0], B[0], C[0]);
1697 *py = mid_pred(A[1], B[1], C[1]);
1700 B = mot_val[ - wrap];
1701 C = mot_val[off[block] - wrap];
1702 *px = mid_pred(A[0], B[0], C[0]);
1703 *py = mid_pred(A[1], B[1], C[1]);
1708 #ifdef CONFIG_ENCODERS
1709 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1711 int range, l, bit_size, sign, code, bits;
1716 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1718 bit_size = f_code - 1;
1719 range = 1 << bit_size;
1720 /* modulo encoding */
1721 l= INT_BIT - 6 - bit_size;
1724 val= (val^sign)-sign;
1728 code = (val >> bit_size) + 1;
1729 bits = val & (range - 1);
1731 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1733 put_bits(&s->pb, bit_size, bits);
1738 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1739 static void h263p_encode_umotion(MpegEncContext * s, int val)
1749 put_bits(&s->pb, 1, 1);
1751 put_bits(&s->pb, 3, 0);
1753 put_bits(&s->pb, 3, 2);
1756 sval = ((val < 0) ? (short)(-val):(short)val);
1759 while (temp_val != 0) {
1760 temp_val = temp_val >> 1;
1766 tcode = (sval & (1 << (i-1))) >> (i-1);
1767 tcode = (tcode << 1) | 1;
1768 code = (code << 2) | tcode;
1771 code = ((code << 1) | (val < 0)) << 1;
1772 put_bits(&s->pb, (2*n_bits)+1, code);
1773 //printf("\nVal = %d\tCode = %d", sval, code);
1777 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1782 if(mv_penalty==NULL)
1783 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1785 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1786 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1789 if(mv==0) len= mvtab[0][1];
1791 int val, bit_size, range, code;
1793 bit_size = f_code - 1;
1794 range = 1 << bit_size;
1800 code = (val >> bit_size) + 1;
1802 len= mvtab[code][1] + 1 + bit_size;
1804 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1808 mv_penalty[f_code][mv+MAX_MV]= len;
1812 for(f_code=MAX_FCODE; f_code>0; f_code--){
1813 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1814 fcode_tab[mv+MAX_MV]= f_code;
1818 for(mv=0; mv<MAX_MV*2+1; mv++){
1819 umv_fcode_tab[mv]= 1;
1824 #ifdef CONFIG_ENCODERS
1826 static void init_uni_dc_tab(void)
1828 int level, uni_code, uni_len;
1830 for(level=-256; level<256; level++){
1832 /* find number of bits */
1841 l= (-level) ^ ((1 << size) - 1);
1846 uni_code= DCtab_lum[size][0];
1847 uni_len = DCtab_lum[size][1];
1850 uni_code<<=size; uni_code|=l;
1853 uni_code<<=1; uni_code|=1;
1857 uni_DCtab_lum_bits[level+256]= uni_code;
1858 uni_DCtab_lum_len [level+256]= uni_len;
1861 uni_code= DCtab_chrom[size][0];
1862 uni_len = DCtab_chrom[size][1];
1865 uni_code<<=size; uni_code|=l;
1868 uni_code<<=1; uni_code|=1;
1872 uni_DCtab_chrom_bits[level+256]= uni_code;
1873 uni_DCtab_chrom_len [level+256]= uni_len;
1878 #endif //CONFIG_ENCODERS
1880 #ifdef CONFIG_ENCODERS
1881 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1882 int slevel, run, last;
1884 assert(MAX_LEVEL >= 64);
1885 assert(MAX_RUN >= 63);
1887 for(slevel=-64; slevel<64; slevel++){
1888 if(slevel==0) continue;
1889 for(run=0; run<64; run++){
1890 for(last=0; last<=1; last++){
1891 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1892 int level= slevel < 0 ? -slevel : slevel;
1893 int sign= slevel < 0 ? 1 : 0;
1894 int bits, len, code;
1897 len_tab[index]= 100;
1900 code= get_rl_index(rl, last, run, level);
1901 bits= rl->table_vlc[code][0];
1902 len= rl->table_vlc[code][1];
1903 bits=bits*2+sign; len++;
1905 if(code!=rl->n && len < len_tab[index]){
1906 bits_tab[index]= bits;
1907 len_tab [index]= len;
1911 bits= rl->table_vlc[rl->n][0];
1912 len= rl->table_vlc[rl->n][1];
1913 bits=bits*2; len++; //esc1
1914 level1= level - rl->max_level[last][run];
1916 code= get_rl_index(rl, last, run, level1);
1917 bits<<= rl->table_vlc[code][1];
1918 len += rl->table_vlc[code][1];
1919 bits += rl->table_vlc[code][0];
1920 bits=bits*2+sign; len++;
1922 if(code!=rl->n && len < len_tab[index]){
1923 bits_tab[index]= bits;
1924 len_tab [index]= len;
1930 bits= rl->table_vlc[rl->n][0];
1931 len= rl->table_vlc[rl->n][1];
1932 bits=bits*4+2; len+=2; //esc2
1933 run1 = run - rl->max_run[last][level] - 1;
1935 code= get_rl_index(rl, last, run1, level);
1936 bits<<= rl->table_vlc[code][1];
1937 len += rl->table_vlc[code][1];
1938 bits += rl->table_vlc[code][0];
1939 bits=bits*2+sign; len++;
1941 if(code!=rl->n && len < len_tab[index]){
1942 bits_tab[index]= bits;
1943 len_tab [index]= len;
1948 bits= rl->table_vlc[rl->n][0];
1949 len = rl->table_vlc[rl->n][1];
1950 bits=bits*4+3; len+=2; //esc3
1951 bits=bits*2+last; len++;
1952 bits=bits*64+run; len+=6;
1953 bits=bits*2+1; len++; //marker
1954 bits=bits*4096+(slevel&0xfff); len+=12;
1955 bits=bits*2+1; len++; //marker
1957 if(len < len_tab[index]){
1958 bits_tab[index]= bits;
1959 len_tab [index]= len;
1966 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1967 int slevel, run, last;
1969 assert(MAX_LEVEL >= 64);
1970 assert(MAX_RUN >= 63);
1972 for(slevel=-64; slevel<64; slevel++){
1973 if(slevel==0) continue;
1974 for(run=0; run<64; run++){
1975 for(last=0; last<=1; last++){
1976 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1977 int level= slevel < 0 ? -slevel : slevel;
1978 int sign= slevel < 0 ? 1 : 0;
1979 int bits, len, code;
1981 len_tab[index]= 100;
1984 code= get_rl_index(rl, last, run, level);
1985 bits= rl->table_vlc[code][0];
1986 len= rl->table_vlc[code][1];
1987 bits=bits*2+sign; len++;
1989 if(code!=rl->n && len < len_tab[index]){
1990 if(bits_tab) bits_tab[index]= bits;
1991 len_tab [index]= len;
1994 bits= rl->table_vlc[rl->n][0];
1995 len = rl->table_vlc[rl->n][1];
1996 bits=bits*2+last; len++;
1997 bits=bits*64+run; len+=6;
1998 bits=bits*256+(level&0xff); len+=8;
2000 if(len < len_tab[index]){
2001 if(bits_tab) bits_tab[index]= bits;
2002 len_tab [index]= len;
2009 void h263_encode_init(MpegEncContext *s)
2011 static int done = 0;
2018 init_rl(&rl_inter, 1);
2019 init_rl(&rl_intra, 1);
2020 init_rl(&rl_intra_aic, 1);
2022 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2023 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2025 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2026 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2028 init_mv_penalty_and_fcode(s);
2030 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2032 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2033 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2035 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2036 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2038 s->ac_esc_length= 7+1+6+8;
2040 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2041 switch(s->codec_id){
2042 case CODEC_ID_MPEG4:
2043 s->fcode_tab= fcode_tab;
2044 s->min_qcoeff= -2048;
2045 s->max_qcoeff= 2047;
2046 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2047 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2048 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2049 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2050 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2051 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2052 s->ac_esc_length= 7+2+1+6+1+12+1;
2053 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2054 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2056 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2058 s->avctx->extradata= av_malloc(1024);
2059 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2061 if(!(s->workaround_bugs & FF_BUG_MS))
2062 mpeg4_encode_visual_object_header(s);
2063 mpeg4_encode_vol_header(s, 0, 0);
2065 // ff_mpeg4_stuffing(&s->pb); ?
2066 flush_put_bits(&s->pb);
2067 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2071 case CODEC_ID_H263P:
2073 s->fcode_tab= umv_fcode_tab;
2074 if(s->modified_quant){
2075 s->min_qcoeff= -2047;
2076 s->max_qcoeff= 2047;
2078 s->min_qcoeff= -127;
2082 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2084 if (s->h263_flv > 1) {
2085 s->min_qcoeff= -1023;
2086 s->max_qcoeff= 1023;
2088 s->min_qcoeff= -127;
2091 s->y_dc_scale_table=
2092 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2094 default: //nothing needed - default table already set in mpegvideo.c
2095 s->min_qcoeff= -127;
2097 s->y_dc_scale_table=
2098 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2103 * encodes a 8x8 block.
2104 * @param block the 8x8 block
2105 * @param n block index (0-3 are luma, 4-5 are chroma)
2107 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2109 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2113 if (s->mb_intra && !s->h263_aic) {
2116 /* 255 cannot be represented, so we clamp */
2121 /* 0 cannot be represented also */
2122 else if (level < 1) {
2126 if (level == 128) //FIXME check rv10
2127 put_bits(&s->pb, 8, 0xff);
2129 put_bits(&s->pb, 8, level);
2133 if (s->h263_aic && s->mb_intra)
2136 if(s->alt_inter_vlc && !s->mb_intra){
2138 int inter_vlc_bits=0;
2142 last_index = s->block_last_index[n];
2143 last_non_zero = i - 1;
2144 for (; i <= last_index; i++) {
2145 j = s->intra_scantable.permutated[i];
2148 run = i - last_non_zero - 1;
2149 last = (i == last_index);
2151 if(level<0) level= -level;
2153 code = get_rl_index(rl, last, run, level);
2154 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2155 inter_vlc_bits += rl->table_vlc[code][1]+1;
2156 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2158 if (code == rl->n) {
2159 inter_vlc_bits += 1+6+8-1;
2161 if (aic_code == rl_intra_aic.n) {
2162 aic_vlc_bits += 1+6+8-1;
2163 wrong_pos += run + 1;
2165 wrong_pos += wrong_run[aic_code];
2170 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2176 last_index = s->block_last_index[n];
2177 last_non_zero = i - 1;
2178 for (; i <= last_index; i++) {
2179 j = s->intra_scantable.permutated[i];
2182 run = i - last_non_zero - 1;
2183 last = (i == last_index);
2190 code = get_rl_index(rl, last, run, level);
2191 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2192 if (code == rl->n) {
2193 if(s->h263_flv <= 1){
2194 put_bits(&s->pb, 1, last);
2195 put_bits(&s->pb, 6, run);
2197 assert(slevel != 0);
2200 put_bits(&s->pb, 8, slevel & 0xff);
2202 put_bits(&s->pb, 8, 128);
2203 put_bits(&s->pb, 5, slevel & 0x1f);
2204 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2207 if(level < 64) { // 7-bit level
2208 put_bits(&s->pb, 1, 0);
2209 put_bits(&s->pb, 1, last);
2210 put_bits(&s->pb, 6, run);
2212 put_bits(&s->pb, 7, slevel & 0x7f);
2215 put_bits(&s->pb, 1, 1);
2216 put_bits(&s->pb, 1, last);
2217 put_bits(&s->pb, 6, run);
2219 put_bits(&s->pb, 11, slevel & 0x7ff);
2223 put_bits(&s->pb, 1, sign);
2231 #ifdef CONFIG_ENCODERS
2233 /***************************************************/
2235 * add mpeg4 stuffing bits (01...1)
2237 void ff_mpeg4_stuffing(PutBitContext * pbc)
2240 put_bits(pbc, 1, 0);
2241 length= (-put_bits_count(pbc))&7;
2242 if(length) put_bits(pbc, length, (1<<length)-1);
2245 /* must be called before writing the header */
2246 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2247 int time_div, time_mod;
2249 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2250 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2252 time_div= s->time/s->avctx->time_base.den;
2253 time_mod= s->time%s->avctx->time_base.den;
2255 if(s->pict_type==B_TYPE){
2256 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2257 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2258 ff_mpeg4_init_direct_mv(s);
2260 s->last_time_base= s->time_base;
2261 s->time_base= time_div;
2262 s->pp_time= s->time - s->last_non_b_time;
2263 s->last_non_b_time= s->time;
2264 assert(picture_number==0 || s->pp_time > 0);
2268 static void mpeg4_encode_gop_header(MpegEncContext * s){
2269 int hours, minutes, seconds;
2272 put_bits(&s->pb, 16, 0);
2273 put_bits(&s->pb, 16, GOP_STARTCODE);
2275 time= s->current_picture_ptr->pts;
2276 if(s->reordered_input_picture[1])
2277 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2278 time= time*s->avctx->time_base.num;
2280 seconds= time/s->avctx->time_base.den;
2281 minutes= seconds/60; seconds %= 60;
2282 hours= minutes/60; minutes %= 60;
2285 put_bits(&s->pb, 5, hours);
2286 put_bits(&s->pb, 6, minutes);
2287 put_bits(&s->pb, 1, 1);
2288 put_bits(&s->pb, 6, seconds);
2290 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2291 put_bits(&s->pb, 1, 0); //broken link == NO
2293 s->last_time_base= time / s->avctx->time_base.den;
2295 ff_mpeg4_stuffing(&s->pb);
2298 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2299 int profile_and_level_indication;
2302 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2303 profile_and_level_indication = s->avctx->profile << 4;
2304 }else if(s->max_b_frames || s->quarter_sample){
2305 profile_and_level_indication= 0xF0; // adv simple
2307 profile_and_level_indication= 0x00; // simple
2310 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2311 profile_and_level_indication |= s->avctx->level;
2313 profile_and_level_indication |= 1; //level 1
2316 if(profile_and_level_indication>>4 == 0xF){
2324 put_bits(&s->pb, 16, 0);
2325 put_bits(&s->pb, 16, VOS_STARTCODE);
2327 put_bits(&s->pb, 8, profile_and_level_indication);
2329 put_bits(&s->pb, 16, 0);
2330 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2332 put_bits(&s->pb, 1, 1);
2333 put_bits(&s->pb, 4, vo_ver_id);
2334 put_bits(&s->pb, 3, 1); //priority
2336 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2338 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2340 ff_mpeg4_stuffing(&s->pb);
2343 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2347 if(s->max_b_frames || s->quarter_sample){
2349 s->vo_type= ADV_SIMPLE_VO_TYPE;
2352 s->vo_type= SIMPLE_VO_TYPE;
2355 put_bits(&s->pb, 16, 0);
2356 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2357 put_bits(&s->pb, 16, 0);
2358 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2360 put_bits(&s->pb, 1, 0); /* random access vol */
2361 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2362 if(s->workaround_bugs & FF_BUG_MS) {
2363 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2365 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2366 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2367 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2370 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2372 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2373 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2374 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2375 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2378 if(s->workaround_bugs & FF_BUG_MS) { //
2379 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2381 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2382 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2383 put_bits(&s->pb, 1, s->low_delay);
2384 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2387 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2388 put_bits(&s->pb, 1, 1); /* marker bit */
2390 put_bits(&s->pb, 16, s->avctx->time_base.den);
2391 if (s->time_increment_bits < 1)
2392 s->time_increment_bits = 1;
2393 put_bits(&s->pb, 1, 1); /* marker bit */
2394 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2395 put_bits(&s->pb, 1, 1); /* marker bit */
2396 put_bits(&s->pb, 13, s->width); /* vol width */
2397 put_bits(&s->pb, 1, 1); /* marker bit */
2398 put_bits(&s->pb, 13, s->height); /* vol height */
2399 put_bits(&s->pb, 1, 1); /* marker bit */
2400 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2401 put_bits(&s->pb, 1, 1); /* obmc disable */
2402 if (vo_ver_id == 1) {
2403 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2405 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2408 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2409 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2412 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2413 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2417 put_bits(&s->pb, 1, s->quarter_sample);
2418 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2419 s->resync_marker= s->rtp_mode;
2420 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2421 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2422 if(s->data_partitioning){
2423 put_bits(&s->pb, 1, 0); /* no rvlc */
2426 if (vo_ver_id != 1){
2427 put_bits(&s->pb, 1, 0); /* newpred */
2428 put_bits(&s->pb, 1, 0); /* reduced res vop */
2430 put_bits(&s->pb, 1, 0); /* scalability */
2432 ff_mpeg4_stuffing(&s->pb);
2435 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2436 put_bits(&s->pb, 16, 0);
2437 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2438 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2442 /* write mpeg4 VOP header */
2443 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2446 int time_div, time_mod;
2448 if(s->pict_type==I_TYPE){
2449 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2450 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2451 mpeg4_encode_visual_object_header(s);
2452 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2453 mpeg4_encode_vol_header(s, 0, 0);
2455 if(!(s->workaround_bugs & FF_BUG_MS))
2456 mpeg4_encode_gop_header(s);
2459 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2461 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2463 put_bits(&s->pb, 16, 0); /* vop header */
2464 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2465 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2468 time_div= s->time/s->avctx->time_base.den;
2469 time_mod= s->time%s->avctx->time_base.den;
2470 time_incr= time_div - s->last_time_base;
2471 assert(time_incr >= 0);
2473 put_bits(&s->pb, 1, 1);
2475 put_bits(&s->pb, 1, 0);
2477 put_bits(&s->pb, 1, 1); /* marker */
2478 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2479 put_bits(&s->pb, 1, 1); /* marker */
2480 put_bits(&s->pb, 1, 1); /* vop coded */
2481 if ( s->pict_type == P_TYPE
2482 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2483 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2485 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2486 if(!s->progressive_sequence){
2487 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2488 put_bits(&s->pb, 1, s->alternate_scan);
2490 //FIXME sprite stuff
2492 put_bits(&s->pb, 5, s->qscale);
2494 if (s->pict_type != I_TYPE)
2495 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2496 if (s->pict_type == B_TYPE)
2497 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2498 // printf("****frame %d\n", picture_number);
2501 #endif //CONFIG_ENCODERS
2504 * set qscale and update qscale dependant variables.
2506 void ff_set_qscale(MpegEncContext * s, int qscale)
2510 else if (qscale > 31)
2514 s->chroma_qscale= s->chroma_qscale_table[qscale];
2516 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2517 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2522 * encoding quantized level -> quantized diff
2523 * decoding quantized diff -> quantized level
2524 * @param n block index (0-3 are luma, 4-5 are chroma)
2525 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2527 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2529 int a, b, c, wrap, pred, scale, ret;
2532 /* find prediction */
2534 scale = s->y_dc_scale;
2536 scale = s->c_dc_scale;
2541 wrap= s->block_wrap[n];
2542 dc_val = s->dc_val[0] + s->block_index[n];
2548 b = dc_val[ - 1 - wrap];
2549 c = dc_val[ - wrap];
2551 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2552 if(s->first_slice_line && n!=3){
2554 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2556 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2557 if(n==0 || n==4 || n==5)
2561 if (abs(a - b) < abs(b - c)) {
2563 *dir_ptr = 1; /* top */
2566 *dir_ptr = 0; /* left */
2568 /* we assume pred is positive */
2569 pred = FASTDIV((pred + (scale >> 1)), scale);
2576 if(s->error_resilience>=3){
2578 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2581 if(level*scale > 2048 + scale){
2582 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2591 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2601 * @param n block index (0-3 are luma, 4-5 are chroma)
2602 * @param dir the ac prediction direction
2604 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2608 int16_t *ac_val, *ac_val1;
2609 int8_t * const qscale_table= s->current_picture.qscale_table;
2611 /* find prediction */
2612 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2616 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2617 /* left prediction */
2620 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2623 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2626 /* different qscale, we must rescale */
2628 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2632 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2633 /* top prediction */
2634 ac_val -= 16 * s->block_wrap[n];
2636 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2639 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2642 /* different qscale, we must rescale */
2644 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2651 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2655 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2659 #ifdef CONFIG_ENCODERS
2662 * encodes the dc value.
2663 * @param n block index (0-3 are luma, 4-5 are chroma)
2665 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2668 // if(level<-255 || level>255) printf("dc overflow\n");
2672 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2675 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2679 /* find number of bits */
2689 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2692 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2695 /* encode remaining bits */
2698 level = (-level) ^ ((1 << size) - 1);
2699 put_bits(&s->pb, size, level);
2701 put_bits(&s->pb, 1, 1);
2706 static inline int mpeg4_get_dc_length(int level, int n){
2708 return uni_DCtab_lum_len[level + 256];
2710 return uni_DCtab_chrom_len[level + 256];
2715 * encodes a 8x8 block
2716 * @param n block index (0-3 are luma, 4-5 are chroma)
2718 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2719 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2721 int i, last_non_zero;
2722 #if 0 //variables for the outcommented version
2723 int code, sign, last;
2728 const int last_index = s->block_last_index[n];
2730 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2731 /* mpeg4 based DC predictor */
2732 mpeg4_encode_dc(dc_pb, intra_dc, n);
2733 if(last_index<1) return;
2736 bits_tab= uni_mpeg4_intra_rl_bits;
2737 len_tab = uni_mpeg4_intra_rl_len;
2739 if(last_index<0) return;
2742 bits_tab= uni_mpeg4_inter_rl_bits;
2743 len_tab = uni_mpeg4_inter_rl_len;
2747 last_non_zero = i - 1;
2749 for (; i < last_index; i++) {
2750 int level = block[ scan_table[i] ];
2752 int run = i - last_non_zero - 1;
2754 if((level&(~127)) == 0){
2755 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2756 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2758 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);
2763 /*if(i<=last_index)*/{
2764 int level = block[ scan_table[i] ];
2765 int run = i - last_non_zero - 1;
2767 if((level&(~127)) == 0){
2768 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2769 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2771 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);
2775 for (; i <= last_index; i++) {
2776 const int slevel = block[ scan_table[i] ];
2779 int run = i - last_non_zero - 1;
2780 last = (i == last_index);
2787 code = get_rl_index(rl, last, run, level);
2788 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2789 if (code == rl->n) {
2791 level1 = level - rl->max_level[last][run];
2794 code = get_rl_index(rl, last, run, level1);
2795 if (code == rl->n) {
2797 put_bits(ac_pb, 1, 1);
2798 if (level > MAX_LEVEL)
2800 run1 = run - rl->max_run[last][level] - 1;
2803 code = get_rl_index(rl, last, run1, level);
2804 if (code == rl->n) {
2807 put_bits(ac_pb, 1, 1);
2808 put_bits(ac_pb, 1, last);
2809 put_bits(ac_pb, 6, run);
2810 put_bits(ac_pb, 1, 1);
2811 put_bits(ac_pb, 12, slevel & 0xfff);
2812 put_bits(ac_pb, 1, 1);
2815 put_bits(ac_pb, 1, 0);
2816 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2817 put_bits(ac_pb, 1, sign);
2821 put_bits(ac_pb, 1, 0);
2822 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2823 put_bits(ac_pb, 1, sign);
2826 put_bits(ac_pb, 1, sign);
2834 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2835 uint8_t *scan_table)
2837 int i, last_non_zero;
2840 const int last_index = s->block_last_index[n];
2843 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2844 /* mpeg4 based DC predictor */
2845 len += mpeg4_get_dc_length(intra_dc, n);
2846 if(last_index<1) return len;
2849 len_tab = uni_mpeg4_intra_rl_len;
2851 if(last_index<0) return 0;
2854 len_tab = uni_mpeg4_inter_rl_len;
2858 last_non_zero = i - 1;
2859 for (; i < last_index; i++) {
2860 int level = block[ scan_table[i] ];
2862 int run = i - last_non_zero - 1;
2864 if((level&(~127)) == 0){
2865 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2866 len += len_tab[index];
2868 len += 7+2+1+6+1+12+1;
2873 /*if(i<=last_index)*/{
2874 int level = block[ scan_table[i] ];
2875 int run = i - last_non_zero - 1;
2877 if((level&(~127)) == 0){
2878 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2879 len += len_tab[index];
2881 len += 7+2+1+6+1+12+1;
2891 /***********************************************/
2894 static VLC intra_MCBPC_vlc;
2895 static VLC inter_MCBPC_vlc;
2896 static VLC cbpy_vlc;
2898 static VLC dc_lum, dc_chrom;
2899 static VLC sprite_trajectory;
2900 static VLC mb_type_b_vlc;
2901 static VLC h263_mbtype_b_vlc;
2902 static VLC cbpc_b_vlc;
2904 void init_vlc_rl(RLTable *rl, int use_static)
2908 /* Return if static table is already initialized */
2909 if(use_static && rl->rl_vlc[0])
2912 init_vlc(&rl->vlc, 9, rl->n + 1,
2913 &rl->table_vlc[0][1], 4, 2,
2914 &rl->table_vlc[0][0], 4, 2, use_static);
2917 for(q=0; q<32; q++){
2926 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2928 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2929 for(i=0; i<rl->vlc.table_size; i++){
2930 int code= rl->vlc.table[i][0];
2931 int len = rl->vlc.table[i][1];
2934 if(len==0){ // illegal code
2937 }else if(len<0){ //more bits needed
2941 if(code==rl->n){ //esc
2945 run= rl->table_run [code] + 1;
2946 level= rl->table_level[code] * qmul + qadd;
2947 if(code >= rl->last) run+=192;
2950 rl->rl_vlc[q][i].len= len;
2951 rl->rl_vlc[q][i].level= level;
2952 rl->rl_vlc[q][i].run= run;
2959 /* XXX: find a better solution to handle static init */
2960 void h263_decode_init_vlc(MpegEncContext *s)
2962 static int done = 0;
2967 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2968 intra_MCBPC_bits, 1, 1,
2969 intra_MCBPC_code, 1, 1, 1);
2970 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2971 inter_MCBPC_bits, 1, 1,
2972 inter_MCBPC_code, 1, 1, 1);
2973 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2974 &cbpy_tab[0][1], 2, 1,
2975 &cbpy_tab[0][0], 2, 1, 1);
2976 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2978 &mvtab[0][0], 2, 1, 1);
2979 init_rl(&rl_inter, 1);
2980 init_rl(&rl_intra, 1);
2981 init_rl(&rvlc_rl_inter, 1);
2982 init_rl(&rvlc_rl_intra, 1);
2983 init_rl(&rl_intra_aic, 1);
2984 init_vlc_rl(&rl_inter, 1);
2985 init_vlc_rl(&rl_intra, 1);
2986 init_vlc_rl(&rvlc_rl_inter, 1);
2987 init_vlc_rl(&rvlc_rl_intra, 1);
2988 init_vlc_rl(&rl_intra_aic, 1);
2989 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2990 &DCtab_lum[0][1], 2, 1,
2991 &DCtab_lum[0][0], 2, 1, 1);
2992 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2993 &DCtab_chrom[0][1], 2, 1,
2994 &DCtab_chrom[0][0], 2, 1, 1);
2995 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2996 &sprite_trajectory_tab[0][1], 4, 2,
2997 &sprite_trajectory_tab[0][0], 4, 2, 1);
2998 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2999 &mb_type_b_tab[0][1], 2, 1,
3000 &mb_type_b_tab[0][0], 2, 1, 1);
3001 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3002 &h263_mbtype_b_tab[0][1], 2, 1,
3003 &h263_mbtype_b_tab[0][0], 2, 1, 1);
3004 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3005 &cbpc_b_tab[0][1], 2, 1,
3006 &cbpc_b_tab[0][0], 2, 1, 1);
3011 * Get the GOB height based on picture height.
3013 int ff_h263_get_gob_height(MpegEncContext *s){
3014 if (s->height <= 400)
3016 else if (s->height <= 800)
3022 int ff_h263_decode_mba(MpegEncContext *s)
3027 if(s->mb_num-1 <= ff_mba_max[i]) break;
3029 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3030 s->mb_x= mb_pos % s->mb_width;
3031 s->mb_y= mb_pos / s->mb_width;
3036 void ff_h263_encode_mba(MpegEncContext *s)
3041 if(s->mb_num-1 <= ff_mba_max[i]) break;
3043 mb_pos= s->mb_x + s->mb_width*s->mb_y;
3044 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3048 * decodes the group of blocks header or slice header.
3049 * @return <0 if an error occured
3051 static int h263_decode_gob_header(MpegEncContext *s)
3053 unsigned int val, gfid, gob_number;
3056 /* Check for GOB Start Code */
3057 val = show_bits(&s->gb, 16);
3061 /* We have a GBSC probably with GSTUFF */
3062 skip_bits(&s->gb, 16); /* Drop the zeros */
3063 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3064 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3065 for(;left>13; left--){
3066 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3071 if(s->h263_slice_structured){
3072 if(get_bits1(&s->gb)==0)
3075 ff_h263_decode_mba(s);
3077 if(s->mb_num > 1583)
3078 if(get_bits1(&s->gb)==0)
3081 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3082 if(get_bits1(&s->gb)==0)
3084 gfid = get_bits(&s->gb, 2); /* GFID */
3086 gob_number = get_bits(&s->gb, 5); /* GN */
3088 s->mb_y= s->gob_index* gob_number;
3089 gfid = get_bits(&s->gb, 2); /* GFID */
3090 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3093 if(s->mb_y >= s->mb_height)
3102 static inline void memsetw(short *tab, int val, int n)
3109 #ifdef CONFIG_ENCODERS
3111 void ff_mpeg4_init_partitions(MpegEncContext *s)
3113 uint8_t *start= pbBufPtr(&s->pb);
3114 uint8_t *end= s->pb.buf_end;
3115 int size= end - start;
3116 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3117 int tex_size= (size - 2*pb_size)&(~3);
3119 set_put_bits_buffer_size(&s->pb, pb_size);
3120 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3121 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3124 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3126 const int pb2_len = put_bits_count(&s->pb2 );
3127 const int tex_pb_len= put_bits_count(&s->tex_pb);
3128 const int bits= put_bits_count(&s->pb);
3130 if(s->pict_type==I_TYPE){
3131 put_bits(&s->pb, 19, DC_MARKER);
3132 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3133 s->i_tex_bits+= tex_pb_len;
3135 put_bits(&s->pb, 17, MOTION_MARKER);
3136 s->misc_bits+=17 + pb2_len;
3137 s->mv_bits+= bits - s->last_bits;
3138 s->p_tex_bits+= tex_pb_len;
3141 flush_put_bits(&s->pb2);
3142 flush_put_bits(&s->tex_pb);
3144 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3145 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3146 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3147 s->last_bits= put_bits_count(&s->pb);
3150 #endif //CONFIG_ENCODERS
3152 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3153 switch(s->pict_type){
3158 return s->f_code+15;
3160 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3166 #ifdef CONFIG_ENCODERS
3168 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3170 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3172 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3173 put_bits(&s->pb, 1, 1);
3175 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3176 put_bits(&s->pb, s->quant_precision, s->qscale);
3177 put_bits(&s->pb, 1, 0); /* no HEC */
3180 #endif //CONFIG_ENCODERS
3183 * check if the next stuff is a resync marker or the end.
3186 static inline int mpeg4_is_resync(MpegEncContext *s){
3187 const int bits_count= get_bits_count(&s->gb);
3189 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3193 if(bits_count + 8 >= s->gb.size_in_bits){
3194 int v= show_bits(&s->gb, 8);
3195 v|= 0x7F >> (7-(bits_count&7));
3200 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3202 GetBitContext gb= s->gb;
3204 skip_bits(&s->gb, 1);
3205 align_get_bits(&s->gb);
3207 for(len=0; len<32; len++){
3208 if(get_bits1(&s->gb)) break;
3213 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3221 * decodes the next video packet.
3222 * @return <0 if something went wrong
3224 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3226 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3227 int header_extension=0, mb_num, len;
3229 /* is there enough space left for a video packet + header */
3230 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3232 for(len=0; len<32; len++){
3233 if(get_bits1(&s->gb)) break;
3236 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3237 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3241 if(s->shape != RECT_SHAPE){
3242 header_extension= get_bits1(&s->gb);
3243 //FIXME more stuff here
3246 mb_num= get_bits(&s->gb, mb_num_bits);
3247 if(mb_num>=s->mb_num){
3248 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3251 if(s->pict_type == B_TYPE){
3252 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3253 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3256 s->mb_x= mb_num % s->mb_width;
3257 s->mb_y= mb_num / s->mb_width;
3259 if(s->shape != BIN_ONLY_SHAPE){
3260 int qscale= get_bits(&s->gb, s->quant_precision);
3262 s->chroma_qscale=s->qscale= qscale;
3265 if(s->shape == RECT_SHAPE){
3266 header_extension= get_bits1(&s->gb);
3268 if(header_extension){
3272 while (get_bits1(&s->gb) != 0)
3275 check_marker(&s->gb, "before time_increment in video packed header");
3276 time_increment= get_bits(&s->gb, s->time_increment_bits);
3277 check_marker(&s->gb, "before vop_coding_type in video packed header");
3279 skip_bits(&s->gb, 2); /* vop coding type */
3280 //FIXME not rect stuff here
3282 if(s->shape != BIN_ONLY_SHAPE){
3283 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3284 //FIXME don't just ignore everything
3285 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3286 mpeg4_decode_sprite_trajectory(s, &s->gb);
3287 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3290 //FIXME reduced res stuff here
3292 if (s->pict_type != I_TYPE) {
3293 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3295 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3298 if (s->pict_type == B_TYPE) {
3299 int b_code = get_bits(&s->gb, 3);
3301 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3306 //FIXME new-pred stuff
3308 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
3313 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3315 int c_wrap, c_xy, l_wrap, l_xy;
3317 l_wrap= s->b8_stride;
3318 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3319 c_wrap= s->mb_stride;
3320 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3324 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3325 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3326 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3330 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3331 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3332 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3335 // we can't clear the MVs as they might be needed by a b frame
3336 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3337 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3338 s->last_mv[0][0][0]=
3339 s->last_mv[0][0][1]=
3340 s->last_mv[1][0][0]=
3341 s->last_mv[1][0][1]= 0;
3345 * decodes the group of blocks / video packet header.
3346 * @return <0 if no resync found
3348 int ff_h263_resync(MpegEncContext *s){
3351 if(s->codec_id==CODEC_ID_MPEG4){
3353 align_get_bits(&s->gb);
3356 if(show_bits(&s->gb, 16)==0){
3357 if(s->codec_id==CODEC_ID_MPEG4)
3358 ret= mpeg4_decode_video_packet_header(s);
3360 ret= h263_decode_gob_header(s);
3364 //ok, it's not where its supposed to be ...
3365 s->gb= s->last_resync_gb;
3366 align_get_bits(&s->gb);
3367 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3369 for(;left>16+1+5+5; left-=8){
3370 if(show_bits(&s->gb, 16)==0){
3371 GetBitContext bak= s->gb;
3373 if(s->codec_id==CODEC_ID_MPEG4)
3374 ret= mpeg4_decode_video_packet_header(s);
3376 ret= h263_decode_gob_header(s);
3382 skip_bits(&s->gb, 8);
3389 * gets the average motion vector for a GMC MB.
3390 * @param n either 0 for the x component or 1 for y
3391 * @returns the average MV for a GMC MB
3393 static inline int get_amv(MpegEncContext *s, int n){
3394 int x, y, mb_v, sum, dx, dy, shift;
3395 int len = 1 << (s->f_code + 4);
3396 const int a= s->sprite_warping_accuracy;
3398 if(s->workaround_bugs & FF_BUG_AMV)
3399 len >>= s->quarter_sample;
3401 if(s->real_sprite_warping_points==1){
3402 if(s->divx_version==500 && s->divx_build==413)
3403 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3405 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3407 dx= s->sprite_delta[n][0];
3408 dy= s->sprite_delta[n][1];
3409 shift= s->sprite_shift[0];
3410 if(n) dy -= 1<<(shift + a + 1);
3411 else dx -= 1<<(shift + a + 1);
3412 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3415 for(y=0; y<16; y++){
3419 //XXX FIXME optimize
3420 for(x=0; x<16; x++){
3425 sum= RSHIFT(sum, a+8-s->quarter_sample);
3428 if (sum < -len) sum= -len;
3429 else if (sum >= len) sum= len-1;
3435 * decodes first partition.
3436 * @return number of MBs decoded or <0 if an error occured
3438 static int mpeg4_decode_partition_a(MpegEncContext *s){
3440 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3442 /* decode first partition */
3444 s->first_slice_line=1;
3445 for(; s->mb_y<s->mb_height; s->mb_y++){
3446 ff_init_block_index(s);
3447 for(; s->mb_x<s->mb_width; s->mb_x++){
3448 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3453 ff_update_block_index(s);
3454 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3455 s->first_slice_line=0;
3457 if(s->pict_type==I_TYPE){
3461 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3465 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3467 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3472 s->cbp_table[xy]= cbpc & 3;
3473 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3477 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3479 s->current_picture.qscale_table[xy]= s->qscale;
3481 s->mbintra_table[xy]= 1;
3484 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3486 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3490 if(dc_pred_dir) dir|=1;
3492 s->pred_dir_table[xy]= dir;
3493 }else{ /* P/S_TYPE */
3494 int mx, my, pred_x, pred_y, bits;
3495 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3496 const int stride= s->b8_stride*2;
3499 bits= show_bits(&s->gb, 17);
3500 if(bits==MOTION_MARKER){
3506 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3507 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3511 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3514 mot_val[0 ]= mot_val[2 ]=
3515 mot_val[0+stride]= mot_val[2+stride]= mx;
3516 mot_val[1 ]= mot_val[3 ]=
3517 mot_val[1+stride]= mot_val[3+stride]= my;
3519 if(s->mbintra_table[xy])
3520 ff_clean_intra_table_entries(s);
3524 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3526 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3532 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3534 s->mb_intra = ((cbpc & 4) != 0);
3537 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3538 s->mbintra_table[xy]= 1;
3539 mot_val[0 ]= mot_val[2 ]=
3540 mot_val[0+stride]= mot_val[2+stride]= 0;
3541 mot_val[1 ]= mot_val[3 ]=
3542 mot_val[1+stride]= mot_val[3+stride]= 0;
3544 if(s->mbintra_table[xy])
3545 ff_clean_intra_table_entries(s);
3547 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3548 s->mcsel= get_bits1(&s->gb);
3551 if ((cbpc & 16) == 0) {
3552 /* 16x16 motion prediction */
3554 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3556 mx = h263_decode_motion(s, pred_x, s->f_code);
3560 my = h263_decode_motion(s, pred_y, s->f_code);
3563 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3567 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3570 mot_val[0 ]= mot_val[2 ] =
3571 mot_val[0+stride]= mot_val[2+stride]= mx;
3572 mot_val[1 ]= mot_val[3 ]=
3573 mot_val[1+stride]= mot_val[3+stride]= my;
3576 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3578 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3579 mx = h263_decode_motion(s, pred_x, s->f_code);
3583 my = h263_decode_motion(s, pred_y, s->f_code);
3600 * decode second partition.
3601 * @return <0 if an error occured
3603 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3605 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3607 s->mb_x= s->resync_mb_x;
3608 s->first_slice_line=1;
3609 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3610 ff_init_block_index(s);
3611 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3612 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3615 ff_update_block_index(s);
3616 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3617 s->first_slice_line=0;
3619 if(s->pict_type==I_TYPE){
3620 int ac_pred= get_bits1(&s->gb);
3621 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3623 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3627 s->cbp_table[xy]|= cbpy<<2;
3628 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3629 }else{ /* P || S_TYPE */
3630 if(IS_INTRA(s->current_picture.mb_type[xy])){
3632 int ac_pred = get_bits1(&s->gb);
3633 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3636 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3640 if(s->cbp_table[xy] & 8) {
3641 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3643 s->current_picture.qscale_table[xy]= s->qscale;
3647 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3649 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3653 if(dc_pred_dir) dir|=1;
3655 s->cbp_table[xy]&= 3; //remove dquant
3656 s->cbp_table[xy]|= cbpy<<2;
3657 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3658 s->pred_dir_table[xy]= dir;
3659 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3660 s->current_picture.qscale_table[xy]= s->qscale;
3661 s->cbp_table[xy]= 0;
3663 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3666 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3670 if(s->cbp_table[xy] & 8) {
3671 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3673 s->current_picture.qscale_table[xy]= s->qscale;
3675 s->cbp_table[xy]&= 3; //remove dquant
3676 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3680 if(mb_num >= mb_count) return 0;
3687 * decodes the first & second partition
3688 * @return <0 if error (and sets error type in the error_status_table)
3690 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3693 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3694 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3696 mb_num= mpeg4_decode_partition_a(s);
3698 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3702 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3703 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3704 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3708 s->mb_num_left= mb_num;
3710 if(s->pict_type==I_TYPE){
3711 while(show_bits(&s->gb, 9) == 1)
3712 skip_bits(&s->gb, 9);
3713 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3714 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3718 while(show_bits(&s->gb, 10) == 1)
3719 skip_bits(&s->gb, 10);
3720 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3721 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3725 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3727 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3728 if(s->pict_type==P_TYPE)
3729 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3732 if(s->pict_type==P_TYPE)
3733 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3740 * decode partition C of one MB.
3741 * @return <0 if an error occured
3743 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3746 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3748 mb_type= s->current_picture.mb_type[xy];
3749 cbp = s->cbp_table[xy];
3751 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3753 if(s->current_picture.qscale_table[xy] != s->qscale){
3754 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3757 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3760 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3761 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3763 s->mb_intra = IS_INTRA(mb_type);
3765 if (IS_SKIP(mb_type)) {
3768 s->block_last_index[i] = -1;
3769 s->mv_dir = MV_DIR_FORWARD;
3770 s->mv_type = MV_TYPE_16X16;
3771 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3778 }else if(s->mb_intra){
3779 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3780 }else if(!s->mb_intra){
3781 // s->mcsel= 0; //FIXME do we need to init that
3783 s->mv_dir = MV_DIR_FORWARD;
3784 if (IS_8X8(mb_type)) {
3785 s->mv_type = MV_TYPE_8X8;
3787 s->mv_type = MV_TYPE_16X16;
3790 } else { /* I-Frame */
3792 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3795 if (!IS_SKIP(mb_type)) {
3797 s->dsp.clear_blocks(s->block[0]);
3798 /* decode each block */
3799 for (i = 0; i < 6; i++) {
3800 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3801 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3808 /* per-MB end of slice check */
3810 if(--s->mb_num_left <= 0){
3811 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3812 if(mpeg4_is_resync(s))
3817 if(mpeg4_is_resync(s)){
3818 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3819 if(s->cbp_table[xy+delta])
3827 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3829 static void preview_obmc(MpegEncContext *s){
3830 GetBitContext gb= s->gb;
3832 int cbpc, i, pred_x, pred_y, mx, my;
3834 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3835 const int stride= s->b8_stride*2;
3838 s->block_index[i]+= 2;
3840 s->block_index[i]+= 1;
3843 assert(s->pict_type == P_TYPE);
3846 if (get_bits1(&s->gb)) {
3848 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3849 mot_val[0 ]= mot_val[2 ]=
3850 mot_val[0+stride]= mot_val[2+stride]= 0;
3851 mot_val[1 ]= mot_val[3 ]=
3852 mot_val[1+stride]= mot_val[3+stride]= 0;
3854 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3857 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3861 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3863 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3865 if(s->modified_quant){
3866 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3867 else skip_bits(&s->gb, 5);
3869 skip_bits(&s->gb, 2);
3872 if ((cbpc & 16) == 0) {
3873 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3874 /* 16x16 motion prediction */
3875 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3877 mx = h263p_decode_umotion(s, pred_x);
3879 mx = h263_decode_motion(s, pred_x, 1);
3882 my = h263p_decode_umotion(s, pred_y);
3884 my = h263_decode_motion(s, pred_y, 1);
3886 mot_val[0 ]= mot_val[2 ]=
3887 mot_val[0+stride]= mot_val[2+stride]= mx;
3888 mot_val[1 ]= mot_val[3 ]=
3889 mot_val[1+stride]= mot_val[3+stride]= my;
3891 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3893 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3895 mx = h263p_decode_umotion(s, pred_x);
3897 mx = h263_decode_motion(s, pred_x, 1);
3900 my = h263p_decode_umotion(s, pred_y);
3902 my = h263_decode_motion(s, pred_y, 1);
3903 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3904 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3913 s->block_index[i]-= 2;
3915 s->block_index[i]-= 1;
3921 static void h263_decode_dquant(MpegEncContext *s){
3922 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3924 if(s->modified_quant){
3925 if(get_bits1(&s->gb))
3926 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3928 s->qscale= get_bits(&s->gb, 5);
3930 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3931 ff_set_qscale(s, s->qscale);
3934 int ff_h263_decode_mb(MpegEncContext *s,
3935 DCTELEM block[6][64])
3937 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3939 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3941 assert(!s->h263_pred);
3943 if (s->pict_type == P_TYPE) {
3945 if (get_bits1(&s->gb)) {
3949 s->block_last_index[i] = -1;
3950 s->mv_dir = MV_DIR_FORWARD;
3951 s->mv_type = MV_TYPE_16X16;
3952 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3955 s->mb_skipped = !(s->obmc | s->loop_filter);
3958 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3959 //fprintf(stderr, "\tCBPC: %d", cbpc);
3961 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3966 s->dsp.clear_blocks(s->block[0]);
3969 s->mb_intra = ((cbpc & 4) != 0);
3970 if (s->mb_intra) goto intra;
3972 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3974 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3977 cbp = (cbpc & 3) | (cbpy << 2);
3979 h263_decode_dquant(s);
3982 s->mv_dir = MV_DIR_FORWARD;
3983 if ((cbpc & 16) == 0) {
3984 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3985 /* 16x16 motion prediction */
3986 s->mv_type = MV_TYPE_16X16;
3987 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3989 mx = h263p_decode_umotion(s, pred_x);
3991 mx = h263_decode_motion(s, pred_x, 1);
3997 my = h263p_decode_umotion(s, pred_y);
3999 my = h263_decode_motion(s, pred_y, 1);
4003 s->mv[0][0][0] = mx;
4004 s->mv[0][0][1] = my;
4006 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4007 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4009 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4010 s->mv_type = MV_TYPE_8X8;
4012 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4014 mx = h263p_decode_umotion(s, pred_x);
4016 mx = h263_decode_motion(s, pred_x, 1);
4021 my = h263p_decode_umotion(s, pred_y);
4023 my = h263_decode_motion(s, pred_y, 1);
4026 s->mv[0][i][0] = mx;
4027 s->mv[0][i][1] = my;
4028 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4029 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4035 /* decode each block */
4036 for (i = 0; i < 6; i++) {
4037 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4043 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4046 } else if(s->pict_type==B_TYPE) {
4048 const int stride= s->b8_stride;
4049 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4050 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4051 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4054 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4055 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4056 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4057 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4060 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4062 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4066 mb_type= h263_mb_type_b_map[ mb_type ];
4069 s->mb_intra = IS_INTRA(mb_type);
4070 if(HAS_CBP(mb_type)){
4071 s->dsp.clear_blocks(s->block[0]);
4072 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4074 dquant = IS_QUANT(mb_type);
4078 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4081 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4085 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4088 cbp = (cbpc & 3) | (cbpy << 2);
4092 assert(!s->mb_intra);
4094 if(IS_QUANT(mb_type)){
4095 h263_decode_dquant(s);
4098 if(IS_DIRECT(mb_type)){
4099 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4100 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4103 s->mv_type= MV_TYPE_16X16;
4106 if(USES_LIST(mb_type, 0)){
4107 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4108 s->mv_dir = MV_DIR_FORWARD;
4110 mx = h263_decode_motion(s, mx, 1);
4111 my = h263_decode_motion(s, my, 1);
4113 s->mv[0][0][0] = mx;
4114 s->mv[0][0][1] = my;
4115 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4116 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4119 if(USES_LIST(mb_type, 1)){
4120 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4121 s->mv_dir |= MV_DIR_BACKWARD;
4123 mx = h263_decode_motion(s, mx, 1);
4124 my = h263_decode_motion(s, my, 1);
4126 s->mv[1][0][0] = mx;
4127 s->mv[1][0][1] = my;
4128 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4129 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4133 s->current_picture.mb_type[xy]= mb_type;
4135 /* decode each block */
4136 for (i = 0; i < 6; i++) {
4137 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4141 } else { /* I-Frame */
4143 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4145 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4150 s->dsp.clear_blocks(s->block[0]);
4155 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4157 s->ac_pred = get_bits1(&s->gb);
4159 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4161 s->h263_aic_dir = get_bits1(&s->gb);
4166 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4168 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4171 cbp = (cbpc & 3) | (cbpy << 2);
4173 h263_decode_dquant(s);
4176 /* decode each block */
4177 for (i = 0; i < 6; i++) {
4178 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4185 /* per-MB end of slice check */
4187 int v= show_bits(&s->gb, 16);
4189 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4190 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4200 int ff_mpeg4_decode_mb(MpegEncContext *s,
4201 DCTELEM block[6][64])
4203 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4205 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4206 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4208 assert(s->h263_pred);
4210 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4212 if (get_bits1(&s->gb)) {
4216 s->block_last_index[i] = -1;
4217 s->mv_dir = MV_DIR_FORWARD;
4218 s->mv_type = MV_TYPE_16X16;
4219 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4220 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4222 s->mv[0][0][0]= get_amv(s, 0);
4223 s->mv[0][0][1]= get_amv(s, 1);
4227 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4235 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4236 //fprintf(stderr, "\tCBPC: %d", cbpc);
4238 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4243 s->dsp.clear_blocks(s->block[0]);
4245 s->mb_intra = ((cbpc & 4) != 0);
4246 if (s->mb_intra) goto intra;
4248 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4249 s->mcsel= get_bits1(&s->gb);
4251 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4253 cbp = (cbpc & 3) | (cbpy << 2);
4255 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4257 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4258 s->interlaced_dct= get_bits1(&s->gb);
4260 s->mv_dir = MV_DIR_FORWARD;
4261 if ((cbpc & 16) == 0) {
4263 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4264 /* 16x16 global motion prediction */
4265 s->mv_type = MV_TYPE_16X16;
4268 s->mv[0][0][0] = mx;
4269 s->mv[0][0][1] = my;
4270 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4271 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4272 /* 16x8 field motion prediction */
4273 s->mv_type= MV_TYPE_FIELD;
4275 s->field_select[0][0]= get_bits1(&s->gb);
4276 s->field_select[0][1]= get_bits1(&s->gb);
4278 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4281 mx = h263_decode_motion(s, pred_x, s->f_code);
4285 my = h263_decode_motion(s, pred_y/2, s->f_code);
4289 s->mv[0][i][0] = mx;
4290 s->mv[0][i][1] = my;
4293 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4294 /* 16x16 motion prediction */
4295 s->mv_type = MV_TYPE_16X16;
4296 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4297 mx = h263_decode_motion(s, pred_x, s->f_code);
4302 my = h263_decode_motion(s, pred_y, s->f_code);
4306 s->mv[0][0][0] = mx;
4307 s->mv[0][0][1] = my;
4310 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4311 s->mv_type = MV_TYPE_8X8;
4313 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4314 mx = h263_decode_motion(s, pred_x, s->f_code);
4318 my = h263_decode_motion(s, pred_y, s->f_code);
4321 s->mv[0][i][0] = mx;
4322 s->mv[0][i][1] = my;
4327 } else if(s->pict_type==B_TYPE) {
4328 int modb1; // first bit of modb
4329 int modb2; // second bit of modb
4332 s->mb_intra = 0; //B-frames never contain intra blocks
4333 s->mcsel=0; // ... true gmc blocks
4337 s->last_mv[i][0][0]=
4338 s->last_mv[i][0][1]=
4339 s->last_mv[i][1][0]=
4340 s->last_mv[i][1][1]= 0;
4344 /* if we skipped it in the future P Frame than skip it now too */
4345 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4350 s->block_last_index[i] = -1;
4352 s->mv_dir = MV_DIR_FORWARD;
4353 s->mv_type = MV_TYPE_16X16;
4358 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4362 modb1= get_bits1(&s->gb);
4364 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4367 modb2= get_bits1(&s->gb);
4368 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4370 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4373 mb_type= mb_type_b_map[ mb_type ];
4376 s->dsp.clear_blocks(s->block[0]);
4377 cbp= get_bits(&s->gb, 6);
4380 if ((!IS_DIRECT(mb_type)) && cbp) {
4381 if(get_bits1(&s->gb)){
4382 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4386 if(!s->progressive_sequence){
4388 s->interlaced_dct= get_bits1(&s->gb);
4390 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4391 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4392 mb_type &= ~MB_TYPE_16x16;
4394 if(USES_LIST(mb_type, 0)){
4395 s->field_select[0][0]= get_bits1(&s->gb);
4396 s->field_select[0][1]= get_bits1(&s->gb);
4398 if(USES_LIST(mb_type, 1)){
4399 s->field_select[1][0]= get_bits1(&s->gb);
4400 s->field_select[1][1]= get_bits1(&s->gb);
4406 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4407 s->mv_type= MV_TYPE_16X16;
4409 if(USES_LIST(mb_type, 0)){
4410 s->mv_dir = MV_DIR_FORWARD;
4412 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4413 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4414 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4415 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4418 if(USES_LIST(mb_type, 1)){
4419 s->mv_dir |= MV_DIR_BACKWARD;
4421 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4422 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4423 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4424 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4426 }else if(!IS_DIRECT(mb_type)){
4427 s->mv_type= MV_TYPE_FIELD;
4429 if(USES_LIST(mb_type, 0)){
4430 s->mv_dir = MV_DIR_FORWARD;
4433 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4434 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4435 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4436 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4440 if(USES_LIST(mb_type, 1)){
4441 s->mv_dir |= MV_DIR_BACKWARD;
4444 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4445 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4446 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4447 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4453 if(IS_DIRECT(mb_type)){
4454 if(IS_SKIP(mb_type))
4457 mx = h263_decode_motion(s, 0, 1);
4458 my = h263_decode_motion(s, 0, 1);
4461 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4462 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4464 s->current_picture.mb_type[xy]= mb_type;
4465 } else { /* I-Frame */
4467 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4469 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4477 s->ac_pred = get_bits1(&s->gb);
4479 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4481 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4483 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4485 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4488 cbp = (cbpc & 3) | (cbpy << 2);
4490 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4493 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4496 if(!s->progressive_sequence)
4497 s->interlaced_dct= get_bits1(&s->gb);
4499 s->dsp.clear_blocks(s->block[0]);
4500 /* decode each block */
4501 for (i = 0; i < 6; i++) {
4502 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4509 /* decode each block */
4510 for (i = 0; i < 6; i++) {
4511 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4517 /* per-MB end of slice check */
4518 if(s->codec_id==CODEC_ID_MPEG4){
4519 #if 0 //http://standards.iso.org/ittf/PubliclyAvailableStandards/ISO_IEC_14496-4_2004_Conformance_Testing/video_conformance/version_1/simple/ERROR.ZIP/mit025.m4v needs this but its unclear if the mpeg4 standard allows this at all (MN)
4520 if(s->pict_type != B_TYPE){
4521 while(show_bits(&s->gb, 9 + (s->pict_type == P_TYPE)) == 1)
4522 skip_bits(&s->gb, 9 + (s->pict_type == P_TYPE));
4525 if(mpeg4_is_resync(s)){
4526 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4527 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4536 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4538 int code, val, sign, shift, l;
4539 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4546 sign = get_bits1(&s->gb);
4550 val = (val - 1) << shift;
4551 val |= get_bits(&s->gb, shift);
4558 /* modulo decoding */
4559 if (!s->h263_long_vectors) {
4560 l = INT_BIT - 5 - f_code;
4563 /* horrible h263 long vector mode */
4564 if (pred < -31 && val < -63)
4566 if (pred > 32 && val > 63)
4573 /* Decodes RVLC of H.263+ UMV */
4574 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4578 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4581 code = 2 + get_bits1(&s->gb);
4583 while (get_bits1(&s->gb))
4586 code += get_bits1(&s->gb);
4591 code = (sign) ? (pred - code) : (pred + code);
4593 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4599 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4602 int code, level, i, j, last, run;
4603 RLTable *rl = &rl_inter;
4604 const uint8_t *scan_table;
4605 GetBitContext gb= s->gb;
4607 scan_table = s->intra_scantable.permutated;
4608 if (s->h263_aic && s->mb_intra) {
4612 if (s->h263_aic_dir)
4613 scan_table = s->intra_v_scantable.permutated; /* left */
4615 scan_table = s->intra_h_scantable.permutated; /* top */
4617 } else if (s->mb_intra) {
4619 if(s->codec_id == CODEC_ID_RV10){
4620 #ifdef CONFIG_RV10_DECODER
4621 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4622 int component, diff;
4623 component = (n <= 3 ? 0 : n - 4 + 1);
4624 level = s->last_dc[component];
4625 if (s->rv10_first_dc_coded[component]) {
4626 diff = rv_decode_dc(s, n);
4630 level = level & 0xff; /* handle wrap round */
4631 s->last_dc[component] = level;
4633 s->rv10_first_dc_coded[component] = 1;
4636 level = get_bits(&s->gb, 8);
4642 level = get_bits(&s->gb, 8);
4643 if((level&0x7F) == 0){
4644 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4645 if(s->error_resilience >= FF_ER_COMPLIANT)
4657 if (s->mb_intra && s->h263_aic)
4659 s->block_last_index[n] = i - 1;
4664 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4666 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4669 if (code == rl->n) {
4671 if (s->h263_flv > 1) {
4672 int is11 = get_bits1(&s->gb);
4673 last = get_bits1(&s->gb);
4674 run = get_bits(&s->gb, 6);
4676 level = get_sbits(&s->gb, 11);
4678 level = get_sbits(&s->gb, 7);
4681 last = get_bits1(&s->gb);
4682 run = get_bits(&s->gb, 6);
4683 level = (int8_t)get_bits(&s->gb, 8);
4685 if (s->codec_id == CODEC_ID_RV10) {
4686 /* XXX: should patch encoder too */
4687 level = get_sbits(&s->gb, 12);
4689 level = get_bits(&s->gb, 5);
4690 level |= get_sbits(&s->gb, 6)<<5;
4695 run = rl->table_run[code];
4696 level = rl->table_level[code];
4697 last = code >= rl->last;
4698 if (get_bits1(&s->gb))
4703 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4704 //looks like a hack but no, it's the way its supposed to work ...
4708 memset(block, 0, sizeof(DCTELEM)*64);
4711 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4721 if (s->mb_intra && s->h263_aic) {
4722 h263_pred_acdc(s, block, n);
4725 s->block_last_index[n] = i;
4730 * decodes the dc value.
4731 * @param n block index (0-3 are luma, 4-5 are chroma)
4732 * @param dir_ptr the prediction direction will be stored here
4733 * @return the quantized dc
4735 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4740 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4742 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4743 if (code < 0 || code > 9 /* && s->nbit<9 */){
4744 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4752 level= 2*get_bits1(&s->gb)-1;
4754 if(get_bits1(&s->gb))
4755 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4757 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4760 level = get_xbits(&s->gb, code);
4764 if(get_bits1(&s->gb)==0){ /* marker */
4765 if(s->error_resilience>=2){
4766 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4773 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4778 * @return <0 if an error occured
4780 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4781 int n, int coded, int intra, int rvlc)
4783 int level, i, last, run;
4786 RL_VLC_ELEM * rl_vlc;
4787 const uint8_t * scan_table;
4790 //Note intra & rvlc should be optimized away if this is inlined
4793 if(s->use_intra_dc_vlc){
4795 if(s->partitioned_frame){
4796 level = s->dc_val[0][ s->block_index[n] ];
4797 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4798 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4799 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4801 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4809 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4815 rl = &rvlc_rl_intra;
4816 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4819 rl_vlc = rl_intra.rl_vlc[0];
4822 if (dc_pred_dir == 0)
4823 scan_table = s->intra_v_scantable.permutated; /* left */
4825 scan_table = s->intra_h_scantable.permutated; /* top */
4827 scan_table = s->intra_scantable.permutated;
4834 s->block_last_index[n] = i;
4837 if(rvlc) rl = &rvlc_rl_inter;
4838 else rl = &rl_inter;
4840 scan_table = s->intra_scantable.permutated;
4846 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4848 rl_vlc = rl_inter.rl_vlc[0];
4851 qmul = s->qscale << 1;
4852 qadd = (s->qscale - 1) | 1;
4854 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4856 rl_vlc = rl_inter.rl_vlc[s->qscale];
4861 OPEN_READER(re, &s->gb);
4863 UPDATE_CACHE(re, &s->gb);
4864 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4868 if(SHOW_UBITS(re, &s->gb, 1)==0){
4869 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4871 }; SKIP_CACHE(re, &s->gb, 1);
4873 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4874 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4875 SKIP_COUNTER(re, &s->gb, 1+1+6);
4876 UPDATE_CACHE(re, &s->gb);
4878 if(SHOW_UBITS(re, &s->gb, 1)==0){
4879 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4881 }; SKIP_CACHE(re, &s->gb, 1);
4883 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4885 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4886 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4888 }; SKIP_CACHE(re, &s->gb, 5);
4890 level= level * qmul + qadd;
4891 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4892 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4898 cache= GET_CACHE(re, &s->gb);
4901 cache ^= 0xC0000000;
4903 if (cache&0x80000000) {
4904 if (cache&0x40000000) {
4906 SKIP_CACHE(re, &s->gb, 2);
4907 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4908 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4909 SKIP_COUNTER(re, &s->gb, 2+1+6);
4910 UPDATE_CACHE(re, &s->gb);
4913 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4915 if(SHOW_UBITS(re, &s->gb, 1)==0){
4916 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4918 }; SKIP_CACHE(re, &s->gb, 1);
4920 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4922 if(SHOW_UBITS(re, &s->gb, 1)==0){
4923 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4925 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4927 SKIP_COUNTER(re, &s->gb, 1+12+1);
4931 if(s->error_resilience >= FF_ER_COMPLIANT){
4932 const int abs_level= ABS(level);
4933 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4934 const int run1= run - rl->max_run[last][abs_level] - 1;
4935 if(abs_level <= rl->max_level[last][run]){
4936 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4939 if(s->error_resilience > FF_ER_COMPLIANT){
4940 if(abs_level <= rl->max_level[last][run]*2){
4941 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4944 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4945 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4952 if (level>0) level= level * qmul + qadd;
4953 else level= level * qmul - qadd;
4955 if((unsigned)(level + 2048) > 4095){
4956 if(s->error_resilience > FF_ER_COMPLIANT){
4957 if(level > 2560 || level<-2560){
4958 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4962 level= level<0 ? -2048 : 2047;
4969 #if MIN_CACHE_BITS < 20
4970 LAST_SKIP_BITS(re, &s->gb, 2);
4971 UPDATE_CACHE(re, &s->gb);
4973 SKIP_BITS(re, &s->gb, 2);
4975 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4976 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4977 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4978 LAST_SKIP_BITS(re, &s->gb, 1);
4982 #if MIN_CACHE_BITS < 19
4983 LAST_SKIP_BITS(re, &s->gb, 1);
4984 UPDATE_CACHE(re, &s->gb);
4986 SKIP_BITS(re, &s->gb, 1);
4988 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4990 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4991 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4992 LAST_SKIP_BITS(re, &s->gb, 1);
4997 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4998 LAST_SKIP_BITS(re, &s->gb, 1);
5003 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5007 block[scan_table[i]] = level;
5011 block[scan_table[i]] = level;
5013 CLOSE_READER(re, &s->gb);
5017 if(!s->use_intra_dc_vlc){
5018 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5020 i -= i>>31; //if(i == -1) i=0;
5023 mpeg4_pred_ac(s, block, n, dc_pred_dir);
5025 i = 63; /* XXX: not optimal */
5028 s->block_last_index[n] = i;
5032 /* most is hardcoded. should extend to handle all h263 streams */
5033 int h263_decode_picture_header(MpegEncContext *s)
5035 int format, width, height, i;
5038 align_get_bits(&s->gb);
5040 startcode= get_bits(&s->gb, 22-8);
5042 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5043 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5045 if(startcode == 0x20)
5049 if (startcode != 0x20) {
5050 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5053 /* temporal reference */
5054 i = get_bits(&s->gb, 8); /* picture timestamp */
5055 if( (s->picture_number&~0xFF)+i < s->picture_number)
5057 s->current_picture_ptr->pts=
5058 s->picture_number= (s->picture_number&~0xFF) + i;
5060 /* PTYPE starts here */
5061 if (get_bits1(&s->gb) != 1) {
5063 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5066 if (get_bits1(&s->gb) != 0) {
5067 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5068 return -1; /* h263 id */
5070 skip_bits1(&s->gb); /* split screen off */
5071 skip_bits1(&s->gb); /* camera off */
5072 skip_bits1(&s->gb); /* freeze picture release off */
5074 format = get_bits(&s->gb, 3);
5079 7 extended PTYPE (PLUSPTYPE)
5082 if (format != 7 && format != 6) {
5085 width = h263_format[format][0];
5086 height = h263_format[format][1];
5090 s->pict_type = I_TYPE + get_bits1(&s->gb);
5092 s->h263_long_vectors = get_bits1(&s->gb);
5094 if (get_bits1(&s->gb) != 0) {
5095 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5096 return -1; /* SAC: off */
5098 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5099 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5101 if (get_bits1(&s->gb) != 0) {
5102 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5103 return -1; /* not PB frame */
5105 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5106 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5110 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5111 s->avctx->time_base= (AVRational){1001, 30000};
5117 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5119 /* ufep other than 0 and 1 are reserved */
5122 format = get_bits(&s->gb, 3);
5123 dprintf("ufep=1, format: %d\n", format);
5124 s->custom_pcf= get_bits1(&s->gb);
5125 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5126 if (get_bits1(&s->gb) != 0) {
5127 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5129 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5130 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5131 s->loop_filter= get_bits1(&s->gb);
5132 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5134 s->h263_slice_structured= get_bits1(&s->gb);
5135 if (get_bits1(&s->gb) != 0) {
5136 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5138 if (get_bits1(&s->gb) != 0) {
5139 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5141 s->alt_inter_vlc= get_bits1(&s->gb);
5142 s->modified_quant= get_bits1(&s->gb);
5143 if(s->modified_quant)
5144 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5146 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5148 skip_bits(&s->gb, 3); /* Reserved */
5149 } else if (ufep != 0) {
5150 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5155 s->pict_type = get_bits(&s->gb, 3);
5156 switch(s->pict_type){
5157 case 0: s->pict_type= I_TYPE;break;
5158 case 1: s->pict_type= P_TYPE;break;
5159 case 3: s->pict_type= B_TYPE;break;
5160 case 7: s->pict_type= I_TYPE;break; //ZYGO
5164 skip_bits(&s->gb, 2);
5165 s->no_rounding = get_bits1(&s->gb);
5166 skip_bits(&s->gb, 4);
5168 /* Get the picture dimensions */
5171 /* Custom Picture Format (CPFMT) */
5172 s->aspect_ratio_info = get_bits(&s->gb, 4);
5173 dprintf("aspect: %d\n", s->aspect_ratio_info);
5178 3 - 10:11 (525-type 4:3)
5179 4 - 16:11 (CIF 16:9)
5180 5 - 40:33 (525-type 16:9)
5183 width = (get_bits(&s->gb, 9) + 1) * 4;
5185 height = get_bits(&s->gb, 9) * 4;
5186 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5187 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5188 /* aspected dimensions */
5189 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5190 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5192 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5195 width = h263_format[format][0];
5196 height = h263_format[format][1];
5197 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5199 if ((width == 0) || (height == 0))
5206 s->avctx->time_base.den= 1800000;
5207 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5208 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5209 if(s->avctx->time_base.num == 0){
5210 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5213 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5214 s->avctx->time_base.den /= gcd;
5215 s->avctx->time_base.num /= gcd;
5216 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5218 s->avctx->time_base= (AVRational){1001, 30000};
5223 skip_bits(&s->gb, 2); //extended Temporal reference
5228 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5231 if(s->h263_slice_structured){
5232 if (get_bits1(&s->gb) != 0) {
5233 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5235 if (get_bits1(&s->gb) != 0) {
5236 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5241 s->qscale = get_bits(&s->gb, 5);
5244 s->mb_width = (s->width + 15) / 16;
5245 s->mb_height = (s->height + 15) / 16;
5246 s->mb_num = s->mb_width * s->mb_height;
5249 while (get_bits1(&s->gb) != 0) {
5250 skip_bits(&s->gb, 8);
5253 if(s->h263_slice_structured){
5254 if (get_bits1(&s->gb) != 1) {
5255 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5259 ff_h263_decode_mba(s);
5261 if (get_bits1(&s->gb) != 1) {
5262 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5269 s->y_dc_scale_table=
5270 s->c_dc_scale_table= ff_aic_dc_scale_table;
5272 s->y_dc_scale_table=
5273 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5276 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5277 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
5278 s->qscale, av_get_pict_type_char(s->pict_type),
5279 s->gb.size_in_bits, 1-s->no_rounding,
5280 s->obmc ? " AP" : "",
5281 s->umvplus ? " UMV" : "",
5282 s->h263_long_vectors ? " LONG" : "",
5283 s->h263_plus ? " +" : "",
5284 s->h263_aic ? " AIC" : "",
5285 s->alt_inter_vlc ? " AIV" : "",
5286 s->modified_quant ? " MQ" : "",
5287 s->loop_filter ? " LOOP" : "",
5288 s->h263_slice_structured ? " SS" : "",
5289 s->avctx->time_base.den, s->avctx->time_base.num
5293 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5295 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5296 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5297 for(i=0; i<13; i++){
5299 int v= get_bits(&s->gb, 8);
5300 v |= get_sbits(&s->gb, 8)<<8;
5301 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5303 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5305 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5312 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5315 int a= 2<<s->sprite_warping_accuracy;
5316 int rho= 3-s->sprite_warping_accuracy;
5318 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5319 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5320 int sprite_ref[4][2];
5321 int virtual_ref[2][2];
5323 int alpha=0, beta=0;
5328 for(i=0; i<s->num_sprite_warping_points; i++){
5332 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5334 x= get_xbits(gb, length);
5336 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5338 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5340 y=get_xbits(gb, length);
5342 skip_bits1(gb); /* marker bit */
5343 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5348 while((1<<alpha)<w) alpha++;
5349 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5353 // Note, the 4th point isn't used for GMC
5354 if(s->divx_version==500 && s->divx_build==413){
5355 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5356 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5357 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5358 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5359 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5360 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5362 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5363 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5364 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5365 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5366 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5367 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5369 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5370 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5372 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5373 // perhaps it should be reordered to be more readable ...
5374 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5375 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5376 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5377 + 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);
5378 virtual_ref[0][1]= 16*vop_ref[0][1]
5379 + 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);
5380 virtual_ref[1][0]= 16*vop_ref[0][0]
5381 + 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);
5382 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5383 + 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);
5385 switch(s->num_sprite_warping_points)
5388 s->sprite_offset[0][0]= 0;
5389 s->sprite_offset[0][1]= 0;
5390 s->sprite_offset[1][0]= 0;
5391 s->sprite_offset[1][1]= 0;
5392 s->sprite_delta[0][0]= a;
5393 s->sprite_delta[0][1]= 0;
5394 s->sprite_delta[1][0]= 0;
5395 s->sprite_delta[1][1]= a;
5396 s->sprite_shift[0]= 0;
5397 s->sprite_shift[1]= 0;
5400 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5401 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5402 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5403 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5404 s->sprite_delta[0][0]= a;
5405 s->sprite_delta[0][1]= 0;
5406 s->sprite_delta[1][0]= 0;
5407 s->sprite_delta[1][1]= a;
5408 s->sprite_shift[0]= 0;
5409 s->sprite_shift[1]= 0;
5412 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5413 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5414 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5415 + (1<<(alpha+rho-1));
5416 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5417 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5418 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5419 + (1<<(alpha+rho-1));
5420 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5421 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5422 +2*w2*r*sprite_ref[0][0]
5424 + (1<<(alpha+rho+1)));
5425 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5426 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5427 +2*w2*r*sprite_ref[0][1]
5429 + (1<<(alpha+rho+1)));
5430 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5431 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5432 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5433 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5435 s->sprite_shift[0]= alpha+rho;
5436 s->sprite_shift[1]= alpha+rho+2;
5439 min_ab= FFMIN(alpha, beta);
5442 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5443 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5444 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5445 + (1<<(alpha+beta+rho-min_ab-1));
5446 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5447 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5448 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5449 + (1<<(alpha+beta+rho-min_ab-1));
5450 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5451 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5452 + 2*w2*h3*r*sprite_ref[0][0]
5454 + (1<<(alpha+beta+rho-min_ab+1));
5455 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5456 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5457 + 2*w2*h3*r*sprite_ref[0][1]
5459 + (1<<(alpha+beta+rho-min_ab+1));
5460 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5461 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5462 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5463 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5465 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5466 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5469 /* try to simplify the situation */
5470 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5471 && s->sprite_delta[0][1] == 0
5472 && s->sprite_delta[1][0] == 0
5473 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5475 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5476 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5477 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5478 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5479 s->sprite_delta[0][0]= a;
5480 s->sprite_delta[0][1]= 0;
5481 s->sprite_delta[1][0]= 0;
5482 s->sprite_delta[1][1]= a;
5483 s->sprite_shift[0]= 0;
5484 s->sprite_shift[1]= 0;
5485 s->real_sprite_warping_points=1;
5488 int shift_y= 16 - s->sprite_shift[0];
5489 int shift_c= 16 - s->sprite_shift[1];
5490 //printf("shifts %d %d\n", shift_y, shift_c);
5492 s->sprite_offset[0][i]<<= shift_y;
5493 s->sprite_offset[1][i]<<= shift_c;
5494 s->sprite_delta[0][i]<<= shift_y;
5495 s->sprite_delta[1][i]<<= shift_y;
5496 s->sprite_shift[i]= 16;
5498 s->real_sprite_warping_points= s->num_sprite_warping_points;
5501 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5502 vop_ref[0][0], vop_ref[0][1],
5503 vop_ref[1][0], vop_ref[1][1],
5504 vop_ref[2][0], vop_ref[2][1],
5505 sprite_ref[0][0], sprite_ref[0][1],
5506 sprite_ref[1][0], sprite_ref[1][1],
5507 sprite_ref[2][0], sprite_ref[2][1],
5508 virtual_ref[0][0], virtual_ref[0][1],
5509 virtual_ref[1][0], virtual_ref[1][1]
5512 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5513 s->sprite_offset[0][0], s->sprite_offset[0][1],
5514 s->sprite_delta[0][0], s->sprite_delta[0][1],
5515 s->sprite_delta[1][0], s->sprite_delta[1][1],
5521 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5522 int hours, minutes, seconds;
5524 hours= get_bits(gb, 5);
5525 minutes= get_bits(gb, 6);
5527 seconds= get_bits(gb, 6);
5529 s->time_base= seconds + 60*(minutes + 60*hours);
5537 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5538 int width, height, vo_ver_id;
5541 skip_bits(gb, 1); /* random access */
5542 s->vo_type= get_bits(gb, 8);
5543 if (get_bits1(gb) != 0) { /* is_ol_id */
5544 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5545 skip_bits(gb, 3); /* vo_priority */
5549 //printf("vo type:%d\n",s->vo_type);
5550 s->aspect_ratio_info= get_bits(gb, 4);
5551 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5552 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5553 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5555 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5558 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5559 int chroma_format= get_bits(gb, 2);
5560 if(chroma_format!=1){
5561 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5563 s->low_delay= get_bits1(gb);
5564 if(get_bits1(gb)){ /* vbv parameters */
5565 get_bits(gb, 15); /* first_half_bitrate */
5566 skip_bits1(gb); /* marker */
5567 get_bits(gb, 15); /* latter_half_bitrate */
5568 skip_bits1(gb); /* marker */
5569 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5570 skip_bits1(gb); /* marker */
5571 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5572 get_bits(gb, 11); /* first_half_vbv_occupancy */
5573 skip_bits1(gb); /* marker */
5574 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5575 skip_bits1(gb); /* marker */
5578 // set low delay flag only once the smartest? low delay detection won't be overriden
5579 if(s->picture_number==0)
5583 s->shape = get_bits(gb, 2); /* vol shape */
5584 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5585 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5586 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5587 skip_bits(gb, 4); //video_object_layer_shape_extension
5590 check_marker(gb, "before time_increment_resolution");
5592 s->avctx->time_base.den = get_bits(gb, 16);
5593 if(!s->avctx->time_base.den){
5594 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5598 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5599 if (s->time_increment_bits < 1)
5600 s->time_increment_bits = 1;
5602 check_marker(gb, "before fixed_vop_rate");
5604 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5605 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5607 s->avctx->time_base.num = 1;
5611 if (s->shape != BIN_ONLY_SHAPE) {
5612 if (s->shape == RECT_SHAPE) {
5613 skip_bits1(gb); /* marker */
5614 width = get_bits(gb, 13);
5615 skip_bits1(gb); /* marker */
5616 height = get_bits(gb, 13);
5617 skip_bits1(gb); /* marker */
5618 if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5621 // printf("width/height: %d %d\n", width, height);
5625 s->progressive_sequence=
5626 s->progressive_frame= get_bits1(gb)^1;
5627 s->interlaced_dct=0;
5628 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5629 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5630 if (vo_ver_id == 1) {
5631 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5633 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5635 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5636 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5637 if(s->vol_sprite_usage==STATIC_SPRITE){
5638 s->sprite_width = get_bits(gb, 13);
5639 skip_bits1(gb); /* marker */
5640 s->sprite_height= get_bits(gb, 13);
5641 skip_bits1(gb); /* marker */
5642 s->sprite_left = get_bits(gb, 13);
5643 skip_bits1(gb); /* marker */
5644 s->sprite_top = get_bits(gb, 13);
5645 skip_bits1(gb); /* marker */
5647 s->num_sprite_warping_points= get_bits(gb, 6);
5648 s->sprite_warping_accuracy = get_bits(gb, 2);
5649 s->sprite_brightness_change= get_bits1(gb);
5650 if(s->vol_sprite_usage==STATIC_SPRITE)
5651 s->low_latency_sprite= get_bits1(gb);
5653 // FIXME sadct disable bit if verid!=1 && shape not rect
5655 if (get_bits1(gb) == 1) { /* not_8_bit */
5656 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5657 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5658 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5660 s->quant_precision = 5;
5663 // FIXME a bunch of grayscale shape things
5665 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5668 /* load default matrixes */
5669 for(i=0; i<64; i++){
5670 int j= s->dsp.idct_permutation[i];
5671 v= ff_mpeg4_default_intra_matrix[i];
5672 s->intra_matrix[j]= v;
5673 s->chroma_intra_matrix[j]= v;
5675 v= ff_mpeg4_default_non_intra_matrix[i];
5676 s->inter_matrix[j]= v;
5677 s->chroma_inter_matrix[j]= v;
5680 /* load custom intra matrix */
5683 for(i=0; i<64; i++){
5689 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5690 s->intra_matrix[j]= v;
5691 s->chroma_intra_matrix[j]= v;
5694 /* replicate last value */
5696 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5697 s->intra_matrix[j]= last;
5698 s->chroma_intra_matrix[j]= last;
5702 /* load custom non intra matrix */
5705 for(i=0; i<64; i++){
5711 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5712 s->inter_matrix[j]= v;
5713 s->chroma_inter_matrix[j]= v;
5716 /* replicate last value */
5718 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5719 s->inter_matrix[j]= last;
5720 s->chroma_inter_matrix[j]= last;
5724 // FIXME a bunch of grayscale shape things
5728 s->quarter_sample= get_bits1(gb);
5729 else s->quarter_sample=0;
5731 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5733 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5735 s->data_partitioning= get_bits1(gb);
5736 if(s->data_partitioning){
5737 s->rvlc= get_bits1(gb);
5740 if(vo_ver_id != 1) {
5741 s->new_pred= get_bits1(gb);
5743 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5744 skip_bits(gb, 2); /* requested upstream message type */
5745 skip_bits1(gb); /* newpred segment type */
5747 s->reduced_res_vop= get_bits1(gb);
5748 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5752 s->reduced_res_vop= 0;
5755 s->scalability= get_bits1(gb);
5757 if (s->scalability) {
5758 GetBitContext bak= *gb;
5760 int ref_layer_sampling_dir;
5761 int h_sampling_factor_n;
5762 int h_sampling_factor_m;
5763 int v_sampling_factor_n;
5764 int v_sampling_factor_m;
5766 s->hierachy_type= get_bits1(gb);
5767 ref_layer_id= get_bits(gb, 4);
5768 ref_layer_sampling_dir= get_bits1(gb);
5769 h_sampling_factor_n= get_bits(gb, 5);
5770 h_sampling_factor_m= get_bits(gb, 5);
5771 v_sampling_factor_n= get_bits(gb, 5);
5772 v_sampling_factor_m= get_bits(gb, 5);
5773 s->enhancement_type= get_bits1(gb);
5775 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5776 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5778 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5783 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5785 // bin shape stuff FIXME
5792 * decodes the user data stuff in the header.
5793 * allso inits divx/xvid/lavc_version/build
5795 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5799 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5802 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5803 if(show_bits(gb, 23) == 0) break;
5804 buf[i]= get_bits(gb, 8);
5808 /* divx detection */
5809 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5811 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5813 s->divx_version= ver;
5814 s->divx_build= build;
5815 s->divx_packed= e==3 && last=='p';
5818 /* ffmpeg detection */
5819 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5821 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5823 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5825 build= (ver<<16) + (ver2<<8) + ver3;
5828 if(strcmp(buf, "ffmpeg")==0){
5829 s->lavc_build= 4600;
5833 s->lavc_build= build;
5836 /* xvid detection */
5837 e=sscanf(buf, "XviD%d", &build);
5839 s->xvid_build= build;
5842 //printf("User Data: %s\n", buf);
5846 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5847 int time_incr, time_increment;
5849 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5850 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5851 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5855 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5856 if(s->partitioned_frame)
5857 s->decode_mb= mpeg4_decode_partitioned_mb;
5859 s->decode_mb= ff_mpeg4_decode_mb;
5862 while (get_bits1(gb) != 0)
5865 check_marker(gb, "before time_increment");
5867 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5868 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5870 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5871 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5874 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5877 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5878 else time_increment= get_bits(gb, s->time_increment_bits);
5880 // printf("%d %X\n", s->time_increment_bits, time_increment);
5881 //av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame);
5882 if(s->pict_type!=B_TYPE){
5883 s->last_time_base= s->time_base;
5884 s->time_base+= time_incr;
5885 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5886 if(s->workaround_bugs&FF_BUG_UMP4){
5887 if(s->time < s->last_non_b_time){
5888 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5890 s->time+= s->avctx->time_base.den;
5893 s->pp_time= s->time - s->last_non_b_time;
5894 s->last_non_b_time= s->time;
5896 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5897 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5898 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5899 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5900 return FRAME_SKIPPED;
5902 ff_mpeg4_init_direct_mv(s);
5904 if(s->t_frame==0) s->t_frame= s->pb_time;
5905 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5906 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5907 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5908 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5909 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5911 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %Ld last_base %d time %Ld pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time);
5913 if(s->avctx->time_base.num)
5914 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5916 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5917 if(s->avctx->debug&FF_DEBUG_PTS)
5918 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5920 check_marker(gb, "before vop_coded");
5923 if (get_bits1(gb) != 1){
5924 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5925 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5926 return FRAME_SKIPPED;
5928 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5929 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5930 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5931 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5932 /* rounding type for motion estimation */
5933 s->no_rounding = get_bits1(gb);
5937 //FIXME reduced res stuff
5939 if (s->shape != RECT_SHAPE) {
5940 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5941 int width, height, hor_spat_ref, ver_spat_ref;
5943 width = get_bits(gb, 13);
5944 skip_bits1(gb); /* marker */
5945 height = get_bits(gb, 13);
5946 skip_bits1(gb); /* marker */
5947 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5948 skip_bits1(gb); /* marker */
5949 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5951 skip_bits1(gb); /* change_CR_disable */
5953 if (get_bits1(gb) != 0) {
5954 skip_bits(gb, 8); /* constant_alpha_value */
5957 //FIXME complexity estimation stuff
5959 if (s->shape != BIN_ONLY_SHAPE) {
5960 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5961 if(!s->progressive_sequence){
5962 s->top_field_first= get_bits1(gb);
5963 s->alternate_scan= get_bits1(gb);
5965 s->alternate_scan= 0;
5968 if(s->alternate_scan){
5969 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5970 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5971 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5972 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5974 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5975 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5976 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5977 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5980 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5981 mpeg4_decode_sprite_trajectory(s, gb);
5982 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5983 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5986 if (s->shape != BIN_ONLY_SHAPE) {
5987 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5989 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5990 return -1; // makes no sense to continue, as there is nothing left from the image then
5993 if (s->pict_type != I_TYPE) {
5994 s->f_code = get_bits(gb, 3); /* fcode_for */
5996 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5997 return -1; // makes no sense to continue, as the MV decoding will break very quickly
6002 if (s->pict_type == B_TYPE) {
6003 s->b_code = get_bits(gb, 3);
6007 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6008 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\n",
6009 s->qscale, s->f_code, s->b_code,
6010 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6011 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6012 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6013 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
6016 if(!s->scalability){
6017 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
6018 skip_bits1(gb); // vop shape coding type
6021 if(s->enhancement_type){
6022 int load_backward_shape= get_bits1(gb);
6023 if(load_backward_shape){
6024 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6027 skip_bits(gb, 2); //ref_select_code
6030 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6031 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6032 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6033 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6037 s->picture_number++; // better than pic number==0 always ;)
6039 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6040 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6042 if(s->workaround_bugs&FF_BUG_EDGE){
6043 s->h_edge_pos= s->width;
6044 s->v_edge_pos= s->height;
6050 * decode mpeg4 headers
6051 * @return <0 if no VOP found (or a damaged one)
6052 * FRAME_SKIPPED if a not coded VOP is found
6053 * 0 if a VOP is found
6055 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6059 /* search next start code */
6062 if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6064 if(get_bits(gb, 8) == 0xF0)
6065 return decode_vop_header(s, gb);
6070 if(get_bits_count(gb) >= gb->size_in_bits){
6071 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6072 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6073 return FRAME_SKIPPED; //divx bug
6075 return -1; //end of stream
6078 /* use the bits after the test */
6079 v = get_bits(gb, 8);
6080 startcode = ((startcode << 8) | v) & 0xffffffff;
6082 if((startcode&0xFFFFFF00) != 0x100)
6083 continue; //no startcode
6085 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6086 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6087 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6088 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6089 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6090 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6091 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6092 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6093 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6094 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6095 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6096 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6097 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6098 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6099 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6100 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6101 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6102 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6103 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6104 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6105 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6106 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6107 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6108 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6109 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6110 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6111 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6112 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6113 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6114 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6117 if(startcode >= 0x120 && startcode <= 0x12F){
6118 if(decode_vol_header(s, gb) < 0)
6121 else if(startcode == USER_DATA_STARTCODE){
6122 decode_user_data(s, gb);
6124 else if(startcode == GOP_STARTCODE){
6125 mpeg4_decode_gop_header(s, gb);
6127 else if(startcode == VOP_STARTCODE){
6128 return decode_vop_header(s, gb);
6136 /* don't understand why they choose a different header ! */
6137 int intel_h263_decode_picture_header(MpegEncContext *s)
6141 /* picture header */
6142 if (get_bits_long(&s->gb, 22) != 0x20) {
6143 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6146 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6148 if (get_bits1(&s->gb) != 1) {
6149 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6150 return -1; /* marker */
6152 if (get_bits1(&s->gb) != 0) {
6153 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6154 return -1; /* h263 id */
6156 skip_bits1(&s->gb); /* split screen off */
6157 skip_bits1(&s->gb); /* camera off */
6158 skip_bits1(&s->gb); /* freeze picture release off */
6160 format = get_bits(&s->gb, 3);
6162 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6167 s->pict_type = I_TYPE + get_bits1(&s->gb);
6169 s->unrestricted_mv = get_bits1(&s->gb);
6170 s->h263_long_vectors = s->unrestricted_mv;
6172 if (get_bits1(&s->gb) != 0) {
6173 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6174 return -1; /* SAC: off */
6176 if (get_bits1(&s->gb) != 0) {
6178 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6179 // return -1; /* advanced prediction mode: off */
6181 if (get_bits1(&s->gb) != 0) {
6182 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6183 return -1; /* PB frame mode */
6186 /* skip unknown header garbage */
6187 skip_bits(&s->gb, 41);
6189 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6190 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6193 while (get_bits1(&s->gb) != 0) {
6194 skip_bits(&s->gb, 8);
6198 s->y_dc_scale_table=
6199 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6204 int flv_h263_decode_picture_header(MpegEncContext *s)
6206 int format, width, height;
6208 /* picture header */
6209 if (get_bits_long(&s->gb, 17) != 1) {
6210 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6213 format = get_bits(&s->gb, 5);
6214 if (format != 0 && format != 1) {
6215 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6218 s->h263_flv = format+1;
6219 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6220 format = get_bits(&s->gb, 3);
6223 width = get_bits(&s->gb, 8);
6224 height = get_bits(&s->gb, 8);
6227 width = get_bits(&s->gb, 16);
6228 height = get_bits(&s->gb, 16);
6254 if(avcodec_check_dimensions(s->avctx, width, height))
6259 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6260 s->dropable= s->pict_type > P_TYPE;
6262 s->pict_type = P_TYPE;
6264 skip_bits1(&s->gb); /* deblocking flag */
6265 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6269 s->unrestricted_mv = 1;
6270 s->h263_long_vectors = 0;
6273 while (get_bits1(&s->gb) != 0) {
6274 skip_bits(&s->gb, 8);
6278 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6279 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6280 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6283 s->y_dc_scale_table=
6284 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;