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 file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * ac prediction encoding, b-frame support, error resilience, optimizations,
25 * qpel decoding, gmc decoding, interlaced decoding,
26 * by Michael Niedermayer <michaelni@gmx.at>
40 #include "mpegvideo.h"
42 #include "mpeg4data.h"
47 #define INTRA_MCBPC_VLC_BITS 6
48 #define INTER_MCBPC_VLC_BITS 7
49 #define CBPY_VLC_BITS 6
52 #define SPRITE_TRAJ_VLC_BITS 6
53 #define MB_TYPE_B_VLC_BITS 4
54 #define TEX_VLC_BITS 9
55 #define H263_MBTYPE_B_VLC_BITS 6
56 #define CBPC_B_VLC_BITS 3
58 #ifdef CONFIG_ENCODERS
59 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
61 static void h263p_encode_umotion(MpegEncContext * s, int val);
62 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
63 int n, int dc, uint8_t *scan_table,
64 PutBitContext *dc_pb, PutBitContext *ac_pb);
65 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
69 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
70 static int h263p_decode_umotion(MpegEncContext * s, int pred);
71 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
73 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
74 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
75 int n, int coded, int intra, int rvlc);
76 #ifdef CONFIG_ENCODERS
77 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
78 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
79 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
80 #endif //CONFIG_ENCODERS
81 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
82 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
84 #ifdef CONFIG_ENCODERS
85 static uint8_t uni_DCtab_lum_len[512];
86 static uint8_t uni_DCtab_chrom_len[512];
87 static uint16_t uni_DCtab_lum_bits[512];
88 static uint16_t uni_DCtab_chrom_bits[512];
90 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
91 static uint8_t fcode_tab[MAX_MV*2+1];
92 static uint8_t umv_fcode_tab[MAX_MV*2+1];
94 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
95 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
96 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
97 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
98 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
99 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
101 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
102 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
115 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
116 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
121 int h263_get_picture_format(int width, int height)
125 if (width == 128 && height == 96)
127 else if (width == 176 && height == 144)
129 else if (width == 352 && height == 288)
131 else if (width == 704 && height == 576)
133 else if (width == 1408 && height == 1152)
140 #ifdef CONFIG_ENCODERS
142 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
145 if(aspect.num==0) aspect= (AVRational){1,1};
148 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
149 s->aspect_ratio_info=i;
154 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
157 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
161 align_put_bits(&s->pb);
163 put_bits(&s->pb, 17, 1);
164 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
165 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
166 s->avctx->time_base.den) & 0xff); /* TemporalReference */
167 if (s->width == 352 && s->height == 288)
169 else if (s->width == 176 && s->height == 144)
171 else if (s->width == 128 && s->height == 96)
173 else if (s->width == 320 && s->height == 240)
175 else if (s->width == 160 && s->height == 120)
177 else if (s->width <= 255 && s->height <= 255)
178 format = 0; /* use 1 byte width & height */
180 format = 1; /* use 2 bytes width & height */
181 put_bits(&s->pb, 3, format); /* PictureSize */
183 put_bits(&s->pb, 8, s->width);
184 put_bits(&s->pb, 8, s->height);
185 } else if (format == 1) {
186 put_bits(&s->pb, 16, s->width);
187 put_bits(&s->pb, 16, s->height);
189 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
190 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
191 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
192 put_bits(&s->pb, 1, 0); /* ExtraInformation */
196 s->c_dc_scale_table= ff_aic_dc_scale_table;
199 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
203 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
205 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
206 int best_clock_code=1;
208 int best_error= INT_MAX;
213 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
214 div= clip(1, div, 127);
215 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
216 if(error < best_error){
223 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
224 coded_frame_rate= 1800000;
225 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
227 align_put_bits(&s->pb);
229 /* Update the pointer to last GOB */
230 s->ptr_lastgob = pbBufPtr(&s->pb);
231 put_bits(&s->pb, 22, 0x20); /* PSC */
232 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
233 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
234 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
236 put_bits(&s->pb, 1, 1); /* marker */
237 put_bits(&s->pb, 1, 0); /* h263 id */
238 put_bits(&s->pb, 1, 0); /* split screen off */
239 put_bits(&s->pb, 1, 0); /* camera off */
240 put_bits(&s->pb, 1, 0); /* freeze picture release off */
242 format = h263_get_picture_format(s->width, s->height);
245 put_bits(&s->pb, 3, format);
246 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
247 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
248 of H.263v1 UMV implies to check the predicted MV after
249 calculation of the current MB to see if we're on the limits */
250 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
251 put_bits(&s->pb, 1, 0); /* SAC: off */
252 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
253 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
254 put_bits(&s->pb, 5, s->qscale);
255 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
259 /* H.263 Plus PTYPE */
261 put_bits(&s->pb, 3, 7);
262 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
264 put_bits(&s->pb,3,6); /* Custom Source Format */
266 put_bits(&s->pb, 3, format);
268 put_bits(&s->pb,1, s->custom_pcf);
269 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
270 put_bits(&s->pb,1,0); /* SAC: off */
271 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
272 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
273 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
274 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
275 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
276 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
277 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
278 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
279 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
280 put_bits(&s->pb,3,0); /* Reserved */
282 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
284 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
285 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
286 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
287 put_bits(&s->pb,2,0); /* Reserved */
288 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
290 /* This should be here if PLUSPTYPE */
291 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
294 /* Custom Picture Format (CPFMT) */
295 aspect_to_info(s, s->avctx->sample_aspect_ratio);
297 put_bits(&s->pb,4,s->aspect_ratio_info);
298 put_bits(&s->pb,9,(s->width >> 2) - 1);
299 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
300 put_bits(&s->pb,9,(s->height >> 2));
301 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
302 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
303 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
308 put_bits(&s->pb, 1, best_clock_code);
309 put_bits(&s->pb, 7, best_divisor);
311 put_bits(&s->pb, 2, (temp_ref>>8)&3);
314 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
316 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
317 //FIXME check actual requested range
318 put_bits(&s->pb,2,1); /* unlimited */
319 if(s->h263_slice_structured)
320 put_bits(&s->pb,2,0); /* no weird submodes */
322 put_bits(&s->pb, 5, s->qscale);
325 put_bits(&s->pb, 1, 0); /* no PEI */
327 if(s->h263_slice_structured){
328 put_bits(&s->pb, 1, 1);
330 assert(s->mb_x == 0 && s->mb_y == 0);
331 ff_h263_encode_mba(s);
333 put_bits(&s->pb, 1, 1);
338 s->c_dc_scale_table= ff_aic_dc_scale_table;
341 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
346 * Encodes a group of blocks header.
348 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
350 put_bits(&s->pb, 17, 1); /* GBSC */
352 if(s->h263_slice_structured){
353 put_bits(&s->pb, 1, 1);
355 ff_h263_encode_mba(s);
358 put_bits(&s->pb, 1, 1);
359 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
360 put_bits(&s->pb, 1, 1);
361 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
363 int gob_number= mb_line / s->gob_index;
365 put_bits(&s->pb, 5, gob_number); /* GN */
366 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
367 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
371 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
376 for(j=1; j<=block_last_index; j++){
377 const int index= scantable[j];
378 int level= block[index];
381 if((level&(~127)) == 0){
382 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
383 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
385 rate += s->ac_esc_length;
395 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
399 int8_t * const qscale_table= s->current_picture.qscale_table;
401 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
404 int16_t *ac_val, *ac_val1;
406 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
408 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
411 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
413 ac_val-= s->block_wrap[n]*16;
414 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
417 const int level= block[n][s->dsp.idct_permutation[i ]];
418 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
419 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
423 /* different qscale, we must rescale */
425 const int level= block[n][s->dsp.idct_permutation[i ]];
426 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
427 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
431 st[n]= s->intra_h_scantable.permutated;
433 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
434 /* left prediction */
436 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
439 const int level= block[n][s->dsp.idct_permutation[i<<3]];
440 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
442 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
445 /* different qscale, we must rescale */
447 const int level= block[n][s->dsp.idct_permutation[i<<3]];
448 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
450 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
453 st[n]= s->intra_v_scantable.permutated;
456 for(i=63; i>0; i--) //FIXME optimize
457 if(block[n][ st[n][i] ]) break;
458 s->block_last_index[n]= i;
460 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
466 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
469 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
472 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
474 st[n]= s->intra_scantable.permutated;
478 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
481 /* left prediction */
483 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
490 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
492 void ff_clean_h263_qscales(MpegEncContext *s){
494 int8_t * const qscale_table= s->current_picture.qscale_table;
496 for(i=1; i<s->mb_num; i++){
497 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
498 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
500 for(i=s->mb_num-2; i>=0; i--){
501 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
502 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
505 if(s->codec_id != CODEC_ID_H263P){
506 for(i=1; i<s->mb_num; i++){
507 int mb_xy= s->mb_index2xy[i];
509 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
510 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
511 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
518 * modify mb_type & qscale so that encoding is acually possible in mpeg4
520 void ff_clean_mpeg4_qscales(MpegEncContext *s){
522 int8_t * const qscale_table= s->current_picture.qscale_table;
524 ff_clean_h263_qscales(s);
526 if(s->pict_type== B_TYPE){
528 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
530 for(i=0; i<s->mb_num; i++){
531 int mb_xy= s->mb_index2xy[i];
532 odd += qscale_table[mb_xy]&1;
535 if(2*odd > s->mb_num) odd=1;
538 for(i=0; i<s->mb_num; i++){
539 int mb_xy= s->mb_index2xy[i];
540 if((qscale_table[mb_xy]&1) != odd)
541 qscale_table[mb_xy]++;
542 if(qscale_table[mb_xy] > 31)
543 qscale_table[mb_xy]= 31;
546 for(i=1; i<s->mb_num; i++){
547 int mb_xy= s->mb_index2xy[i];
548 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
549 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
550 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
556 #endif //CONFIG_ENCODERS
558 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
559 #define tab_bias (tab_size/2)
561 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
563 for(i=0; i<tab_size; i++){
564 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
565 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
569 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
570 int xy= s->block_index[i];
571 uint16_t time_pp= s->pp_time;
572 uint16_t time_pb= s->pb_time;
575 p_mx= s->next_picture.motion_val[0][xy][0];
576 if((unsigned)(p_mx + tab_bias) < tab_size){
577 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
578 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
579 : s->direct_scale_mv[1][p_mx + tab_bias];
581 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
582 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
583 : p_mx*(time_pb - time_pp)/time_pp;
585 p_my= s->next_picture.motion_val[0][xy][1];
586 if((unsigned)(p_my + tab_bias) < tab_size){
587 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
588 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
589 : s->direct_scale_mv[1][p_my + tab_bias];
591 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
592 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
593 : p_my*(time_pb - time_pp)/time_pp;
602 * @return the mb_type
604 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
605 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
606 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
607 uint16_t time_pp= s->pp_time;
608 uint16_t time_pb= s->pb_time;
611 //FIXME avoid divides
612 // try special case with shifts for 1 and 3 B-frames?
614 if(IS_8X8(colocated_mb_type)){
615 s->mv_type = MV_TYPE_8X8;
617 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
619 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
620 } else if(IS_INTERLACED(colocated_mb_type)){
621 s->mv_type = MV_TYPE_FIELD;
623 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
624 s->field_select[0][i]= field_select;
625 s->field_select[1][i]= i;
626 if(s->top_field_first){
627 time_pp= s->pp_field_time - field_select + i;
628 time_pb= s->pb_field_time - field_select + i;
630 time_pp= s->pp_field_time + field_select - i;
631 time_pb= s->pb_field_time + field_select - i;
633 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
634 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
635 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
636 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
637 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
638 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
640 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
642 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
643 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
644 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
645 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
646 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
647 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
648 s->mv_type= MV_TYPE_16X16;
650 s->mv_type= MV_TYPE_8X8;
651 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
655 void ff_h263_update_motion_val(MpegEncContext * s){
656 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
657 //FIXME a lot of that is only needed for !low_delay
658 const int wrap = s->b8_stride;
659 const int xy = s->block_index[0];
661 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
663 if(s->mv_type != MV_TYPE_8X8){
664 int motion_x, motion_y;
668 } else if (s->mv_type == MV_TYPE_16X16) {
669 motion_x = s->mv[0][0][0];
670 motion_y = s->mv[0][0][1];
671 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
673 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
674 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
675 motion_x = (motion_x>>1) | (motion_x&1);
677 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
678 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
680 s->current_picture.ref_index[0][xy ]=
681 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
682 s->current_picture.ref_index[0][xy + wrap ]=
683 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
686 /* no update if 8X8 because it has been done during parsing */
687 s->current_picture.motion_val[0][xy][0] = motion_x;
688 s->current_picture.motion_val[0][xy][1] = motion_y;
689 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
690 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
691 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
692 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
693 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
694 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
697 if(s->encoding){ //FIXME encoding MUST be cleaned up
698 if (s->mv_type == MV_TYPE_8X8)
699 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
701 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
703 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
707 #ifdef CONFIG_ENCODERS
709 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
710 int l, bit_size, code;
715 bit_size = f_code - 1;
716 /* modulo encoding */
717 l= INT_BIT - 6 - bit_size;
720 code = (val >> bit_size) + 1;
722 return mvtab[code][1] + 1 + bit_size;
726 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
727 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
728 skip_put_bits(&s->pb,
729 h263_get_motion_length(s, x, f_code)
730 +h263_get_motion_length(s, y, f_code));
732 ff_h263_encode_motion(s, x, f_code);
733 ff_h263_encode_motion(s, y, f_code);
737 static inline int get_p_cbp(MpegEncContext * s,
738 DCTELEM block[6][64],
739 int motion_x, int motion_y){
742 if(s->flags & CODEC_FLAG_CBP_RD){
743 int best_cbpy_score= INT_MAX;
744 int best_cbpc_score= INT_MAX;
745 int cbpc = (-1), cbpy= (-1);
746 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
747 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
750 int score= inter_MCBPC_bits[i + offset] * lambda;
751 if(i&1) score += s->coded_score[5];
752 if(i&2) score += s->coded_score[4];
754 if(score < best_cbpc_score){
755 best_cbpc_score= score;
761 int score= cbpy_tab[i ^ 0xF][1] * lambda;
762 if(i&1) score += s->coded_score[3];
763 if(i&2) score += s->coded_score[2];
764 if(i&4) score += s->coded_score[1];
765 if(i&8) score += s->coded_score[0];
767 if(score < best_cbpy_score){
768 best_cbpy_score= score;
773 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
774 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
778 for (i = 0; i < 6; i++) {
779 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
780 s->block_last_index[i]= -1;
781 memset(s->block[i], 0, sizeof(DCTELEM)*64);
786 for (i = 0; i < 6; i++) {
787 if (s->block_last_index[i] >= 0)
794 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
795 int motion_x, int motion_y, int mb_type){
798 if(s->flags & CODEC_FLAG_CBP_RD){
800 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
803 if(s->coded_score[i] < 0){
804 score += s->coded_score[i];
811 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
812 zero_score-= 4; //2*MV + mb_type + cbp bit
816 if(zero_score <= score){
821 for (i = 0; i < 6; i++) {
822 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
823 s->block_last_index[i]= -1;
824 memset(s->block[i], 0, sizeof(DCTELEM)*64);
828 for (i = 0; i < 6; i++) {
829 if (s->block_last_index[i] >= 0)
836 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
837 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
841 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
842 for (i = 0; i < 6; i++) {
843 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
846 /* encode each block */
847 for (i = 0; i < 6; i++) {
848 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
852 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
853 for (i = 0; i < 6; i++) {
854 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
857 /* encode each block */
858 for (i = 0; i < 6; i++) {
859 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
865 void mpeg4_encode_mb(MpegEncContext * s,
866 DCTELEM block[6][64],
867 int motion_x, int motion_y)
869 int cbpc, cbpy, pred_x, pred_y;
870 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
871 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
872 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
873 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
874 const int dquant_code[5]= {1,0,9,2,3};
876 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
880 if(s->pict_type==B_TYPE){
881 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
882 int mb_type= mb_type_table[s->mv_dir];
889 s->last_mv[i][1][1]= 0;
893 assert(s->dquant>=-2 && s->dquant<=2);
894 assert((s->dquant&1)==0);
897 /* nothing to do if this MB was skipped in the next P Frame */
898 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
904 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
905 s->qscale -= s->dquant;
911 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
913 if ((cbp | motion_x | motion_y | mb_type) ==0) {
914 /* direct MB with MV={0,0} */
915 assert(s->dquant==0);
917 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
919 if(interleaved_stats){
927 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
928 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
929 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
930 if(cbp) put_bits(&s->pb, 6, cbp);
934 put_bits(&s->pb, 2, (s->dquant>>2)+3);
936 put_bits(&s->pb, 1, 0);
938 s->qscale -= s->dquant;
940 if(!s->progressive_sequence){
942 put_bits(&s->pb, 1, s->interlaced_dct);
943 if(mb_type) // not direct mode
944 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
947 if(interleaved_stats){
948 s->misc_bits+= get_bits_diff(s);
952 assert(s->mv_dir & MV_DIRECT);
953 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
957 assert(mb_type > 0 && mb_type < 4);
958 if(s->mv_type != MV_TYPE_FIELD){
959 if(s->mv_dir & MV_DIR_FORWARD){
960 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
961 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
962 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
963 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
966 if(s->mv_dir & MV_DIR_BACKWARD){
967 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
968 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
969 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
970 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
974 if(s->mv_dir & MV_DIR_FORWARD){
975 put_bits(&s->pb, 1, s->field_select[0][0]);
976 put_bits(&s->pb, 1, s->field_select[0][1]);
978 if(s->mv_dir & MV_DIR_BACKWARD){
979 put_bits(&s->pb, 1, s->field_select[1][0]);
980 put_bits(&s->pb, 1, s->field_select[1][1]);
982 if(s->mv_dir & MV_DIR_FORWARD){
984 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
985 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
986 s->last_mv[0][i][0]= s->mv[0][i][0];
987 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
991 if(s->mv_dir & MV_DIR_BACKWARD){
993 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
994 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
995 s->last_mv[1][i][0]= s->mv[1][i][0];
996 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1003 if(interleaved_stats){
1004 s->mv_bits+= get_bits_diff(s);
1007 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1009 if(interleaved_stats){
1010 s->p_tex_bits+= get_bits_diff(s);
1013 }else{ /* s->pict_type==B_TYPE */
1014 cbp= get_p_cbp(s, block, motion_x, motion_y);
1016 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1017 /* check if the B frames can skip it too, as we must skip it if we skip here
1018 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1019 if(s->max_b_frames>0){
1026 if(x+16 > s->width) x= s->width-16;
1027 if(y+16 > s->height) y= s->height-16;
1029 offset= x + y*s->linesize;
1030 p_pic= s->new_picture.data[0] + offset;
1033 for(i=0; i<s->max_b_frames; i++){
1036 Picture *pic= s->reordered_input_picture[i+1];
1038 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1040 b_pic= pic->data[0] + offset;
1041 if(pic->type != FF_BUFFER_TYPE_SHARED)
1042 b_pic+= INPLACE_OFFSET;
1043 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1044 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1052 if(s->mb_skipped==1){
1053 /* skip macroblock */
1054 put_bits(&s->pb, 1, 1);
1056 if(interleaved_stats){
1066 put_bits(&s->pb, 1, 0); /* mb coded */
1070 if(s->mv_type==MV_TYPE_16X16){
1071 if(s->dquant) cbpc+= 8;
1073 inter_MCBPC_bits[cbpc],
1074 inter_MCBPC_code[cbpc]);
1076 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1078 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1080 if(!s->progressive_sequence){
1082 put_bits(pb2, 1, s->interlaced_dct);
1083 put_bits(pb2, 1, 0);
1086 if(interleaved_stats){
1087 s->misc_bits+= get_bits_diff(s);
1090 /* motion vectors: 16x16 mode */
1091 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1093 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1094 motion_y - pred_y, s->f_code);
1095 }else if(s->mv_type==MV_TYPE_FIELD){
1096 if(s->dquant) cbpc+= 8;
1098 inter_MCBPC_bits[cbpc],
1099 inter_MCBPC_code[cbpc]);
1101 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1103 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1105 assert(!s->progressive_sequence);
1107 put_bits(pb2, 1, s->interlaced_dct);
1108 put_bits(pb2, 1, 1);
1110 if(interleaved_stats){
1111 s->misc_bits+= get_bits_diff(s);
1114 /* motion vectors: 16x8 interlaced mode */
1115 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1118 put_bits(&s->pb, 1, s->field_select[0][0]);
1119 put_bits(&s->pb, 1, s->field_select[0][1]);
1121 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1122 s->mv[0][0][1] - pred_y, s->f_code);
1123 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1124 s->mv[0][1][1] - pred_y, s->f_code);
1126 assert(s->mv_type==MV_TYPE_8X8);
1128 inter_MCBPC_bits[cbpc+16],
1129 inter_MCBPC_code[cbpc+16]);
1130 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1132 if(!s->progressive_sequence){
1134 put_bits(pb2, 1, s->interlaced_dct);
1137 if(interleaved_stats){
1138 s->misc_bits+= get_bits_diff(s);
1142 /* motion vectors: 8x8 mode*/
1143 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1145 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1146 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1150 if(interleaved_stats){
1151 s->mv_bits+= get_bits_diff(s);
1154 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1156 if(interleaved_stats){
1157 s->p_tex_bits+= get_bits_diff(s);
1163 int dc_diff[6]; //dc values with the dc prediction subtracted
1164 int dir[6]; //prediction direction
1165 int zigzag_last_index[6];
1166 uint8_t *scan_table[6];
1170 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1173 if(s->flags & CODEC_FLAG_AC_PRED){
1174 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1176 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1179 scan_table[i]= s->intra_scantable.permutated;
1184 for (i = 0; i < 6; i++) {
1185 if (s->block_last_index[i] >= 1)
1186 cbp |= 1 << (5 - i);
1190 if (s->pict_type == I_TYPE) {
1191 if(s->dquant) cbpc+=4;
1193 intra_MCBPC_bits[cbpc],
1194 intra_MCBPC_code[cbpc]);
1196 if(s->dquant) cbpc+=8;
1197 put_bits(&s->pb, 1, 0); /* mb coded */
1199 inter_MCBPC_bits[cbpc + 4],
1200 inter_MCBPC_code[cbpc + 4]);
1202 put_bits(pb2, 1, s->ac_pred);
1204 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1206 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1208 if(!s->progressive_sequence){
1209 put_bits(dc_pb, 1, s->interlaced_dct);
1212 if(interleaved_stats){
1213 s->misc_bits+= get_bits_diff(s);
1216 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1218 if(interleaved_stats){
1219 s->i_tex_bits+= get_bits_diff(s);
1223 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1225 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1229 void h263_encode_mb(MpegEncContext * s,
1230 DCTELEM block[6][64],
1231 int motion_x, int motion_y)
1233 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1235 int16_t rec_intradc[6];
1237 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1238 const int dquant_code[5]= {1,0,9,2,3};
1240 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1243 cbp= get_p_cbp(s, block, motion_x, motion_y);
1245 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1246 /* skip macroblock */
1247 put_bits(&s->pb, 1, 1);
1248 if(interleaved_stats){
1256 put_bits(&s->pb, 1, 0); /* mb coded */
1260 if(s->alt_inter_vlc==0 || cbpc!=3)
1262 if(s->dquant) cbpc+= 8;
1263 if(s->mv_type==MV_TYPE_16X16){
1265 inter_MCBPC_bits[cbpc],
1266 inter_MCBPC_code[cbpc]);
1268 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1270 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1272 if(interleaved_stats){
1273 s->misc_bits+= get_bits_diff(s);
1276 /* motion vectors: 16x16 mode */
1277 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1280 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1281 motion_y - pred_y, 1);
1284 h263p_encode_umotion(s, motion_x - pred_x);
1285 h263p_encode_umotion(s, motion_y - pred_y);
1286 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1287 /* To prevent Start Code emulation */
1288 put_bits(&s->pb,1,1);
1292 inter_MCBPC_bits[cbpc+16],
1293 inter_MCBPC_code[cbpc+16]);
1294 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1296 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1298 if(interleaved_stats){
1299 s->misc_bits+= get_bits_diff(s);
1303 /* motion vectors: 8x8 mode*/
1304 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1306 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1307 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1309 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1310 motion_y - pred_y, 1);
1313 h263p_encode_umotion(s, motion_x - pred_x);
1314 h263p_encode_umotion(s, motion_y - pred_y);
1315 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1316 /* To prevent Start Code emulation */
1317 put_bits(&s->pb,1,1);
1322 if(interleaved_stats){
1323 s->mv_bits+= get_bits_diff(s);
1326 assert(s->mb_intra);
1331 for(i=0; i<6; i++) {
1332 int16_t level = block[i][0];
1335 if(i<4) scale= s->y_dc_scale;
1336 else scale= s->c_dc_scale;
1338 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1342 level = (level + (scale>>1))/scale;
1344 level = (level - (scale>>1))/scale;
1346 /* AIC can change CBP */
1347 if (level == 0 && s->block_last_index[i] == 0)
1348 s->block_last_index[i] = -1;
1350 if(!s->modified_quant){
1353 else if (level > 127)
1357 block[i][0] = level;
1358 /* Reconstruction */
1359 rec_intradc[i] = scale*level + pred_dc;
1361 rec_intradc[i] |= 1;
1362 //if ((rec_intradc[i] % 2) == 0)
1363 // rec_intradc[i]++;
1365 if (rec_intradc[i] < 0)
1367 else if (rec_intradc[i] > 2047)
1368 rec_intradc[i] = 2047;
1370 /* Update AC/DC tables */
1371 *dc_ptr[i] = rec_intradc[i];
1372 if (s->block_last_index[i] >= 0)
1373 cbp |= 1 << (5 - i);
1376 for(i=0; i<6; i++) {
1378 if (s->block_last_index[i] >= 1)
1379 cbp |= 1 << (5 - i);
1384 if (s->pict_type == I_TYPE) {
1385 if(s->dquant) cbpc+=4;
1387 intra_MCBPC_bits[cbpc],
1388 intra_MCBPC_code[cbpc]);
1390 if(s->dquant) cbpc+=8;
1391 put_bits(&s->pb, 1, 0); /* mb coded */
1393 inter_MCBPC_bits[cbpc + 4],
1394 inter_MCBPC_code[cbpc + 4]);
1397 /* XXX: currently, we do not try to use ac prediction */
1398 put_bits(&s->pb, 1, 0); /* no AC prediction */
1401 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1403 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1405 if(interleaved_stats){
1406 s->misc_bits+= get_bits_diff(s);
1410 for(i=0; i<6; i++) {
1411 /* encode each block */
1412 h263_encode_block(s, block[i], i);
1414 /* Update INTRADC for decoding */
1415 if (s->h263_aic && s->mb_intra) {
1416 block[i][0] = rec_intradc[i];
1421 if(interleaved_stats){
1423 s->p_tex_bits+= get_bits_diff(s);
1426 s->i_tex_bits+= get_bits_diff(s);
1433 void ff_h263_loop_filter(MpegEncContext * s){
1435 const int linesize = s->linesize;
1436 const int uvlinesize= s->uvlinesize;
1437 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1438 uint8_t *dest_y = s->dest[0];
1439 uint8_t *dest_cb= s->dest[1];
1440 uint8_t *dest_cr= s->dest[2];
1442 // if(s->pict_type==B_TYPE && !s->readable) return;
1448 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1450 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1451 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1456 int qp_dt, qp_t, qp_tc;
1458 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1461 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1469 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1470 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1471 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1473 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1474 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1478 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1481 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1484 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1487 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1488 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1489 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1490 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1496 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1497 if(s->mb_y + 1 == s->mb_height)
1498 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1503 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1506 qp_lc= s->current_picture.qscale_table[xy-1];
1509 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1510 if(s->mb_y + 1 == s->mb_height){
1511 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1512 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1513 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1514 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1520 #ifdef CONFIG_ENCODERS
1521 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1523 int x, y, wrap, a, c, pred_dc, scale;
1526 /* find prediction */
1528 x = 2 * s->mb_x + (n & 1);
1529 y = 2 * s->mb_y + ((n & 2) >> 1);
1530 wrap = s->b8_stride;
1531 dc_val = s->dc_val[0];
1532 scale = s->y_dc_scale;
1536 wrap = s->mb_stride;
1537 dc_val = s->dc_val[n - 4 + 1];
1538 scale = s->c_dc_scale;
1543 a = dc_val[(x - 1) + (y) * wrap];
1544 c = dc_val[(x) + (y - 1) * wrap];
1546 /* No prediction outside GOB boundary */
1547 if(s->first_slice_line && n!=3){
1549 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1552 /* just DC prediction */
1553 if (a != 1024 && c != 1024)
1554 pred_dc = (a + c) >> 1;
1560 /* we assume pred is positive */
1561 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1562 *dc_val_ptr = &dc_val[x + y * wrap];
1565 #endif /* CONFIG_ENCODERS */
1567 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1569 int x, y, wrap, a, c, pred_dc, scale, i;
1570 int16_t *dc_val, *ac_val, *ac_val1;
1572 /* find prediction */
1574 x = 2 * s->mb_x + (n & 1);
1575 y = 2 * s->mb_y + (n>> 1);
1576 wrap = s->b8_stride;
1577 dc_val = s->dc_val[0];
1578 ac_val = s->ac_val[0][0];
1579 scale = s->y_dc_scale;
1583 wrap = s->mb_stride;
1584 dc_val = s->dc_val[n - 4 + 1];
1585 ac_val = s->ac_val[n - 4 + 1][0];
1586 scale = s->c_dc_scale;
1589 ac_val += ((y) * wrap + (x)) * 16;
1595 a = dc_val[(x - 1) + (y) * wrap];
1596 c = dc_val[(x) + (y - 1) * wrap];
1598 /* No prediction outside GOB boundary */
1599 if(s->first_slice_line && n!=3){
1601 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1606 if (s->h263_aic_dir) {
1607 /* left prediction */
1611 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1616 /* top prediction */
1618 ac_val -= 16 * wrap;
1620 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1626 /* just DC prediction */
1627 if (a != 1024 && c != 1024)
1628 pred_dc = (a + c) >> 1;
1635 /* we assume pred is positive */
1636 block[0]=block[0]*scale + pred_dc;
1643 /* Update AC/DC tables */
1644 dc_val[(x) + (y) * wrap] = block[0];
1648 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1651 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1654 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1658 int16_t *A, *B, *C, (*mot_val)[2];
1659 static const int off[4]= {2, 1, 1, -1};
1661 wrap = s->b8_stride;
1662 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1665 /* special case for first (slice) line */
1666 if (s->first_slice_line && block<3) {
1667 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1668 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1669 if(block==0){ //most common case
1670 if(s->mb_x == s->resync_mb_x){ //rare
1672 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1673 C = mot_val[off[block] - wrap];
1678 *px = mid_pred(A[0], 0, C[0]);
1679 *py = mid_pred(A[1], 0, C[1]);
1686 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1687 C = mot_val[off[block] - wrap];
1688 *px = mid_pred(A[0], 0, C[0]);
1689 *py = mid_pred(A[1], 0, C[1]);
1694 }else{ /* block==2*/
1695 B = mot_val[ - wrap];
1696 C = mot_val[off[block] - wrap];
1697 if(s->mb_x == s->resync_mb_x) //rare
1700 *px = mid_pred(A[0], B[0], C[0]);
1701 *py = mid_pred(A[1], B[1], C[1]);
1704 B = mot_val[ - wrap];
1705 C = mot_val[off[block] - wrap];
1706 *px = mid_pred(A[0], B[0], C[0]);
1707 *py = mid_pred(A[1], B[1], C[1]);
1712 #ifdef CONFIG_ENCODERS
1713 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1715 int range, l, bit_size, sign, code, bits;
1720 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1722 bit_size = f_code - 1;
1723 range = 1 << bit_size;
1724 /* modulo encoding */
1725 l= INT_BIT - 6 - bit_size;
1728 val= (val^sign)-sign;
1732 code = (val >> bit_size) + 1;
1733 bits = val & (range - 1);
1735 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1737 put_bits(&s->pb, bit_size, bits);
1742 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1743 static void h263p_encode_umotion(MpegEncContext * s, int val)
1753 put_bits(&s->pb, 1, 1);
1755 put_bits(&s->pb, 3, 0);
1757 put_bits(&s->pb, 3, 2);
1760 sval = ((val < 0) ? (short)(-val):(short)val);
1763 while (temp_val != 0) {
1764 temp_val = temp_val >> 1;
1770 tcode = (sval & (1 << (i-1))) >> (i-1);
1771 tcode = (tcode << 1) | 1;
1772 code = (code << 2) | tcode;
1775 code = ((code << 1) | (val < 0)) << 1;
1776 put_bits(&s->pb, (2*n_bits)+1, code);
1777 //printf("\nVal = %d\tCode = %d", sval, code);
1781 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1786 if(mv_penalty==NULL)
1787 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1789 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1790 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1793 if(mv==0) len= mvtab[0][1];
1795 int val, bit_size, range, code;
1797 bit_size = f_code - 1;
1798 range = 1 << bit_size;
1804 code = (val >> bit_size) + 1;
1806 len= mvtab[code][1] + 1 + bit_size;
1808 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1812 mv_penalty[f_code][mv+MAX_MV]= len;
1816 for(f_code=MAX_FCODE; f_code>0; f_code--){
1817 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1818 fcode_tab[mv+MAX_MV]= f_code;
1822 for(mv=0; mv<MAX_MV*2+1; mv++){
1823 umv_fcode_tab[mv]= 1;
1828 #ifdef CONFIG_ENCODERS
1830 static void init_uni_dc_tab(void)
1832 int level, uni_code, uni_len;
1834 for(level=-256; level<256; level++){
1836 /* find number of bits */
1845 l= (-level) ^ ((1 << size) - 1);
1850 uni_code= DCtab_lum[size][0];
1851 uni_len = DCtab_lum[size][1];
1854 uni_code<<=size; uni_code|=l;
1857 uni_code<<=1; uni_code|=1;
1861 uni_DCtab_lum_bits[level+256]= uni_code;
1862 uni_DCtab_lum_len [level+256]= uni_len;
1865 uni_code= DCtab_chrom[size][0];
1866 uni_len = DCtab_chrom[size][1];
1869 uni_code<<=size; uni_code|=l;
1872 uni_code<<=1; uni_code|=1;
1876 uni_DCtab_chrom_bits[level+256]= uni_code;
1877 uni_DCtab_chrom_len [level+256]= uni_len;
1882 #endif //CONFIG_ENCODERS
1884 #ifdef CONFIG_ENCODERS
1885 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1886 int slevel, run, last;
1888 assert(MAX_LEVEL >= 64);
1889 assert(MAX_RUN >= 63);
1891 for(slevel=-64; slevel<64; slevel++){
1892 if(slevel==0) continue;
1893 for(run=0; run<64; run++){
1894 for(last=0; last<=1; last++){
1895 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1896 int level= slevel < 0 ? -slevel : slevel;
1897 int sign= slevel < 0 ? 1 : 0;
1898 int bits, len, code;
1901 len_tab[index]= 100;
1904 code= get_rl_index(rl, last, run, level);
1905 bits= rl->table_vlc[code][0];
1906 len= rl->table_vlc[code][1];
1907 bits=bits*2+sign; len++;
1909 if(code!=rl->n && len < len_tab[index]){
1910 bits_tab[index]= bits;
1911 len_tab [index]= len;
1915 bits= rl->table_vlc[rl->n][0];
1916 len= rl->table_vlc[rl->n][1];
1917 bits=bits*2; len++; //esc1
1918 level1= level - rl->max_level[last][run];
1920 code= get_rl_index(rl, last, run, level1);
1921 bits<<= rl->table_vlc[code][1];
1922 len += rl->table_vlc[code][1];
1923 bits += rl->table_vlc[code][0];
1924 bits=bits*2+sign; len++;
1926 if(code!=rl->n && len < len_tab[index]){
1927 bits_tab[index]= bits;
1928 len_tab [index]= len;
1934 bits= rl->table_vlc[rl->n][0];
1935 len= rl->table_vlc[rl->n][1];
1936 bits=bits*4+2; len+=2; //esc2
1937 run1 = run - rl->max_run[last][level] - 1;
1939 code= get_rl_index(rl, last, run1, level);
1940 bits<<= rl->table_vlc[code][1];
1941 len += rl->table_vlc[code][1];
1942 bits += rl->table_vlc[code][0];
1943 bits=bits*2+sign; len++;
1945 if(code!=rl->n && len < len_tab[index]){
1946 bits_tab[index]= bits;
1947 len_tab [index]= len;
1952 bits= rl->table_vlc[rl->n][0];
1953 len = rl->table_vlc[rl->n][1];
1954 bits=bits*4+3; len+=2; //esc3
1955 bits=bits*2+last; len++;
1956 bits=bits*64+run; len+=6;
1957 bits=bits*2+1; len++; //marker
1958 bits=bits*4096+(slevel&0xfff); len+=12;
1959 bits=bits*2+1; len++; //marker
1961 if(len < len_tab[index]){
1962 bits_tab[index]= bits;
1963 len_tab [index]= len;
1970 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1971 int slevel, run, last;
1973 assert(MAX_LEVEL >= 64);
1974 assert(MAX_RUN >= 63);
1976 for(slevel=-64; slevel<64; slevel++){
1977 if(slevel==0) continue;
1978 for(run=0; run<64; run++){
1979 for(last=0; last<=1; last++){
1980 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1981 int level= slevel < 0 ? -slevel : slevel;
1982 int sign= slevel < 0 ? 1 : 0;
1983 int bits, len, code;
1985 len_tab[index]= 100;
1988 code= get_rl_index(rl, last, run, level);
1989 bits= rl->table_vlc[code][0];
1990 len= rl->table_vlc[code][1];
1991 bits=bits*2+sign; len++;
1993 if(code!=rl->n && len < len_tab[index]){
1994 if(bits_tab) bits_tab[index]= bits;
1995 len_tab [index]= len;
1998 bits= rl->table_vlc[rl->n][0];
1999 len = rl->table_vlc[rl->n][1];
2000 bits=bits*2+last; len++;
2001 bits=bits*64+run; len+=6;
2002 bits=bits*256+(level&0xff); len+=8;
2004 if(len < len_tab[index]){
2005 if(bits_tab) bits_tab[index]= bits;
2006 len_tab [index]= len;
2013 void h263_encode_init(MpegEncContext *s)
2015 static int done = 0;
2022 init_rl(&rl_inter, 1);
2023 init_rl(&rl_intra, 1);
2024 init_rl(&rl_intra_aic, 1);
2026 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2027 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2029 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2030 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2032 init_mv_penalty_and_fcode(s);
2034 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2036 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2037 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2039 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2040 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2042 s->ac_esc_length= 7+1+6+8;
2044 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2045 switch(s->codec_id){
2046 case CODEC_ID_MPEG4:
2047 s->fcode_tab= fcode_tab;
2048 s->min_qcoeff= -2048;
2049 s->max_qcoeff= 2047;
2050 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2051 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2052 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2053 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2054 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2055 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2056 s->ac_esc_length= 7+2+1+6+1+12+1;
2057 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2058 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2060 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2062 s->avctx->extradata= av_malloc(1024);
2063 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2065 if(!(s->workaround_bugs & FF_BUG_MS))
2066 mpeg4_encode_visual_object_header(s);
2067 mpeg4_encode_vol_header(s, 0, 0);
2069 // ff_mpeg4_stuffing(&s->pb); ?
2070 flush_put_bits(&s->pb);
2071 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2075 case CODEC_ID_H263P:
2077 s->fcode_tab= umv_fcode_tab;
2078 if(s->modified_quant){
2079 s->min_qcoeff= -2047;
2080 s->max_qcoeff= 2047;
2082 s->min_qcoeff= -127;
2086 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2088 if (s->h263_flv > 1) {
2089 s->min_qcoeff= -1023;
2090 s->max_qcoeff= 1023;
2092 s->min_qcoeff= -127;
2095 s->y_dc_scale_table=
2096 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2098 default: //nothing needed - default table already set in mpegvideo.c
2099 s->min_qcoeff= -127;
2101 s->y_dc_scale_table=
2102 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2107 * encodes a 8x8 block.
2108 * @param block the 8x8 block
2109 * @param n block index (0-3 are luma, 4-5 are chroma)
2111 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2113 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2117 if (s->mb_intra && !s->h263_aic) {
2120 /* 255 cannot be represented, so we clamp */
2125 /* 0 cannot be represented also */
2126 else if (level < 1) {
2130 if (level == 128) //FIXME check rv10
2131 put_bits(&s->pb, 8, 0xff);
2133 put_bits(&s->pb, 8, level);
2137 if (s->h263_aic && s->mb_intra)
2140 if(s->alt_inter_vlc && !s->mb_intra){
2142 int inter_vlc_bits=0;
2146 last_index = s->block_last_index[n];
2147 last_non_zero = i - 1;
2148 for (; i <= last_index; i++) {
2149 j = s->intra_scantable.permutated[i];
2152 run = i - last_non_zero - 1;
2153 last = (i == last_index);
2155 if(level<0) level= -level;
2157 code = get_rl_index(rl, last, run, level);
2158 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2159 inter_vlc_bits += rl->table_vlc[code][1]+1;
2160 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2162 if (code == rl->n) {
2163 inter_vlc_bits += 1+6+8-1;
2165 if (aic_code == rl_intra_aic.n) {
2166 aic_vlc_bits += 1+6+8-1;
2167 wrong_pos += run + 1;
2169 wrong_pos += wrong_run[aic_code];
2174 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2180 last_index = s->block_last_index[n];
2181 last_non_zero = i - 1;
2182 for (; i <= last_index; i++) {
2183 j = s->intra_scantable.permutated[i];
2186 run = i - last_non_zero - 1;
2187 last = (i == last_index);
2194 code = get_rl_index(rl, last, run, level);
2195 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2196 if (code == rl->n) {
2197 if(s->h263_flv <= 1){
2198 put_bits(&s->pb, 1, last);
2199 put_bits(&s->pb, 6, run);
2201 assert(slevel != 0);
2204 put_bits(&s->pb, 8, slevel & 0xff);
2206 put_bits(&s->pb, 8, 128);
2207 put_bits(&s->pb, 5, slevel & 0x1f);
2208 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2211 if(level < 64) { // 7-bit level
2212 put_bits(&s->pb, 1, 0);
2213 put_bits(&s->pb, 1, last);
2214 put_bits(&s->pb, 6, run);
2216 put_bits(&s->pb, 7, slevel & 0x7f);
2219 put_bits(&s->pb, 1, 1);
2220 put_bits(&s->pb, 1, last);
2221 put_bits(&s->pb, 6, run);
2223 put_bits(&s->pb, 11, slevel & 0x7ff);
2227 put_bits(&s->pb, 1, sign);
2235 #ifdef CONFIG_ENCODERS
2237 /***************************************************/
2239 * add mpeg4 stuffing bits (01...1)
2241 void ff_mpeg4_stuffing(PutBitContext * pbc)
2244 put_bits(pbc, 1, 0);
2245 length= (-put_bits_count(pbc))&7;
2246 if(length) put_bits(pbc, length, (1<<length)-1);
2249 /* must be called before writing the header */
2250 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2251 int time_div, time_mod;
2253 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2254 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2256 time_div= s->time/s->avctx->time_base.den;
2257 time_mod= s->time%s->avctx->time_base.den;
2259 if(s->pict_type==B_TYPE){
2260 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2261 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2262 ff_mpeg4_init_direct_mv(s);
2264 s->last_time_base= s->time_base;
2265 s->time_base= time_div;
2266 s->pp_time= s->time - s->last_non_b_time;
2267 s->last_non_b_time= s->time;
2268 assert(picture_number==0 || s->pp_time > 0);
2272 static void mpeg4_encode_gop_header(MpegEncContext * s){
2273 int hours, minutes, seconds;
2276 put_bits(&s->pb, 16, 0);
2277 put_bits(&s->pb, 16, GOP_STARTCODE);
2279 time= s->current_picture_ptr->pts;
2280 if(s->reordered_input_picture[1])
2281 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2282 time= time*s->avctx->time_base.num;
2284 seconds= time/s->avctx->time_base.den;
2285 minutes= seconds/60; seconds %= 60;
2286 hours= minutes/60; minutes %= 60;
2289 put_bits(&s->pb, 5, hours);
2290 put_bits(&s->pb, 6, minutes);
2291 put_bits(&s->pb, 1, 1);
2292 put_bits(&s->pb, 6, seconds);
2294 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2295 put_bits(&s->pb, 1, 0); //broken link == NO
2297 s->last_time_base= time / s->avctx->time_base.den;
2299 ff_mpeg4_stuffing(&s->pb);
2302 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2303 int profile_and_level_indication;
2306 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2307 profile_and_level_indication = s->avctx->profile << 4;
2308 }else if(s->max_b_frames || s->quarter_sample){
2309 profile_and_level_indication= 0xF0; // adv simple
2311 profile_and_level_indication= 0x00; // simple
2314 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2315 profile_and_level_indication |= s->avctx->level;
2317 profile_and_level_indication |= 1; //level 1
2320 if(profile_and_level_indication>>4 == 0xF){
2328 put_bits(&s->pb, 16, 0);
2329 put_bits(&s->pb, 16, VOS_STARTCODE);
2331 put_bits(&s->pb, 8, profile_and_level_indication);
2333 put_bits(&s->pb, 16, 0);
2334 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2336 put_bits(&s->pb, 1, 1);
2337 put_bits(&s->pb, 4, vo_ver_id);
2338 put_bits(&s->pb, 3, 1); //priority
2340 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2342 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2344 ff_mpeg4_stuffing(&s->pb);
2347 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2351 if(s->max_b_frames || s->quarter_sample){
2353 s->vo_type= ADV_SIMPLE_VO_TYPE;
2356 s->vo_type= SIMPLE_VO_TYPE;
2359 put_bits(&s->pb, 16, 0);
2360 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2361 put_bits(&s->pb, 16, 0);
2362 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2364 put_bits(&s->pb, 1, 0); /* random access vol */
2365 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2366 if(s->workaround_bugs & FF_BUG_MS) {
2367 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2369 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2370 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2371 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2374 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2376 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2377 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2378 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2379 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2382 if(s->workaround_bugs & FF_BUG_MS) { //
2383 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2385 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2386 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2387 put_bits(&s->pb, 1, s->low_delay);
2388 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2391 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2392 put_bits(&s->pb, 1, 1); /* marker bit */
2394 put_bits(&s->pb, 16, s->avctx->time_base.den);
2395 if (s->time_increment_bits < 1)
2396 s->time_increment_bits = 1;
2397 put_bits(&s->pb, 1, 1); /* marker bit */
2398 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2399 put_bits(&s->pb, 1, 1); /* marker bit */
2400 put_bits(&s->pb, 13, s->width); /* vol width */
2401 put_bits(&s->pb, 1, 1); /* marker bit */
2402 put_bits(&s->pb, 13, s->height); /* vol height */
2403 put_bits(&s->pb, 1, 1); /* marker bit */
2404 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2405 put_bits(&s->pb, 1, 1); /* obmc disable */
2406 if (vo_ver_id == 1) {
2407 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2409 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2412 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2413 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2416 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2417 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2421 put_bits(&s->pb, 1, s->quarter_sample);
2422 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2423 s->resync_marker= s->rtp_mode;
2424 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2425 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2426 if(s->data_partitioning){
2427 put_bits(&s->pb, 1, 0); /* no rvlc */
2430 if (vo_ver_id != 1){
2431 put_bits(&s->pb, 1, 0); /* newpred */
2432 put_bits(&s->pb, 1, 0); /* reduced res vop */
2434 put_bits(&s->pb, 1, 0); /* scalability */
2436 ff_mpeg4_stuffing(&s->pb);
2439 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2440 put_bits(&s->pb, 16, 0);
2441 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2442 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2446 /* write mpeg4 VOP header */
2447 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2450 int time_div, time_mod;
2452 if(s->pict_type==I_TYPE){
2453 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2454 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2455 mpeg4_encode_visual_object_header(s);
2456 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2457 mpeg4_encode_vol_header(s, 0, 0);
2459 if(!(s->workaround_bugs & FF_BUG_MS))
2460 mpeg4_encode_gop_header(s);
2463 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2465 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2467 put_bits(&s->pb, 16, 0); /* vop header */
2468 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2469 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2472 time_div= s->time/s->avctx->time_base.den;
2473 time_mod= s->time%s->avctx->time_base.den;
2474 time_incr= time_div - s->last_time_base;
2475 assert(time_incr >= 0);
2477 put_bits(&s->pb, 1, 1);
2479 put_bits(&s->pb, 1, 0);
2481 put_bits(&s->pb, 1, 1); /* marker */
2482 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2483 put_bits(&s->pb, 1, 1); /* marker */
2484 put_bits(&s->pb, 1, 1); /* vop coded */
2485 if ( s->pict_type == P_TYPE
2486 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2487 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2489 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2490 if(!s->progressive_sequence){
2491 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2492 put_bits(&s->pb, 1, s->alternate_scan);
2494 //FIXME sprite stuff
2496 put_bits(&s->pb, 5, s->qscale);
2498 if (s->pict_type != I_TYPE)
2499 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2500 if (s->pict_type == B_TYPE)
2501 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2502 // printf("****frame %d\n", picture_number);
2505 #endif //CONFIG_ENCODERS
2508 * set qscale and update qscale dependant variables.
2510 void ff_set_qscale(MpegEncContext * s, int qscale)
2514 else if (qscale > 31)
2518 s->chroma_qscale= s->chroma_qscale_table[qscale];
2520 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2521 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2526 * encoding quantized level -> quantized diff
2527 * decoding quantized diff -> quantized level
2528 * @param n block index (0-3 are luma, 4-5 are chroma)
2529 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2531 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2533 int a, b, c, wrap, pred, scale, ret;
2536 /* find prediction */
2538 scale = s->y_dc_scale;
2540 scale = s->c_dc_scale;
2545 wrap= s->block_wrap[n];
2546 dc_val = s->dc_val[0] + s->block_index[n];
2552 b = dc_val[ - 1 - wrap];
2553 c = dc_val[ - wrap];
2555 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2556 if(s->first_slice_line && n!=3){
2558 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2560 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2561 if(n==0 || n==4 || n==5)
2565 if (abs(a - b) < abs(b - c)) {
2567 *dir_ptr = 1; /* top */
2570 *dir_ptr = 0; /* left */
2572 /* we assume pred is positive */
2573 pred = FASTDIV((pred + (scale >> 1)), scale);
2580 if(s->error_resilience>=3){
2582 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2585 if(level*scale > 2048 + scale){
2586 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2595 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2605 * @param n block index (0-3 are luma, 4-5 are chroma)
2606 * @param dir the ac prediction direction
2608 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2612 int16_t *ac_val, *ac_val1;
2613 int8_t * const qscale_table= s->current_picture.qscale_table;
2615 /* find prediction */
2616 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2620 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2621 /* left prediction */
2624 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2627 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2630 /* different qscale, we must rescale */
2632 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2636 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2637 /* top prediction */
2638 ac_val -= 16 * s->block_wrap[n];
2640 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2643 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2646 /* different qscale, we must rescale */
2648 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2655 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2659 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2663 #ifdef CONFIG_ENCODERS
2666 * encodes the dc value.
2667 * @param n block index (0-3 are luma, 4-5 are chroma)
2669 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2672 // if(level<-255 || level>255) printf("dc overflow\n");
2676 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2679 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2683 /* find number of bits */
2693 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2696 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2699 /* encode remaining bits */
2702 level = (-level) ^ ((1 << size) - 1);
2703 put_bits(&s->pb, size, level);
2705 put_bits(&s->pb, 1, 1);
2710 static inline int mpeg4_get_dc_length(int level, int n){
2712 return uni_DCtab_lum_len[level + 256];
2714 return uni_DCtab_chrom_len[level + 256];
2719 * encodes a 8x8 block
2720 * @param n block index (0-3 are luma, 4-5 are chroma)
2722 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2723 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2725 int i, last_non_zero;
2726 #if 0 //variables for the outcommented version
2727 int code, sign, last;
2732 const int last_index = s->block_last_index[n];
2734 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2735 /* mpeg4 based DC predictor */
2736 mpeg4_encode_dc(dc_pb, intra_dc, n);
2737 if(last_index<1) return;
2740 bits_tab= uni_mpeg4_intra_rl_bits;
2741 len_tab = uni_mpeg4_intra_rl_len;
2743 if(last_index<0) return;
2746 bits_tab= uni_mpeg4_inter_rl_bits;
2747 len_tab = uni_mpeg4_inter_rl_len;
2751 last_non_zero = i - 1;
2753 for (; i < last_index; i++) {
2754 int level = block[ scan_table[i] ];
2756 int run = i - last_non_zero - 1;
2758 if((level&(~127)) == 0){
2759 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2760 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2762 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);
2767 /*if(i<=last_index)*/{
2768 int level = block[ scan_table[i] ];
2769 int run = i - last_non_zero - 1;
2771 if((level&(~127)) == 0){
2772 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2773 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2775 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);
2779 for (; i <= last_index; i++) {
2780 const int slevel = block[ scan_table[i] ];
2783 int run = i - last_non_zero - 1;
2784 last = (i == last_index);
2791 code = get_rl_index(rl, last, run, level);
2792 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2793 if (code == rl->n) {
2795 level1 = level - rl->max_level[last][run];
2798 code = get_rl_index(rl, last, run, level1);
2799 if (code == rl->n) {
2801 put_bits(ac_pb, 1, 1);
2802 if (level > MAX_LEVEL)
2804 run1 = run - rl->max_run[last][level] - 1;
2807 code = get_rl_index(rl, last, run1, level);
2808 if (code == rl->n) {
2811 put_bits(ac_pb, 1, 1);
2812 put_bits(ac_pb, 1, last);
2813 put_bits(ac_pb, 6, run);
2814 put_bits(ac_pb, 1, 1);
2815 put_bits(ac_pb, 12, slevel & 0xfff);
2816 put_bits(ac_pb, 1, 1);
2819 put_bits(ac_pb, 1, 0);
2820 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2821 put_bits(ac_pb, 1, sign);
2825 put_bits(ac_pb, 1, 0);
2826 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2827 put_bits(ac_pb, 1, sign);
2830 put_bits(ac_pb, 1, sign);
2838 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2839 uint8_t *scan_table)
2841 int i, last_non_zero;
2844 const int last_index = s->block_last_index[n];
2847 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2848 /* mpeg4 based DC predictor */
2849 len += mpeg4_get_dc_length(intra_dc, n);
2850 if(last_index<1) return len;
2853 len_tab = uni_mpeg4_intra_rl_len;
2855 if(last_index<0) return 0;
2858 len_tab = uni_mpeg4_inter_rl_len;
2862 last_non_zero = i - 1;
2863 for (; i < last_index; i++) {
2864 int level = block[ scan_table[i] ];
2866 int run = i - last_non_zero - 1;
2868 if((level&(~127)) == 0){
2869 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2870 len += len_tab[index];
2872 len += 7+2+1+6+1+12+1;
2877 /*if(i<=last_index)*/{
2878 int level = block[ scan_table[i] ];
2879 int run = i - last_non_zero - 1;
2881 if((level&(~127)) == 0){
2882 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2883 len += len_tab[index];
2885 len += 7+2+1+6+1+12+1;
2895 /***********************************************/
2898 static VLC intra_MCBPC_vlc;
2899 static VLC inter_MCBPC_vlc;
2900 static VLC cbpy_vlc;
2902 static VLC dc_lum, dc_chrom;
2903 static VLC sprite_trajectory;
2904 static VLC mb_type_b_vlc;
2905 static VLC h263_mbtype_b_vlc;
2906 static VLC cbpc_b_vlc;
2908 void init_vlc_rl(RLTable *rl, int use_static)
2912 /* Return if static table is already initialized */
2913 if(use_static && rl->rl_vlc[0])
2916 init_vlc(&rl->vlc, 9, rl->n + 1,
2917 &rl->table_vlc[0][1], 4, 2,
2918 &rl->table_vlc[0][0], 4, 2, use_static);
2921 for(q=0; q<32; q++){
2930 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2932 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2933 for(i=0; i<rl->vlc.table_size; i++){
2934 int code= rl->vlc.table[i][0];
2935 int len = rl->vlc.table[i][1];
2938 if(len==0){ // illegal code
2941 }else if(len<0){ //more bits needed
2945 if(code==rl->n){ //esc
2949 run= rl->table_run [code] + 1;
2950 level= rl->table_level[code] * qmul + qadd;
2951 if(code >= rl->last) run+=192;
2954 rl->rl_vlc[q][i].len= len;
2955 rl->rl_vlc[q][i].level= level;
2956 rl->rl_vlc[q][i].run= run;
2963 /* XXX: find a better solution to handle static init */
2964 void h263_decode_init_vlc(MpegEncContext *s)
2966 static int done = 0;
2971 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2972 intra_MCBPC_bits, 1, 1,
2973 intra_MCBPC_code, 1, 1, 1);
2974 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2975 inter_MCBPC_bits, 1, 1,
2976 inter_MCBPC_code, 1, 1, 1);
2977 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2978 &cbpy_tab[0][1], 2, 1,
2979 &cbpy_tab[0][0], 2, 1, 1);
2980 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2982 &mvtab[0][0], 2, 1, 1);
2983 init_rl(&rl_inter, 1);
2984 init_rl(&rl_intra, 1);
2985 init_rl(&rvlc_rl_inter, 1);
2986 init_rl(&rvlc_rl_intra, 1);
2987 init_rl(&rl_intra_aic, 1);
2988 init_vlc_rl(&rl_inter, 1);
2989 init_vlc_rl(&rl_intra, 1);
2990 init_vlc_rl(&rvlc_rl_inter, 1);
2991 init_vlc_rl(&rvlc_rl_intra, 1);
2992 init_vlc_rl(&rl_intra_aic, 1);
2993 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2994 &DCtab_lum[0][1], 2, 1,
2995 &DCtab_lum[0][0], 2, 1, 1);
2996 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2997 &DCtab_chrom[0][1], 2, 1,
2998 &DCtab_chrom[0][0], 2, 1, 1);
2999 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
3000 &sprite_trajectory_tab[0][1], 4, 2,
3001 &sprite_trajectory_tab[0][0], 4, 2, 1);
3002 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3003 &mb_type_b_tab[0][1], 2, 1,
3004 &mb_type_b_tab[0][0], 2, 1, 1);
3005 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3006 &h263_mbtype_b_tab[0][1], 2, 1,
3007 &h263_mbtype_b_tab[0][0], 2, 1, 1);
3008 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3009 &cbpc_b_tab[0][1], 2, 1,
3010 &cbpc_b_tab[0][0], 2, 1, 1);
3015 * Get the GOB height based on picture height.
3017 int ff_h263_get_gob_height(MpegEncContext *s){
3018 if (s->height <= 400)
3020 else if (s->height <= 800)
3026 int ff_h263_decode_mba(MpegEncContext *s)
3031 if(s->mb_num-1 <= ff_mba_max[i]) break;
3033 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3034 s->mb_x= mb_pos % s->mb_width;
3035 s->mb_y= mb_pos / s->mb_width;
3040 void ff_h263_encode_mba(MpegEncContext *s)
3045 if(s->mb_num-1 <= ff_mba_max[i]) break;
3047 mb_pos= s->mb_x + s->mb_width*s->mb_y;
3048 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3052 * decodes the group of blocks header or slice header.
3053 * @return <0 if an error occured
3055 static int h263_decode_gob_header(MpegEncContext *s)
3057 unsigned int val, gfid, gob_number;
3060 /* Check for GOB Start Code */
3061 val = show_bits(&s->gb, 16);
3065 /* We have a GBSC probably with GSTUFF */
3066 skip_bits(&s->gb, 16); /* Drop the zeros */
3067 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3068 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3069 for(;left>13; left--){
3070 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3075 if(s->h263_slice_structured){
3076 if(get_bits1(&s->gb)==0)
3079 ff_h263_decode_mba(s);
3081 if(s->mb_num > 1583)
3082 if(get_bits1(&s->gb)==0)
3085 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3086 if(get_bits1(&s->gb)==0)
3088 gfid = get_bits(&s->gb, 2); /* GFID */
3090 gob_number = get_bits(&s->gb, 5); /* GN */
3092 s->mb_y= s->gob_index* gob_number;
3093 gfid = get_bits(&s->gb, 2); /* GFID */
3094 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3097 if(s->mb_y >= s->mb_height)
3106 static inline void memsetw(short *tab, int val, int n)
3113 #ifdef CONFIG_ENCODERS
3115 void ff_mpeg4_init_partitions(MpegEncContext *s)
3117 uint8_t *start= pbBufPtr(&s->pb);
3118 uint8_t *end= s->pb.buf_end;
3119 int size= end - start;
3120 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3121 int tex_size= (size - 2*pb_size)&(~3);
3123 set_put_bits_buffer_size(&s->pb, pb_size);
3124 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3125 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3128 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3130 const int pb2_len = put_bits_count(&s->pb2 );
3131 const int tex_pb_len= put_bits_count(&s->tex_pb);
3132 const int bits= put_bits_count(&s->pb);
3134 if(s->pict_type==I_TYPE){
3135 put_bits(&s->pb, 19, DC_MARKER);
3136 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3137 s->i_tex_bits+= tex_pb_len;
3139 put_bits(&s->pb, 17, MOTION_MARKER);
3140 s->misc_bits+=17 + pb2_len;
3141 s->mv_bits+= bits - s->last_bits;
3142 s->p_tex_bits+= tex_pb_len;
3145 flush_put_bits(&s->pb2);
3146 flush_put_bits(&s->tex_pb);
3148 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3149 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3150 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3151 s->last_bits= put_bits_count(&s->pb);
3154 #endif //CONFIG_ENCODERS
3156 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3157 switch(s->pict_type){
3162 return s->f_code+15;
3164 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3170 #ifdef CONFIG_ENCODERS
3172 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3174 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3176 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3177 put_bits(&s->pb, 1, 1);
3179 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3180 put_bits(&s->pb, s->quant_precision, s->qscale);
3181 put_bits(&s->pb, 1, 0); /* no HEC */
3184 #endif //CONFIG_ENCODERS
3187 * check if the next stuff is a resync marker or the end.
3190 static inline int mpeg4_is_resync(MpegEncContext *s){
3191 int bits_count= get_bits_count(&s->gb);
3192 int v= show_bits(&s->gb, 16);
3194 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3199 if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3201 skip_bits(&s->gb, 8+s->pict_type);
3202 bits_count+= 8+s->pict_type;
3203 v= show_bits(&s->gb, 16);
3206 if(bits_count + 8 >= s->gb.size_in_bits){
3208 v|= 0x7F >> (7-(bits_count&7));
3213 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3215 GetBitContext gb= s->gb;
3217 skip_bits(&s->gb, 1);
3218 align_get_bits(&s->gb);
3220 for(len=0; len<32; len++){
3221 if(get_bits1(&s->gb)) break;
3226 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3234 * decodes the next video packet.
3235 * @return <0 if something went wrong
3237 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3239 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3240 int header_extension=0, mb_num, len;
3242 /* is there enough space left for a video packet + header */
3243 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3245 for(len=0; len<32; len++){
3246 if(get_bits1(&s->gb)) break;
3249 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3250 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3254 if(s->shape != RECT_SHAPE){
3255 header_extension= get_bits1(&s->gb);
3256 //FIXME more stuff here
3259 mb_num= get_bits(&s->gb, mb_num_bits);
3260 if(mb_num>=s->mb_num){
3261 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3264 if(s->pict_type == B_TYPE){
3265 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3266 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3269 s->mb_x= mb_num % s->mb_width;
3270 s->mb_y= mb_num / s->mb_width;
3272 if(s->shape != BIN_ONLY_SHAPE){
3273 int qscale= get_bits(&s->gb, s->quant_precision);
3275 s->chroma_qscale=s->qscale= qscale;
3278 if(s->shape == RECT_SHAPE){
3279 header_extension= get_bits1(&s->gb);
3281 if(header_extension){
3285 while (get_bits1(&s->gb) != 0)
3288 check_marker(&s->gb, "before time_increment in video packed header");
3289 time_increment= get_bits(&s->gb, s->time_increment_bits);
3290 check_marker(&s->gb, "before vop_coding_type in video packed header");
3292 skip_bits(&s->gb, 2); /* vop coding type */
3293 //FIXME not rect stuff here
3295 if(s->shape != BIN_ONLY_SHAPE){
3296 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3297 //FIXME don't just ignore everything
3298 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3299 mpeg4_decode_sprite_trajectory(s, &s->gb);
3300 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3303 //FIXME reduced res stuff here
3305 if (s->pict_type != I_TYPE) {
3306 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3308 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3311 if (s->pict_type == B_TYPE) {
3312 int b_code = get_bits(&s->gb, 3);
3314 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3319 //FIXME new-pred stuff
3321 //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));
3326 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3328 int c_wrap, c_xy, l_wrap, l_xy;
3330 l_wrap= s->b8_stride;
3331 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3332 c_wrap= s->mb_stride;
3333 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3337 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3338 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3339 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3343 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3344 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3345 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3348 // we can't clear the MVs as they might be needed by a b frame
3349 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3350 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3351 s->last_mv[0][0][0]=
3352 s->last_mv[0][0][1]=
3353 s->last_mv[1][0][0]=
3354 s->last_mv[1][0][1]= 0;
3358 * decodes the group of blocks / video packet header.
3359 * @return <0 if no resync found
3361 int ff_h263_resync(MpegEncContext *s){
3364 if(s->codec_id==CODEC_ID_MPEG4){
3366 align_get_bits(&s->gb);
3369 if(show_bits(&s->gb, 16)==0){
3370 if(s->codec_id==CODEC_ID_MPEG4)
3371 ret= mpeg4_decode_video_packet_header(s);
3373 ret= h263_decode_gob_header(s);
3377 //ok, it's not where its supposed to be ...
3378 s->gb= s->last_resync_gb;
3379 align_get_bits(&s->gb);
3380 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3382 for(;left>16+1+5+5; left-=8){
3383 if(show_bits(&s->gb, 16)==0){
3384 GetBitContext bak= s->gb;
3386 if(s->codec_id==CODEC_ID_MPEG4)
3387 ret= mpeg4_decode_video_packet_header(s);
3389 ret= h263_decode_gob_header(s);
3395 skip_bits(&s->gb, 8);
3402 * gets the average motion vector for a GMC MB.
3403 * @param n either 0 for the x component or 1 for y
3404 * @returns the average MV for a GMC MB
3406 static inline int get_amv(MpegEncContext *s, int n){
3407 int x, y, mb_v, sum, dx, dy, shift;
3408 int len = 1 << (s->f_code + 4);
3409 const int a= s->sprite_warping_accuracy;
3411 if(s->workaround_bugs & FF_BUG_AMV)
3412 len >>= s->quarter_sample;
3414 if(s->real_sprite_warping_points==1){
3415 if(s->divx_version==500 && s->divx_build==413)
3416 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3418 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3420 dx= s->sprite_delta[n][0];
3421 dy= s->sprite_delta[n][1];
3422 shift= s->sprite_shift[0];
3423 if(n) dy -= 1<<(shift + a + 1);
3424 else dx -= 1<<(shift + a + 1);
3425 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3428 for(y=0; y<16; y++){
3432 //XXX FIXME optimize
3433 for(x=0; x<16; x++){
3438 sum= RSHIFT(sum, a+8-s->quarter_sample);
3441 if (sum < -len) sum= -len;
3442 else if (sum >= len) sum= len-1;
3448 * decodes first partition.
3449 * @return number of MBs decoded or <0 if an error occured
3451 static int mpeg4_decode_partition_a(MpegEncContext *s){
3453 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3455 /* decode first partition */
3457 s->first_slice_line=1;
3458 for(; s->mb_y<s->mb_height; s->mb_y++){
3459 ff_init_block_index(s);
3460 for(; s->mb_x<s->mb_width; s->mb_x++){
3461 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3466 ff_update_block_index(s);
3467 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3468 s->first_slice_line=0;
3470 if(s->pict_type==I_TYPE){
3474 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3478 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3480 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3485 s->cbp_table[xy]= cbpc & 3;
3486 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3490 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3492 s->current_picture.qscale_table[xy]= s->qscale;
3494 s->mbintra_table[xy]= 1;
3497 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3499 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3503 if(dc_pred_dir) dir|=1;
3505 s->pred_dir_table[xy]= dir;
3506 }else{ /* P/S_TYPE */
3507 int mx, my, pred_x, pred_y, bits;
3508 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3509 const int stride= s->b8_stride*2;
3512 bits= show_bits(&s->gb, 17);
3513 if(bits==MOTION_MARKER){
3519 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3520 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3524 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3527 mot_val[0 ]= mot_val[2 ]=
3528 mot_val[0+stride]= mot_val[2+stride]= mx;
3529 mot_val[1 ]= mot_val[3 ]=
3530 mot_val[1+stride]= mot_val[3+stride]= my;
3532 if(s->mbintra_table[xy])
3533 ff_clean_intra_table_entries(s);
3537 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3539 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3545 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3547 s->mb_intra = ((cbpc & 4) != 0);
3550 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3551 s->mbintra_table[xy]= 1;
3552 mot_val[0 ]= mot_val[2 ]=
3553 mot_val[0+stride]= mot_val[2+stride]= 0;
3554 mot_val[1 ]= mot_val[3 ]=
3555 mot_val[1+stride]= mot_val[3+stride]= 0;
3557 if(s->mbintra_table[xy])
3558 ff_clean_intra_table_entries(s);
3560 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3561 s->mcsel= get_bits1(&s->gb);
3564 if ((cbpc & 16) == 0) {
3565 /* 16x16 motion prediction */
3567 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3569 mx = h263_decode_motion(s, pred_x, s->f_code);
3573 my = h263_decode_motion(s, pred_y, s->f_code);
3576 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3580 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3583 mot_val[0 ]= mot_val[2 ] =
3584 mot_val[0+stride]= mot_val[2+stride]= mx;
3585 mot_val[1 ]= mot_val[3 ]=
3586 mot_val[1+stride]= mot_val[3+stride]= my;
3589 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3591 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3592 mx = h263_decode_motion(s, pred_x, s->f_code);
3596 my = h263_decode_motion(s, pred_y, s->f_code);
3613 * decode second partition.
3614 * @return <0 if an error occured
3616 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3618 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3620 s->mb_x= s->resync_mb_x;
3621 s->first_slice_line=1;
3622 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3623 ff_init_block_index(s);
3624 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3625 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3628 ff_update_block_index(s);
3629 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3630 s->first_slice_line=0;
3632 if(s->pict_type==I_TYPE){
3633 int ac_pred= get_bits1(&s->gb);
3634 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3636 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3640 s->cbp_table[xy]|= cbpy<<2;
3641 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3642 }else{ /* P || S_TYPE */
3643 if(IS_INTRA(s->current_picture.mb_type[xy])){
3645 int ac_pred = get_bits1(&s->gb);
3646 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3649 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3653 if(s->cbp_table[xy] & 8) {
3654 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3656 s->current_picture.qscale_table[xy]= s->qscale;
3660 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3662 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3666 if(dc_pred_dir) dir|=1;
3668 s->cbp_table[xy]&= 3; //remove dquant
3669 s->cbp_table[xy]|= cbpy<<2;
3670 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3671 s->pred_dir_table[xy]= dir;
3672 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3673 s->current_picture.qscale_table[xy]= s->qscale;
3674 s->cbp_table[xy]= 0;
3676 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3679 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3683 if(s->cbp_table[xy] & 8) {
3684 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3686 s->current_picture.qscale_table[xy]= s->qscale;
3688 s->cbp_table[xy]&= 3; //remove dquant
3689 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3693 if(mb_num >= mb_count) return 0;
3700 * decodes the first & second partition
3701 * @return <0 if error (and sets error type in the error_status_table)
3703 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3706 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3707 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3709 mb_num= mpeg4_decode_partition_a(s);
3711 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3715 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3716 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3717 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3721 s->mb_num_left= mb_num;
3723 if(s->pict_type==I_TYPE){
3724 while(show_bits(&s->gb, 9) == 1)
3725 skip_bits(&s->gb, 9);
3726 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3727 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3731 while(show_bits(&s->gb, 10) == 1)
3732 skip_bits(&s->gb, 10);
3733 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3734 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3738 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3740 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3741 if(s->pict_type==P_TYPE)
3742 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3745 if(s->pict_type==P_TYPE)
3746 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3753 * decode partition C of one MB.
3754 * @return <0 if an error occured
3756 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3759 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3761 mb_type= s->current_picture.mb_type[xy];
3762 cbp = s->cbp_table[xy];
3764 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3766 if(s->current_picture.qscale_table[xy] != s->qscale){
3767 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3770 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3773 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3774 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3776 s->mb_intra = IS_INTRA(mb_type);
3778 if (IS_SKIP(mb_type)) {
3781 s->block_last_index[i] = -1;
3782 s->mv_dir = MV_DIR_FORWARD;
3783 s->mv_type = MV_TYPE_16X16;
3784 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3791 }else if(s->mb_intra){
3792 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3793 }else if(!s->mb_intra){
3794 // s->mcsel= 0; //FIXME do we need to init that
3796 s->mv_dir = MV_DIR_FORWARD;
3797 if (IS_8X8(mb_type)) {
3798 s->mv_type = MV_TYPE_8X8;
3800 s->mv_type = MV_TYPE_16X16;
3803 } else { /* I-Frame */
3805 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3808 if (!IS_SKIP(mb_type)) {
3810 s->dsp.clear_blocks(s->block[0]);
3811 /* decode each block */
3812 for (i = 0; i < 6; i++) {
3813 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3814 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3821 /* per-MB end of slice check */
3823 if(--s->mb_num_left <= 0){
3824 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3825 if(mpeg4_is_resync(s))
3830 if(mpeg4_is_resync(s)){
3831 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3832 if(s->cbp_table[xy+delta])
3840 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3842 static void preview_obmc(MpegEncContext *s){
3843 GetBitContext gb= s->gb;
3845 int cbpc, i, pred_x, pred_y, mx, my;
3847 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3848 const int stride= s->b8_stride*2;
3851 s->block_index[i]+= 2;
3853 s->block_index[i]+= 1;
3856 assert(s->pict_type == P_TYPE);
3859 if (get_bits1(&s->gb)) {
3861 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3862 mot_val[0 ]= mot_val[2 ]=
3863 mot_val[0+stride]= mot_val[2+stride]= 0;
3864 mot_val[1 ]= mot_val[3 ]=
3865 mot_val[1+stride]= mot_val[3+stride]= 0;
3867 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3870 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3874 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3876 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3878 if(s->modified_quant){
3879 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3880 else skip_bits(&s->gb, 5);
3882 skip_bits(&s->gb, 2);
3885 if ((cbpc & 16) == 0) {
3886 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3887 /* 16x16 motion prediction */
3888 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3890 mx = h263p_decode_umotion(s, pred_x);
3892 mx = h263_decode_motion(s, pred_x, 1);
3895 my = h263p_decode_umotion(s, pred_y);
3897 my = h263_decode_motion(s, pred_y, 1);
3899 mot_val[0 ]= mot_val[2 ]=
3900 mot_val[0+stride]= mot_val[2+stride]= mx;
3901 mot_val[1 ]= mot_val[3 ]=
3902 mot_val[1+stride]= mot_val[3+stride]= my;
3904 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3906 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3908 mx = h263p_decode_umotion(s, pred_x);
3910 mx = h263_decode_motion(s, pred_x, 1);
3913 my = h263p_decode_umotion(s, pred_y);
3915 my = h263_decode_motion(s, pred_y, 1);
3916 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3917 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3926 s->block_index[i]-= 2;
3928 s->block_index[i]-= 1;
3934 static void h263_decode_dquant(MpegEncContext *s){
3935 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3937 if(s->modified_quant){
3938 if(get_bits1(&s->gb))
3939 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3941 s->qscale= get_bits(&s->gb, 5);
3943 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3944 ff_set_qscale(s, s->qscale);
3947 int ff_h263_decode_mb(MpegEncContext *s,
3948 DCTELEM block[6][64])
3950 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3952 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3954 assert(!s->h263_pred);
3956 if (s->pict_type == P_TYPE) {
3958 if (get_bits1(&s->gb)) {
3962 s->block_last_index[i] = -1;
3963 s->mv_dir = MV_DIR_FORWARD;
3964 s->mv_type = MV_TYPE_16X16;
3965 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3968 s->mb_skipped = !(s->obmc | s->loop_filter);
3971 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3972 //fprintf(stderr, "\tCBPC: %d", cbpc);
3974 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3979 s->dsp.clear_blocks(s->block[0]);
3982 s->mb_intra = ((cbpc & 4) != 0);
3983 if (s->mb_intra) goto intra;
3985 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3987 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3990 cbp = (cbpc & 3) | (cbpy << 2);
3992 h263_decode_dquant(s);
3995 s->mv_dir = MV_DIR_FORWARD;
3996 if ((cbpc & 16) == 0) {
3997 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3998 /* 16x16 motion prediction */
3999 s->mv_type = MV_TYPE_16X16;
4000 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4002 mx = h263p_decode_umotion(s, pred_x);
4004 mx = h263_decode_motion(s, pred_x, 1);
4010 my = h263p_decode_umotion(s, pred_y);
4012 my = h263_decode_motion(s, pred_y, 1);
4016 s->mv[0][0][0] = mx;
4017 s->mv[0][0][1] = my;
4019 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4020 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4022 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4023 s->mv_type = MV_TYPE_8X8;
4025 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4027 mx = h263p_decode_umotion(s, pred_x);
4029 mx = h263_decode_motion(s, pred_x, 1);
4034 my = h263p_decode_umotion(s, pred_y);
4036 my = h263_decode_motion(s, pred_y, 1);
4039 s->mv[0][i][0] = mx;
4040 s->mv[0][i][1] = my;
4041 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4042 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4048 /* decode each block */
4049 for (i = 0; i < 6; i++) {
4050 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4056 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4059 } else if(s->pict_type==B_TYPE) {
4061 const int stride= s->b8_stride;
4062 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4063 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4064 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4067 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4068 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4069 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4070 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4073 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4075 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4079 mb_type= h263_mb_type_b_map[ mb_type ];
4082 s->mb_intra = IS_INTRA(mb_type);
4083 if(HAS_CBP(mb_type)){
4084 s->dsp.clear_blocks(s->block[0]);
4085 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4087 dquant = IS_QUANT(mb_type);
4091 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4094 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4098 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4101 cbp = (cbpc & 3) | (cbpy << 2);
4105 assert(!s->mb_intra);
4107 if(IS_QUANT(mb_type)){
4108 h263_decode_dquant(s);
4111 if(IS_DIRECT(mb_type)){
4112 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4113 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4116 s->mv_type= MV_TYPE_16X16;
4119 if(USES_LIST(mb_type, 0)){
4120 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4121 s->mv_dir = MV_DIR_FORWARD;
4123 mx = h263_decode_motion(s, mx, 1);
4124 my = h263_decode_motion(s, my, 1);
4126 s->mv[0][0][0] = mx;
4127 s->mv[0][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;
4132 if(USES_LIST(mb_type, 1)){
4133 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4134 s->mv_dir |= MV_DIR_BACKWARD;
4136 mx = h263_decode_motion(s, mx, 1);
4137 my = h263_decode_motion(s, my, 1);
4139 s->mv[1][0][0] = mx;
4140 s->mv[1][0][1] = my;
4141 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4142 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4146 s->current_picture.mb_type[xy]= mb_type;
4148 /* decode each block */
4149 for (i = 0; i < 6; i++) {
4150 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4154 } else { /* I-Frame */
4156 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4158 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4163 s->dsp.clear_blocks(s->block[0]);
4168 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4170 s->ac_pred = get_bits1(&s->gb);
4172 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4174 s->h263_aic_dir = get_bits1(&s->gb);
4179 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4181 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4184 cbp = (cbpc & 3) | (cbpy << 2);
4186 h263_decode_dquant(s);
4189 /* decode each block */
4190 for (i = 0; i < 6; i++) {
4191 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4198 /* per-MB end of slice check */
4200 int v= show_bits(&s->gb, 16);
4202 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4203 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4213 int ff_mpeg4_decode_mb(MpegEncContext *s,
4214 DCTELEM block[6][64])
4216 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4218 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4219 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4221 assert(s->h263_pred);
4223 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4225 if (get_bits1(&s->gb)) {
4229 s->block_last_index[i] = -1;
4230 s->mv_dir = MV_DIR_FORWARD;
4231 s->mv_type = MV_TYPE_16X16;
4232 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4233 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4235 s->mv[0][0][0]= get_amv(s, 0);
4236 s->mv[0][0][1]= get_amv(s, 1);
4240 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4248 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4249 //fprintf(stderr, "\tCBPC: %d", cbpc);
4251 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4256 s->dsp.clear_blocks(s->block[0]);
4258 s->mb_intra = ((cbpc & 4) != 0);
4259 if (s->mb_intra) goto intra;
4261 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4262 s->mcsel= get_bits1(&s->gb);
4264 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4266 cbp = (cbpc & 3) | (cbpy << 2);
4268 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4270 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4271 s->interlaced_dct= get_bits1(&s->gb);
4273 s->mv_dir = MV_DIR_FORWARD;
4274 if ((cbpc & 16) == 0) {
4276 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4277 /* 16x16 global motion prediction */
4278 s->mv_type = MV_TYPE_16X16;
4281 s->mv[0][0][0] = mx;
4282 s->mv[0][0][1] = my;
4283 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4284 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4285 /* 16x8 field motion prediction */
4286 s->mv_type= MV_TYPE_FIELD;
4288 s->field_select[0][0]= get_bits1(&s->gb);
4289 s->field_select[0][1]= get_bits1(&s->gb);
4291 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4294 mx = h263_decode_motion(s, pred_x, s->f_code);
4298 my = h263_decode_motion(s, pred_y/2, s->f_code);
4302 s->mv[0][i][0] = mx;
4303 s->mv[0][i][1] = my;
4306 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4307 /* 16x16 motion prediction */
4308 s->mv_type = MV_TYPE_16X16;
4309 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4310 mx = h263_decode_motion(s, pred_x, s->f_code);
4315 my = h263_decode_motion(s, pred_y, s->f_code);
4319 s->mv[0][0][0] = mx;
4320 s->mv[0][0][1] = my;
4323 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4324 s->mv_type = MV_TYPE_8X8;
4326 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4327 mx = h263_decode_motion(s, pred_x, s->f_code);
4331 my = h263_decode_motion(s, pred_y, s->f_code);
4334 s->mv[0][i][0] = mx;
4335 s->mv[0][i][1] = my;
4340 } else if(s->pict_type==B_TYPE) {
4341 int modb1; // first bit of modb
4342 int modb2; // second bit of modb
4345 s->mb_intra = 0; //B-frames never contain intra blocks
4346 s->mcsel=0; // ... true gmc blocks
4350 s->last_mv[i][0][0]=
4351 s->last_mv[i][0][1]=
4352 s->last_mv[i][1][0]=
4353 s->last_mv[i][1][1]= 0;
4357 /* if we skipped it in the future P Frame than skip it now too */
4358 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4363 s->block_last_index[i] = -1;
4365 s->mv_dir = MV_DIR_FORWARD;
4366 s->mv_type = MV_TYPE_16X16;
4371 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4375 modb1= get_bits1(&s->gb);
4377 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4380 modb2= get_bits1(&s->gb);
4381 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4383 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4386 mb_type= mb_type_b_map[ mb_type ];
4389 s->dsp.clear_blocks(s->block[0]);
4390 cbp= get_bits(&s->gb, 6);
4393 if ((!IS_DIRECT(mb_type)) && cbp) {
4394 if(get_bits1(&s->gb)){
4395 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4399 if(!s->progressive_sequence){
4401 s->interlaced_dct= get_bits1(&s->gb);
4403 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4404 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4405 mb_type &= ~MB_TYPE_16x16;
4407 if(USES_LIST(mb_type, 0)){
4408 s->field_select[0][0]= get_bits1(&s->gb);
4409 s->field_select[0][1]= get_bits1(&s->gb);
4411 if(USES_LIST(mb_type, 1)){
4412 s->field_select[1][0]= get_bits1(&s->gb);
4413 s->field_select[1][1]= get_bits1(&s->gb);
4419 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4420 s->mv_type= MV_TYPE_16X16;
4422 if(USES_LIST(mb_type, 0)){
4423 s->mv_dir = MV_DIR_FORWARD;
4425 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4426 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4427 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4428 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4431 if(USES_LIST(mb_type, 1)){
4432 s->mv_dir |= MV_DIR_BACKWARD;
4434 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4435 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4436 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4437 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4439 }else if(!IS_DIRECT(mb_type)){
4440 s->mv_type= MV_TYPE_FIELD;
4442 if(USES_LIST(mb_type, 0)){
4443 s->mv_dir = MV_DIR_FORWARD;
4446 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4447 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4448 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4449 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4453 if(USES_LIST(mb_type, 1)){
4454 s->mv_dir |= MV_DIR_BACKWARD;
4457 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4458 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4459 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4460 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4466 if(IS_DIRECT(mb_type)){
4467 if(IS_SKIP(mb_type))
4470 mx = h263_decode_motion(s, 0, 1);
4471 my = h263_decode_motion(s, 0, 1);
4474 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4475 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4477 s->current_picture.mb_type[xy]= mb_type;
4478 } else { /* I-Frame */
4480 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4482 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4490 s->ac_pred = get_bits1(&s->gb);
4492 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4494 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4496 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4498 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4501 cbp = (cbpc & 3) | (cbpy << 2);
4503 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4506 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4509 if(!s->progressive_sequence)
4510 s->interlaced_dct= get_bits1(&s->gb);
4512 s->dsp.clear_blocks(s->block[0]);
4513 /* decode each block */
4514 for (i = 0; i < 6; i++) {
4515 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4522 /* decode each block */
4523 for (i = 0; i < 6; i++) {
4524 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4530 /* per-MB end of slice check */
4531 if(s->codec_id==CODEC_ID_MPEG4){
4532 if(mpeg4_is_resync(s)){
4533 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4534 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4543 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4545 int code, val, sign, shift, l;
4546 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4553 sign = get_bits1(&s->gb);
4557 val = (val - 1) << shift;
4558 val |= get_bits(&s->gb, shift);
4565 /* modulo decoding */
4566 if (!s->h263_long_vectors) {
4567 l = INT_BIT - 5 - f_code;
4570 /* horrible h263 long vector mode */
4571 if (pred < -31 && val < -63)
4573 if (pred > 32 && val > 63)
4580 /* Decodes RVLC of H.263+ UMV */
4581 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4585 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4588 code = 2 + get_bits1(&s->gb);
4590 while (get_bits1(&s->gb))
4593 code += get_bits1(&s->gb);
4598 code = (sign) ? (pred - code) : (pred + code);
4600 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4606 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4609 int code, level, i, j, last, run;
4610 RLTable *rl = &rl_inter;
4611 const uint8_t *scan_table;
4612 GetBitContext gb= s->gb;
4614 scan_table = s->intra_scantable.permutated;
4615 if (s->h263_aic && s->mb_intra) {
4619 if (s->h263_aic_dir)
4620 scan_table = s->intra_v_scantable.permutated; /* left */
4622 scan_table = s->intra_h_scantable.permutated; /* top */
4624 } else if (s->mb_intra) {
4626 if(s->codec_id == CODEC_ID_RV10){
4627 #ifdef CONFIG_RV10_DECODER
4628 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4629 int component, diff;
4630 component = (n <= 3 ? 0 : n - 4 + 1);
4631 level = s->last_dc[component];
4632 if (s->rv10_first_dc_coded[component]) {
4633 diff = rv_decode_dc(s, n);
4637 level = level & 0xff; /* handle wrap round */
4638 s->last_dc[component] = level;
4640 s->rv10_first_dc_coded[component] = 1;
4643 level = get_bits(&s->gb, 8);
4649 level = get_bits(&s->gb, 8);
4650 if((level&0x7F) == 0){
4651 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4652 if(s->error_resilience >= FF_ER_COMPLIANT)
4664 if (s->mb_intra && s->h263_aic)
4666 s->block_last_index[n] = i - 1;
4671 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4673 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4676 if (code == rl->n) {
4678 if (s->h263_flv > 1) {
4679 int is11 = get_bits1(&s->gb);
4680 last = get_bits1(&s->gb);
4681 run = get_bits(&s->gb, 6);
4683 level = get_sbits(&s->gb, 11);
4685 level = get_sbits(&s->gb, 7);
4688 last = get_bits1(&s->gb);
4689 run = get_bits(&s->gb, 6);
4690 level = (int8_t)get_bits(&s->gb, 8);
4692 if (s->codec_id == CODEC_ID_RV10) {
4693 /* XXX: should patch encoder too */
4694 level = get_sbits(&s->gb, 12);
4696 level = get_bits(&s->gb, 5);
4697 level |= get_sbits(&s->gb, 6)<<5;
4702 run = rl->table_run[code];
4703 level = rl->table_level[code];
4704 last = code >= rl->last;
4705 if (get_bits1(&s->gb))
4710 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4711 //looks like a hack but no, it's the way its supposed to work ...
4715 memset(block, 0, sizeof(DCTELEM)*64);
4718 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4728 if (s->mb_intra && s->h263_aic) {
4729 h263_pred_acdc(s, block, n);
4732 s->block_last_index[n] = i;
4737 * decodes the dc value.
4738 * @param n block index (0-3 are luma, 4-5 are chroma)
4739 * @param dir_ptr the prediction direction will be stored here
4740 * @return the quantized dc
4742 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4747 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4749 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4750 if (code < 0 || code > 9 /* && s->nbit<9 */){
4751 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4759 level= 2*get_bits1(&s->gb)-1;
4761 if(get_bits1(&s->gb))
4762 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4764 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4767 level = get_xbits(&s->gb, code);
4771 if(get_bits1(&s->gb)==0){ /* marker */
4772 if(s->error_resilience>=2){
4773 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4780 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4785 * @return <0 if an error occured
4787 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4788 int n, int coded, int intra, int rvlc)
4790 int level, i, last, run;
4793 RL_VLC_ELEM * rl_vlc;
4794 const uint8_t * scan_table;
4797 //Note intra & rvlc should be optimized away if this is inlined
4800 if(s->use_intra_dc_vlc){
4802 if(s->partitioned_frame){
4803 level = s->dc_val[0][ s->block_index[n] ];
4804 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4805 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4806 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4808 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4816 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4822 rl = &rvlc_rl_intra;
4823 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4826 rl_vlc = rl_intra.rl_vlc[0];
4829 if (dc_pred_dir == 0)
4830 scan_table = s->intra_v_scantable.permutated; /* left */
4832 scan_table = s->intra_h_scantable.permutated; /* top */
4834 scan_table = s->intra_scantable.permutated;
4841 s->block_last_index[n] = i;
4844 if(rvlc) rl = &rvlc_rl_inter;
4845 else rl = &rl_inter;
4847 scan_table = s->intra_scantable.permutated;
4853 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4855 rl_vlc = rl_inter.rl_vlc[0];
4858 qmul = s->qscale << 1;
4859 qadd = (s->qscale - 1) | 1;
4861 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4863 rl_vlc = rl_inter.rl_vlc[s->qscale];
4868 OPEN_READER(re, &s->gb);
4870 UPDATE_CACHE(re, &s->gb);
4871 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4875 if(SHOW_UBITS(re, &s->gb, 1)==0){
4876 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4878 }; SKIP_CACHE(re, &s->gb, 1);
4880 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4881 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4882 SKIP_COUNTER(re, &s->gb, 1+1+6);
4883 UPDATE_CACHE(re, &s->gb);
4885 if(SHOW_UBITS(re, &s->gb, 1)==0){
4886 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4888 }; SKIP_CACHE(re, &s->gb, 1);
4890 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4892 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4893 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4895 }; SKIP_CACHE(re, &s->gb, 5);
4897 level= level * qmul + qadd;
4898 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4899 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4905 cache= GET_CACHE(re, &s->gb);
4908 cache ^= 0xC0000000;
4910 if (cache&0x80000000) {
4911 if (cache&0x40000000) {
4913 SKIP_CACHE(re, &s->gb, 2);
4914 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4915 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4916 SKIP_COUNTER(re, &s->gb, 2+1+6);
4917 UPDATE_CACHE(re, &s->gb);
4920 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4922 if(SHOW_UBITS(re, &s->gb, 1)==0){
4923 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4925 }; SKIP_CACHE(re, &s->gb, 1);
4927 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4929 if(SHOW_UBITS(re, &s->gb, 1)==0){
4930 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4932 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4934 SKIP_COUNTER(re, &s->gb, 1+12+1);
4938 if(s->error_resilience >= FF_ER_COMPLIANT){
4939 const int abs_level= FFABS(level);
4940 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4941 const int run1= run - rl->max_run[last][abs_level] - 1;
4942 if(abs_level <= rl->max_level[last][run]){
4943 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4946 if(s->error_resilience > FF_ER_COMPLIANT){
4947 if(abs_level <= rl->max_level[last][run]*2){
4948 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4951 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4952 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4959 if (level>0) level= level * qmul + qadd;
4960 else level= level * qmul - qadd;
4962 if((unsigned)(level + 2048) > 4095){
4963 if(s->error_resilience > FF_ER_COMPLIANT){
4964 if(level > 2560 || level<-2560){
4965 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4969 level= level<0 ? -2048 : 2047;
4976 #if MIN_CACHE_BITS < 20
4977 LAST_SKIP_BITS(re, &s->gb, 2);
4978 UPDATE_CACHE(re, &s->gb);
4980 SKIP_BITS(re, &s->gb, 2);
4982 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4983 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4984 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4985 LAST_SKIP_BITS(re, &s->gb, 1);
4989 #if MIN_CACHE_BITS < 19
4990 LAST_SKIP_BITS(re, &s->gb, 1);
4991 UPDATE_CACHE(re, &s->gb);
4993 SKIP_BITS(re, &s->gb, 1);
4995 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4997 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4998 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4999 LAST_SKIP_BITS(re, &s->gb, 1);
5004 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
5005 LAST_SKIP_BITS(re, &s->gb, 1);
5010 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5014 block[scan_table[i]] = level;
5018 block[scan_table[i]] = level;
5020 CLOSE_READER(re, &s->gb);
5024 if(!s->use_intra_dc_vlc){
5025 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5027 i -= i>>31; //if(i == -1) i=0;
5030 mpeg4_pred_ac(s, block, n, dc_pred_dir);
5032 i = 63; /* XXX: not optimal */
5035 s->block_last_index[n] = i;
5039 /* most is hardcoded. should extend to handle all h263 streams */
5040 int h263_decode_picture_header(MpegEncContext *s)
5042 int format, width, height, i;
5045 align_get_bits(&s->gb);
5047 startcode= get_bits(&s->gb, 22-8);
5049 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5050 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5052 if(startcode == 0x20)
5056 if (startcode != 0x20) {
5057 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5060 /* temporal reference */
5061 i = get_bits(&s->gb, 8); /* picture timestamp */
5062 if( (s->picture_number&~0xFF)+i < s->picture_number)
5064 s->current_picture_ptr->pts=
5065 s->picture_number= (s->picture_number&~0xFF) + i;
5067 /* PTYPE starts here */
5068 if (get_bits1(&s->gb) != 1) {
5070 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5073 if (get_bits1(&s->gb) != 0) {
5074 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5075 return -1; /* h263 id */
5077 skip_bits1(&s->gb); /* split screen off */
5078 skip_bits1(&s->gb); /* camera off */
5079 skip_bits1(&s->gb); /* freeze picture release off */
5081 format = get_bits(&s->gb, 3);
5086 7 extended PTYPE (PLUSPTYPE)
5089 if (format != 7 && format != 6) {
5092 width = h263_format[format][0];
5093 height = h263_format[format][1];
5097 s->pict_type = I_TYPE + get_bits1(&s->gb);
5099 s->h263_long_vectors = get_bits1(&s->gb);
5101 if (get_bits1(&s->gb) != 0) {
5102 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5103 return -1; /* SAC: off */
5105 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5106 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5108 if (get_bits1(&s->gb) != 0) {
5109 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5110 return -1; /* not PB frame */
5112 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5113 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5117 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5118 s->avctx->time_base= (AVRational){1001, 30000};
5124 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5126 /* ufep other than 0 and 1 are reserved */
5129 format = get_bits(&s->gb, 3);
5130 dprintf("ufep=1, format: %d\n", format);
5131 s->custom_pcf= get_bits1(&s->gb);
5132 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5133 if (get_bits1(&s->gb) != 0) {
5134 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5136 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5137 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5138 s->loop_filter= get_bits1(&s->gb);
5139 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5141 s->h263_slice_structured= get_bits1(&s->gb);
5142 if (get_bits1(&s->gb) != 0) {
5143 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5145 if (get_bits1(&s->gb) != 0) {
5146 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5148 s->alt_inter_vlc= get_bits1(&s->gb);
5149 s->modified_quant= get_bits1(&s->gb);
5150 if(s->modified_quant)
5151 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5153 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5155 skip_bits(&s->gb, 3); /* Reserved */
5156 } else if (ufep != 0) {
5157 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5162 s->pict_type = get_bits(&s->gb, 3);
5163 switch(s->pict_type){
5164 case 0: s->pict_type= I_TYPE;break;
5165 case 1: s->pict_type= P_TYPE;break;
5166 case 3: s->pict_type= B_TYPE;break;
5167 case 7: s->pict_type= I_TYPE;break; //ZYGO
5171 skip_bits(&s->gb, 2);
5172 s->no_rounding = get_bits1(&s->gb);
5173 skip_bits(&s->gb, 4);
5175 /* Get the picture dimensions */
5178 /* Custom Picture Format (CPFMT) */
5179 s->aspect_ratio_info = get_bits(&s->gb, 4);
5180 dprintf("aspect: %d\n", s->aspect_ratio_info);
5185 3 - 10:11 (525-type 4:3)
5186 4 - 16:11 (CIF 16:9)
5187 5 - 40:33 (525-type 16:9)
5190 width = (get_bits(&s->gb, 9) + 1) * 4;
5192 height = get_bits(&s->gb, 9) * 4;
5193 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5194 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5195 /* aspected dimensions */
5196 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5197 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5199 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5202 width = h263_format[format][0];
5203 height = h263_format[format][1];
5204 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5206 if ((width == 0) || (height == 0))
5213 s->avctx->time_base.den= 1800000;
5214 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5215 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5216 if(s->avctx->time_base.num == 0){
5217 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5220 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5221 s->avctx->time_base.den /= gcd;
5222 s->avctx->time_base.num /= gcd;
5223 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5225 s->avctx->time_base= (AVRational){1001, 30000};
5230 skip_bits(&s->gb, 2); //extended Temporal reference
5235 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5238 if(s->h263_slice_structured){
5239 if (get_bits1(&s->gb) != 0) {
5240 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5242 if (get_bits1(&s->gb) != 0) {
5243 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5248 s->qscale = get_bits(&s->gb, 5);
5251 s->mb_width = (s->width + 15) / 16;
5252 s->mb_height = (s->height + 15) / 16;
5253 s->mb_num = s->mb_width * s->mb_height;
5256 while (get_bits1(&s->gb) != 0) {
5257 skip_bits(&s->gb, 8);
5260 if(s->h263_slice_structured){
5261 if (get_bits1(&s->gb) != 1) {
5262 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5266 ff_h263_decode_mba(s);
5268 if (get_bits1(&s->gb) != 1) {
5269 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5276 s->y_dc_scale_table=
5277 s->c_dc_scale_table= ff_aic_dc_scale_table;
5279 s->y_dc_scale_table=
5280 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5283 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5284 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",
5285 s->qscale, av_get_pict_type_char(s->pict_type),
5286 s->gb.size_in_bits, 1-s->no_rounding,
5287 s->obmc ? " AP" : "",
5288 s->umvplus ? " UMV" : "",
5289 s->h263_long_vectors ? " LONG" : "",
5290 s->h263_plus ? " +" : "",
5291 s->h263_aic ? " AIC" : "",
5292 s->alt_inter_vlc ? " AIV" : "",
5293 s->modified_quant ? " MQ" : "",
5294 s->loop_filter ? " LOOP" : "",
5295 s->h263_slice_structured ? " SS" : "",
5296 s->avctx->time_base.den, s->avctx->time_base.num
5300 if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){
5302 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5303 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5304 for(i=0; i<13; i++){
5306 int v= get_bits(&s->gb, 8);
5307 v |= get_sbits(&s->gb, 8)<<8;
5308 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5310 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5312 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5319 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5322 int a= 2<<s->sprite_warping_accuracy;
5323 int rho= 3-s->sprite_warping_accuracy;
5325 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5326 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5327 int sprite_ref[4][2];
5328 int virtual_ref[2][2];
5330 int alpha=0, beta=0;
5335 for(i=0; i<s->num_sprite_warping_points; i++){
5339 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5341 x= get_xbits(gb, length);
5343 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5345 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5347 y=get_xbits(gb, length);
5349 skip_bits1(gb); /* marker bit */
5350 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5355 while((1<<alpha)<w) alpha++;
5356 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5360 // Note, the 4th point isn't used for GMC
5361 if(s->divx_version==500 && s->divx_build==413){
5362 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5363 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5364 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5365 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5366 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5367 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5369 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5370 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5371 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5372 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5373 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5374 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5376 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5377 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5379 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5380 // perhaps it should be reordered to be more readable ...
5381 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5382 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5383 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5384 + 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);
5385 virtual_ref[0][1]= 16*vop_ref[0][1]
5386 + 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);
5387 virtual_ref[1][0]= 16*vop_ref[0][0]
5388 + 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);
5389 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5390 + 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);
5392 switch(s->num_sprite_warping_points)
5395 s->sprite_offset[0][0]= 0;
5396 s->sprite_offset[0][1]= 0;
5397 s->sprite_offset[1][0]= 0;
5398 s->sprite_offset[1][1]= 0;
5399 s->sprite_delta[0][0]= a;
5400 s->sprite_delta[0][1]= 0;
5401 s->sprite_delta[1][0]= 0;
5402 s->sprite_delta[1][1]= a;
5403 s->sprite_shift[0]= 0;
5404 s->sprite_shift[1]= 0;
5407 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5408 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5409 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5410 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5411 s->sprite_delta[0][0]= a;
5412 s->sprite_delta[0][1]= 0;
5413 s->sprite_delta[1][0]= 0;
5414 s->sprite_delta[1][1]= a;
5415 s->sprite_shift[0]= 0;
5416 s->sprite_shift[1]= 0;
5419 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5420 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5421 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5422 + (1<<(alpha+rho-1));
5423 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5424 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5425 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5426 + (1<<(alpha+rho-1));
5427 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5428 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5429 +2*w2*r*sprite_ref[0][0]
5431 + (1<<(alpha+rho+1)));
5432 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5433 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5434 +2*w2*r*sprite_ref[0][1]
5436 + (1<<(alpha+rho+1)));
5437 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5438 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5439 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5440 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5442 s->sprite_shift[0]= alpha+rho;
5443 s->sprite_shift[1]= alpha+rho+2;
5446 min_ab= FFMIN(alpha, beta);
5449 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5450 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5451 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5452 + (1<<(alpha+beta+rho-min_ab-1));
5453 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5454 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5455 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5456 + (1<<(alpha+beta+rho-min_ab-1));
5457 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5458 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5459 + 2*w2*h3*r*sprite_ref[0][0]
5461 + (1<<(alpha+beta+rho-min_ab+1));
5462 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5463 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5464 + 2*w2*h3*r*sprite_ref[0][1]
5466 + (1<<(alpha+beta+rho-min_ab+1));
5467 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5468 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5469 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5470 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5472 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5473 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5476 /* try to simplify the situation */
5477 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5478 && s->sprite_delta[0][1] == 0
5479 && s->sprite_delta[1][0] == 0
5480 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5482 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5483 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5484 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5485 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5486 s->sprite_delta[0][0]= a;
5487 s->sprite_delta[0][1]= 0;
5488 s->sprite_delta[1][0]= 0;
5489 s->sprite_delta[1][1]= a;
5490 s->sprite_shift[0]= 0;
5491 s->sprite_shift[1]= 0;
5492 s->real_sprite_warping_points=1;
5495 int shift_y= 16 - s->sprite_shift[0];
5496 int shift_c= 16 - s->sprite_shift[1];
5497 //printf("shifts %d %d\n", shift_y, shift_c);
5499 s->sprite_offset[0][i]<<= shift_y;
5500 s->sprite_offset[1][i]<<= shift_c;
5501 s->sprite_delta[0][i]<<= shift_y;
5502 s->sprite_delta[1][i]<<= shift_y;
5503 s->sprite_shift[i]= 16;
5505 s->real_sprite_warping_points= s->num_sprite_warping_points;
5508 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5509 vop_ref[0][0], vop_ref[0][1],
5510 vop_ref[1][0], vop_ref[1][1],
5511 vop_ref[2][0], vop_ref[2][1],
5512 sprite_ref[0][0], sprite_ref[0][1],
5513 sprite_ref[1][0], sprite_ref[1][1],
5514 sprite_ref[2][0], sprite_ref[2][1],
5515 virtual_ref[0][0], virtual_ref[0][1],
5516 virtual_ref[1][0], virtual_ref[1][1]
5519 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5520 s->sprite_offset[0][0], s->sprite_offset[0][1],
5521 s->sprite_delta[0][0], s->sprite_delta[0][1],
5522 s->sprite_delta[1][0], s->sprite_delta[1][1],
5528 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5529 int hours, minutes, seconds;
5531 hours= get_bits(gb, 5);
5532 minutes= get_bits(gb, 6);
5534 seconds= get_bits(gb, 6);
5536 s->time_base= seconds + 60*(minutes + 60*hours);
5544 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5545 int width, height, vo_ver_id;
5548 skip_bits(gb, 1); /* random access */
5549 s->vo_type= get_bits(gb, 8);
5550 if (get_bits1(gb) != 0) { /* is_ol_id */
5551 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5552 skip_bits(gb, 3); /* vo_priority */
5556 //printf("vo type:%d\n",s->vo_type);
5557 s->aspect_ratio_info= get_bits(gb, 4);
5558 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5559 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5560 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5562 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5565 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5566 int chroma_format= get_bits(gb, 2);
5567 if(chroma_format!=1){
5568 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5570 s->low_delay= get_bits1(gb);
5571 if(get_bits1(gb)){ /* vbv parameters */
5572 get_bits(gb, 15); /* first_half_bitrate */
5573 skip_bits1(gb); /* marker */
5574 get_bits(gb, 15); /* latter_half_bitrate */
5575 skip_bits1(gb); /* marker */
5576 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5577 skip_bits1(gb); /* marker */
5578 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5579 get_bits(gb, 11); /* first_half_vbv_occupancy */
5580 skip_bits1(gb); /* marker */
5581 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5582 skip_bits1(gb); /* marker */
5585 // set low delay flag only once the smartest? low delay detection won't be overriden
5586 if(s->picture_number==0)
5590 s->shape = get_bits(gb, 2); /* vol shape */
5591 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5592 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5593 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5594 skip_bits(gb, 4); //video_object_layer_shape_extension
5597 check_marker(gb, "before time_increment_resolution");
5599 s->avctx->time_base.den = get_bits(gb, 16);
5600 if(!s->avctx->time_base.den){
5601 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5605 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5606 if (s->time_increment_bits < 1)
5607 s->time_increment_bits = 1;
5609 check_marker(gb, "before fixed_vop_rate");
5611 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5612 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5614 s->avctx->time_base.num = 1;
5618 if (s->shape != BIN_ONLY_SHAPE) {
5619 if (s->shape == RECT_SHAPE) {
5620 skip_bits1(gb); /* marker */
5621 width = get_bits(gb, 13);
5622 skip_bits1(gb); /* marker */
5623 height = get_bits(gb, 13);
5624 skip_bits1(gb); /* marker */
5625 if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5628 // printf("width/height: %d %d\n", width, height);
5632 s->progressive_sequence=
5633 s->progressive_frame= get_bits1(gb)^1;
5634 s->interlaced_dct=0;
5635 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5636 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5637 if (vo_ver_id == 1) {
5638 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5640 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5642 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5643 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5644 if(s->vol_sprite_usage==STATIC_SPRITE){
5645 s->sprite_width = get_bits(gb, 13);
5646 skip_bits1(gb); /* marker */
5647 s->sprite_height= get_bits(gb, 13);
5648 skip_bits1(gb); /* marker */
5649 s->sprite_left = get_bits(gb, 13);
5650 skip_bits1(gb); /* marker */
5651 s->sprite_top = get_bits(gb, 13);
5652 skip_bits1(gb); /* marker */
5654 s->num_sprite_warping_points= get_bits(gb, 6);
5655 s->sprite_warping_accuracy = get_bits(gb, 2);
5656 s->sprite_brightness_change= get_bits1(gb);
5657 if(s->vol_sprite_usage==STATIC_SPRITE)
5658 s->low_latency_sprite= get_bits1(gb);
5660 // FIXME sadct disable bit if verid!=1 && shape not rect
5662 if (get_bits1(gb) == 1) { /* not_8_bit */
5663 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5664 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5665 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5667 s->quant_precision = 5;
5670 // FIXME a bunch of grayscale shape things
5672 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5675 /* load default matrixes */
5676 for(i=0; i<64; i++){
5677 int j= s->dsp.idct_permutation[i];
5678 v= ff_mpeg4_default_intra_matrix[i];
5679 s->intra_matrix[j]= v;
5680 s->chroma_intra_matrix[j]= v;
5682 v= ff_mpeg4_default_non_intra_matrix[i];
5683 s->inter_matrix[j]= v;
5684 s->chroma_inter_matrix[j]= v;
5687 /* load custom intra matrix */
5690 for(i=0; i<64; i++){
5696 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5697 s->intra_matrix[j]= v;
5698 s->chroma_intra_matrix[j]= v;
5701 /* replicate last value */
5703 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5704 s->intra_matrix[j]= last;
5705 s->chroma_intra_matrix[j]= last;
5709 /* load custom non intra matrix */
5712 for(i=0; i<64; i++){
5718 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5719 s->inter_matrix[j]= v;
5720 s->chroma_inter_matrix[j]= v;
5723 /* replicate last value */
5725 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5726 s->inter_matrix[j]= last;
5727 s->chroma_inter_matrix[j]= last;
5731 // FIXME a bunch of grayscale shape things
5735 s->quarter_sample= get_bits1(gb);
5736 else s->quarter_sample=0;
5738 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5740 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5742 s->data_partitioning= get_bits1(gb);
5743 if(s->data_partitioning){
5744 s->rvlc= get_bits1(gb);
5747 if(vo_ver_id != 1) {
5748 s->new_pred= get_bits1(gb);
5750 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5751 skip_bits(gb, 2); /* requested upstream message type */
5752 skip_bits1(gb); /* newpred segment type */
5754 s->reduced_res_vop= get_bits1(gb);
5755 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5759 s->reduced_res_vop= 0;
5762 s->scalability= get_bits1(gb);
5764 if (s->scalability) {
5765 GetBitContext bak= *gb;
5767 int ref_layer_sampling_dir;
5768 int h_sampling_factor_n;
5769 int h_sampling_factor_m;
5770 int v_sampling_factor_n;
5771 int v_sampling_factor_m;
5773 s->hierachy_type= get_bits1(gb);
5774 ref_layer_id= get_bits(gb, 4);
5775 ref_layer_sampling_dir= get_bits1(gb);
5776 h_sampling_factor_n= get_bits(gb, 5);
5777 h_sampling_factor_m= get_bits(gb, 5);
5778 v_sampling_factor_n= get_bits(gb, 5);
5779 v_sampling_factor_m= get_bits(gb, 5);
5780 s->enhancement_type= get_bits1(gb);
5782 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5783 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5785 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5790 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5792 // bin shape stuff FIXME
5799 * decodes the user data stuff in the header.
5800 * allso inits divx/xvid/lavc_version/build
5802 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5806 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5809 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5810 if(show_bits(gb, 23) == 0) break;
5811 buf[i]= get_bits(gb, 8);
5815 /* divx detection */
5816 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5818 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5820 s->divx_version= ver;
5821 s->divx_build= build;
5822 s->divx_packed= e==3 && last=='p';
5825 /* ffmpeg detection */
5826 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5828 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5830 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5832 build= (ver<<16) + (ver2<<8) + ver3;
5835 if(strcmp(buf, "ffmpeg")==0){
5836 s->lavc_build= 4600;
5840 s->lavc_build= build;
5843 /* xvid detection */
5844 e=sscanf(buf, "XviD%d", &build);
5846 s->xvid_build= build;
5849 //printf("User Data: %s\n", buf);
5853 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5854 int time_incr, time_increment;
5856 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5857 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5858 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5862 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5863 if(s->partitioned_frame)
5864 s->decode_mb= mpeg4_decode_partitioned_mb;
5866 s->decode_mb= ff_mpeg4_decode_mb;
5869 while (get_bits1(gb) != 0)
5872 check_marker(gb, "before time_increment");
5874 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5875 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5877 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5878 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5881 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5884 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5885 else time_increment= get_bits(gb, s->time_increment_bits);
5887 // printf("%d %X\n", s->time_increment_bits, time_increment);
5888 //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);
5889 if(s->pict_type!=B_TYPE){
5890 s->last_time_base= s->time_base;
5891 s->time_base+= time_incr;
5892 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5893 if(s->workaround_bugs&FF_BUG_UMP4){
5894 if(s->time < s->last_non_b_time){
5895 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5897 s->time+= s->avctx->time_base.den;
5900 s->pp_time= s->time - s->last_non_b_time;
5901 s->last_non_b_time= s->time;
5903 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5904 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5905 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5906 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5907 return FRAME_SKIPPED;
5909 ff_mpeg4_init_direct_mv(s);
5911 if(s->t_frame==0) s->t_frame= s->pb_time;
5912 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5913 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5914 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5915 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5916 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5918 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" 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);
5920 if(s->avctx->time_base.num)
5921 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5923 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5924 if(s->avctx->debug&FF_DEBUG_PTS)
5925 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5927 check_marker(gb, "before vop_coded");
5930 if (get_bits1(gb) != 1){
5931 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5932 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5933 return FRAME_SKIPPED;
5935 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5936 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5937 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5938 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5939 /* rounding type for motion estimation */
5940 s->no_rounding = get_bits1(gb);
5944 //FIXME reduced res stuff
5946 if (s->shape != RECT_SHAPE) {
5947 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5948 int width, height, hor_spat_ref, ver_spat_ref;
5950 width = get_bits(gb, 13);
5951 skip_bits1(gb); /* marker */
5952 height = get_bits(gb, 13);
5953 skip_bits1(gb); /* marker */
5954 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5955 skip_bits1(gb); /* marker */
5956 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5958 skip_bits1(gb); /* change_CR_disable */
5960 if (get_bits1(gb) != 0) {
5961 skip_bits(gb, 8); /* constant_alpha_value */
5964 //FIXME complexity estimation stuff
5966 if (s->shape != BIN_ONLY_SHAPE) {
5967 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5968 if(!s->progressive_sequence){
5969 s->top_field_first= get_bits1(gb);
5970 s->alternate_scan= get_bits1(gb);
5972 s->alternate_scan= 0;
5975 if(s->alternate_scan){
5976 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5977 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5978 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5979 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5981 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5982 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5983 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5984 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5987 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5988 mpeg4_decode_sprite_trajectory(s, gb);
5989 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5990 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5993 if (s->shape != BIN_ONLY_SHAPE) {
5994 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5996 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5997 return -1; // makes no sense to continue, as there is nothing left from the image then
6000 if (s->pict_type != I_TYPE) {
6001 s->f_code = get_bits(gb, 3); /* fcode_for */
6003 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
6004 return -1; // makes no sense to continue, as the MV decoding will break very quickly
6009 if (s->pict_type == B_TYPE) {
6010 s->b_code = get_bits(gb, 3);
6014 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6015 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",
6016 s->qscale, s->f_code, s->b_code,
6017 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6018 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6019 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6020 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
6023 if(!s->scalability){
6024 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
6025 skip_bits1(gb); // vop shape coding type
6028 if(s->enhancement_type){
6029 int load_backward_shape= get_bits1(gb);
6030 if(load_backward_shape){
6031 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6034 skip_bits(gb, 2); //ref_select_code
6037 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6038 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6039 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6040 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6044 s->picture_number++; // better than pic number==0 always ;)
6046 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6047 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6049 if(s->workaround_bugs&FF_BUG_EDGE){
6050 s->h_edge_pos= s->width;
6051 s->v_edge_pos= s->height;
6057 * decode mpeg4 headers
6058 * @return <0 if no VOP found (or a damaged one)
6059 * FRAME_SKIPPED if a not coded VOP is found
6060 * 0 if a VOP is found
6062 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6066 /* search next start code */
6069 if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6071 if(get_bits(gb, 8) == 0xF0)
6072 return decode_vop_header(s, gb);
6077 if(get_bits_count(gb) >= gb->size_in_bits){
6078 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6079 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6080 return FRAME_SKIPPED; //divx bug
6082 return -1; //end of stream
6085 /* use the bits after the test */
6086 v = get_bits(gb, 8);
6087 startcode = ((startcode << 8) | v) & 0xffffffff;
6089 if((startcode&0xFFFFFF00) != 0x100)
6090 continue; //no startcode
6092 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6093 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6094 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6095 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6096 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6097 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6098 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6099 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6100 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6101 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6102 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6103 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6104 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6105 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6106 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6107 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6108 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6109 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6110 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6111 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6112 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6113 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6114 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6115 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6116 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6117 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6118 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6119 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6120 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6121 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6124 if(startcode >= 0x120 && startcode <= 0x12F){
6125 if(decode_vol_header(s, gb) < 0)
6128 else if(startcode == USER_DATA_STARTCODE){
6129 decode_user_data(s, gb);
6131 else if(startcode == GOP_STARTCODE){
6132 mpeg4_decode_gop_header(s, gb);
6134 else if(startcode == VOP_STARTCODE){
6135 return decode_vop_header(s, gb);
6143 /* don't understand why they choose a different header ! */
6144 int intel_h263_decode_picture_header(MpegEncContext *s)
6148 /* picture header */
6149 if (get_bits_long(&s->gb, 22) != 0x20) {
6150 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6153 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6155 if (get_bits1(&s->gb) != 1) {
6156 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6157 return -1; /* marker */
6159 if (get_bits1(&s->gb) != 0) {
6160 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6161 return -1; /* h263 id */
6163 skip_bits1(&s->gb); /* split screen off */
6164 skip_bits1(&s->gb); /* camera off */
6165 skip_bits1(&s->gb); /* freeze picture release off */
6167 format = get_bits(&s->gb, 3);
6169 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6174 s->pict_type = I_TYPE + get_bits1(&s->gb);
6176 s->unrestricted_mv = get_bits1(&s->gb);
6177 s->h263_long_vectors = s->unrestricted_mv;
6179 if (get_bits1(&s->gb) != 0) {
6180 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6181 return -1; /* SAC: off */
6183 if (get_bits1(&s->gb) != 0) {
6185 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6186 // return -1; /* advanced prediction mode: off */
6188 if (get_bits1(&s->gb) != 0) {
6189 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6190 return -1; /* PB frame mode */
6193 /* skip unknown header garbage */
6194 skip_bits(&s->gb, 41);
6196 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6197 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6200 while (get_bits1(&s->gb) != 0) {
6201 skip_bits(&s->gb, 8);
6205 s->y_dc_scale_table=
6206 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6211 int flv_h263_decode_picture_header(MpegEncContext *s)
6213 int format, width, height;
6215 /* picture header */
6216 if (get_bits_long(&s->gb, 17) != 1) {
6217 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6220 format = get_bits(&s->gb, 5);
6221 if (format != 0 && format != 1) {
6222 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6225 s->h263_flv = format+1;
6226 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6227 format = get_bits(&s->gb, 3);
6230 width = get_bits(&s->gb, 8);
6231 height = get_bits(&s->gb, 8);
6234 width = get_bits(&s->gb, 16);
6235 height = get_bits(&s->gb, 16);
6261 if(avcodec_check_dimensions(s->avctx, width, height))
6266 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6267 s->dropable= s->pict_type > P_TYPE;
6269 s->pict_type = P_TYPE;
6271 skip_bits1(&s->gb); /* deblocking flag */
6272 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6276 s->unrestricted_mv = 1;
6277 s->h263_long_vectors = 0;
6280 while (get_bits1(&s->gb) != 0) {
6281 skip_bits(&s->gb, 8);
6285 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6286 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6287 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6290 s->y_dc_scale_table=
6291 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;