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 * init s->current_picture.qscale_table from s->lambda_table
492 static void ff_init_qscale_tab(MpegEncContext *s){
493 int8_t * const qscale_table= s->current_picture.qscale_table;
496 for(i=0; i<s->mb_num; i++){
497 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
498 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
499 qscale_table[ s->mb_index2xy[i] ]= clip(qp, s->avctx->qmin, s->avctx->qmax);
504 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
506 void ff_clean_h263_qscales(MpegEncContext *s){
508 int8_t * const qscale_table= s->current_picture.qscale_table;
510 ff_init_qscale_tab(s);
512 for(i=1; i<s->mb_num; i++){
513 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
514 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
516 for(i=s->mb_num-2; i>=0; i--){
517 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
518 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
521 if(s->codec_id != CODEC_ID_H263P){
522 for(i=1; i<s->mb_num; i++){
523 int mb_xy= s->mb_index2xy[i];
525 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
526 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
533 * modify mb_type & qscale so that encoding is acually possible in mpeg4
535 void ff_clean_mpeg4_qscales(MpegEncContext *s){
537 int8_t * const qscale_table= s->current_picture.qscale_table;
539 ff_clean_h263_qscales(s);
541 if(s->pict_type== B_TYPE){
543 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
545 for(i=0; i<s->mb_num; i++){
546 int mb_xy= s->mb_index2xy[i];
547 odd += qscale_table[mb_xy]&1;
550 if(2*odd > s->mb_num) odd=1;
553 for(i=0; i<s->mb_num; i++){
554 int mb_xy= s->mb_index2xy[i];
555 if((qscale_table[mb_xy]&1) != odd)
556 qscale_table[mb_xy]++;
557 if(qscale_table[mb_xy] > 31)
558 qscale_table[mb_xy]= 31;
561 for(i=1; i<s->mb_num; i++){
562 int mb_xy= s->mb_index2xy[i];
563 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
564 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
570 #endif //CONFIG_ENCODERS
572 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
573 #define tab_bias (tab_size/2)
575 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
577 for(i=0; i<tab_size; i++){
578 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
579 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
583 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
584 int xy= s->block_index[i];
585 uint16_t time_pp= s->pp_time;
586 uint16_t time_pb= s->pb_time;
589 p_mx= s->next_picture.motion_val[0][xy][0];
590 if((unsigned)(p_mx + tab_bias) < tab_size){
591 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
592 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
593 : s->direct_scale_mv[1][p_mx + tab_bias];
595 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
596 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
597 : p_mx*(time_pb - time_pp)/time_pp;
599 p_my= s->next_picture.motion_val[0][xy][1];
600 if((unsigned)(p_my + tab_bias) < tab_size){
601 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
602 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
603 : s->direct_scale_mv[1][p_my + tab_bias];
605 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
606 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
607 : p_my*(time_pb - time_pp)/time_pp;
616 * @return the mb_type
618 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
619 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
620 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
621 uint16_t time_pp= s->pp_time;
622 uint16_t time_pb= s->pb_time;
625 //FIXME avoid divides
626 // try special case with shifts for 1 and 3 B-frames?
628 if(IS_8X8(colocated_mb_type)){
629 s->mv_type = MV_TYPE_8X8;
631 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
633 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
634 } else if(IS_INTERLACED(colocated_mb_type)){
635 s->mv_type = MV_TYPE_FIELD;
637 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
638 s->field_select[0][i]= field_select;
639 s->field_select[1][i]= i;
640 if(s->top_field_first){
641 time_pp= s->pp_field_time - field_select + i;
642 time_pb= s->pb_field_time - field_select + i;
644 time_pp= s->pp_field_time + field_select - i;
645 time_pb= s->pb_field_time + field_select - i;
647 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
648 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
649 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
650 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
651 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
652 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
654 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
656 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
657 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
658 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
659 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
660 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
661 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
662 s->mv_type= MV_TYPE_16X16;
664 s->mv_type= MV_TYPE_8X8;
665 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
669 void ff_h263_update_motion_val(MpegEncContext * s){
670 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
671 //FIXME a lot of that is only needed for !low_delay
672 const int wrap = s->b8_stride;
673 const int xy = s->block_index[0];
675 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
677 if(s->mv_type != MV_TYPE_8X8){
678 int motion_x, motion_y;
682 } else if (s->mv_type == MV_TYPE_16X16) {
683 motion_x = s->mv[0][0][0];
684 motion_y = s->mv[0][0][1];
685 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
687 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
688 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
689 motion_x = (motion_x>>1) | (motion_x&1);
691 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
692 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
694 s->current_picture.ref_index[0][xy ]=
695 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
696 s->current_picture.ref_index[0][xy + wrap ]=
697 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
700 /* no update if 8X8 because it has been done during parsing */
701 s->current_picture.motion_val[0][xy][0] = motion_x;
702 s->current_picture.motion_val[0][xy][1] = motion_y;
703 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
704 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
705 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
706 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
707 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
708 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
711 if(s->encoding){ //FIXME encoding MUST be cleaned up
712 if (s->mv_type == MV_TYPE_8X8)
713 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
715 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
717 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
721 #ifdef CONFIG_ENCODERS
723 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
724 int l, bit_size, code;
729 bit_size = f_code - 1;
730 /* modulo encoding */
731 l= INT_BIT - 6 - bit_size;
734 code = (val >> bit_size) + 1;
736 return mvtab[code][1] + 1 + bit_size;
740 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
741 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
742 skip_put_bits(&s->pb,
743 h263_get_motion_length(s, x, f_code)
744 +h263_get_motion_length(s, y, f_code));
746 ff_h263_encode_motion(s, x, f_code);
747 ff_h263_encode_motion(s, y, f_code);
751 static inline int get_p_cbp(MpegEncContext * s,
752 DCTELEM block[6][64],
753 int motion_x, int motion_y){
756 if(s->flags & CODEC_FLAG_CBP_RD){
757 int best_cbpy_score= INT_MAX;
758 int best_cbpc_score= INT_MAX;
759 int cbpc = (-1), cbpy= (-1);
760 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
761 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
764 int score= inter_MCBPC_bits[i + offset] * lambda;
765 if(i&1) score += s->coded_score[5];
766 if(i&2) score += s->coded_score[4];
768 if(score < best_cbpc_score){
769 best_cbpc_score= score;
775 int score= cbpy_tab[i ^ 0xF][1] * lambda;
776 if(i&1) score += s->coded_score[3];
777 if(i&2) score += s->coded_score[2];
778 if(i&4) score += s->coded_score[1];
779 if(i&8) score += s->coded_score[0];
781 if(score < best_cbpy_score){
782 best_cbpy_score= score;
787 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
788 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
792 for (i = 0; i < 6; i++) {
793 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
794 s->block_last_index[i]= -1;
795 memset(s->block[i], 0, sizeof(DCTELEM)*64);
800 for (i = 0; i < 6; i++) {
801 if (s->block_last_index[i] >= 0)
808 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
809 int motion_x, int motion_y, int mb_type){
812 if(s->flags & CODEC_FLAG_CBP_RD){
814 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
817 if(s->coded_score[i] < 0){
818 score += s->coded_score[i];
825 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
826 zero_score-= 4; //2*MV + mb_type + cbp bit
830 if(zero_score <= score){
835 for (i = 0; i < 6; i++) {
836 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
837 s->block_last_index[i]= -1;
838 memset(s->block[i], 0, sizeof(DCTELEM)*64);
842 for (i = 0; i < 6; i++) {
843 if (s->block_last_index[i] >= 0)
850 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
851 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
855 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
856 for (i = 0; i < 6; i++) {
857 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
860 /* encode each block */
861 for (i = 0; i < 6; i++) {
862 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
866 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
867 for (i = 0; i < 6; i++) {
868 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
871 /* encode each block */
872 for (i = 0; i < 6; i++) {
873 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
879 void mpeg4_encode_mb(MpegEncContext * s,
880 DCTELEM block[6][64],
881 int motion_x, int motion_y)
883 int cbpc, cbpy, pred_x, pred_y;
884 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
885 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
886 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
887 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
888 const int dquant_code[5]= {1,0,9,2,3};
890 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
894 if(s->pict_type==B_TYPE){
895 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
896 int mb_type= mb_type_table[s->mv_dir];
903 s->last_mv[i][1][1]= 0;
907 assert(s->dquant>=-2 && s->dquant<=2);
908 assert((s->dquant&1)==0);
911 /* nothing to do if this MB was skipped in the next P Frame */
912 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
918 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
919 s->qscale -= s->dquant;
925 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
927 if ((cbp | motion_x | motion_y | mb_type) ==0) {
928 /* direct MB with MV={0,0} */
929 assert(s->dquant==0);
931 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
933 if(interleaved_stats){
941 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
942 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
943 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
944 if(cbp) put_bits(&s->pb, 6, cbp);
948 put_bits(&s->pb, 2, (s->dquant>>2)+3);
950 put_bits(&s->pb, 1, 0);
952 s->qscale -= s->dquant;
954 if(!s->progressive_sequence){
956 put_bits(&s->pb, 1, s->interlaced_dct);
957 if(mb_type) // not direct mode
958 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
961 if(interleaved_stats){
962 s->misc_bits+= get_bits_diff(s);
966 assert(s->mv_dir & MV_DIRECT);
967 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
971 assert(mb_type > 0 && mb_type < 4);
972 if(s->mv_type != MV_TYPE_FIELD){
973 if(s->mv_dir & MV_DIR_FORWARD){
974 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
975 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
976 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
977 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
980 if(s->mv_dir & MV_DIR_BACKWARD){
981 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
982 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
983 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
984 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
988 if(s->mv_dir & MV_DIR_FORWARD){
989 put_bits(&s->pb, 1, s->field_select[0][0]);
990 put_bits(&s->pb, 1, s->field_select[0][1]);
992 if(s->mv_dir & MV_DIR_BACKWARD){
993 put_bits(&s->pb, 1, s->field_select[1][0]);
994 put_bits(&s->pb, 1, s->field_select[1][1]);
996 if(s->mv_dir & MV_DIR_FORWARD){
998 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
999 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1000 s->last_mv[0][i][0]= s->mv[0][i][0];
1001 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1005 if(s->mv_dir & MV_DIR_BACKWARD){
1007 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
1008 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1009 s->last_mv[1][i][0]= s->mv[1][i][0];
1010 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1017 if(interleaved_stats){
1018 s->mv_bits+= get_bits_diff(s);
1021 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1023 if(interleaved_stats){
1024 s->p_tex_bits+= get_bits_diff(s);
1027 }else{ /* s->pict_type==B_TYPE */
1028 cbp= get_p_cbp(s, block, motion_x, motion_y);
1030 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1031 /* check if the B frames can skip it too, as we must skip it if we skip here
1032 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1033 if(s->max_b_frames>0){
1040 if(x+16 > s->width) x= s->width-16;
1041 if(y+16 > s->height) y= s->height-16;
1043 offset= x + y*s->linesize;
1044 p_pic= s->new_picture.data[0] + offset;
1047 for(i=0; i<s->max_b_frames; i++){
1050 Picture *pic= s->reordered_input_picture[i+1];
1052 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1054 b_pic= pic->data[0] + offset;
1055 if(pic->type != FF_BUFFER_TYPE_SHARED)
1056 b_pic+= INPLACE_OFFSET;
1057 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1058 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1066 if(s->mb_skipped==1){
1067 /* skip macroblock */
1068 put_bits(&s->pb, 1, 1);
1070 if(interleaved_stats){
1080 put_bits(&s->pb, 1, 0); /* mb coded */
1084 if(s->mv_type==MV_TYPE_16X16){
1085 if(s->dquant) cbpc+= 8;
1087 inter_MCBPC_bits[cbpc],
1088 inter_MCBPC_code[cbpc]);
1090 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1092 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1094 if(!s->progressive_sequence){
1096 put_bits(pb2, 1, s->interlaced_dct);
1097 put_bits(pb2, 1, 0);
1100 if(interleaved_stats){
1101 s->misc_bits+= get_bits_diff(s);
1104 /* motion vectors: 16x16 mode */
1105 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1107 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1108 motion_y - pred_y, s->f_code);
1109 }else if(s->mv_type==MV_TYPE_FIELD){
1110 if(s->dquant) cbpc+= 8;
1112 inter_MCBPC_bits[cbpc],
1113 inter_MCBPC_code[cbpc]);
1115 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1117 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1119 assert(!s->progressive_sequence);
1121 put_bits(pb2, 1, s->interlaced_dct);
1122 put_bits(pb2, 1, 1);
1124 if(interleaved_stats){
1125 s->misc_bits+= get_bits_diff(s);
1128 /* motion vectors: 16x8 interlaced mode */
1129 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1132 put_bits(&s->pb, 1, s->field_select[0][0]);
1133 put_bits(&s->pb, 1, s->field_select[0][1]);
1135 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1136 s->mv[0][0][1] - pred_y, s->f_code);
1137 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1138 s->mv[0][1][1] - pred_y, s->f_code);
1140 assert(s->mv_type==MV_TYPE_8X8);
1142 inter_MCBPC_bits[cbpc+16],
1143 inter_MCBPC_code[cbpc+16]);
1144 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1146 if(!s->progressive_sequence){
1148 put_bits(pb2, 1, s->interlaced_dct);
1151 if(interleaved_stats){
1152 s->misc_bits+= get_bits_diff(s);
1156 /* motion vectors: 8x8 mode*/
1157 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1159 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1160 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1164 if(interleaved_stats){
1165 s->mv_bits+= get_bits_diff(s);
1168 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1170 if(interleaved_stats){
1171 s->p_tex_bits+= get_bits_diff(s);
1177 int dc_diff[6]; //dc values with the dc prediction subtracted
1178 int dir[6]; //prediction direction
1179 int zigzag_last_index[6];
1180 uint8_t *scan_table[6];
1184 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1187 if(s->flags & CODEC_FLAG_AC_PRED){
1188 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1190 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1193 scan_table[i]= s->intra_scantable.permutated;
1198 for (i = 0; i < 6; i++) {
1199 if (s->block_last_index[i] >= 1)
1200 cbp |= 1 << (5 - i);
1204 if (s->pict_type == I_TYPE) {
1205 if(s->dquant) cbpc+=4;
1207 intra_MCBPC_bits[cbpc],
1208 intra_MCBPC_code[cbpc]);
1210 if(s->dquant) cbpc+=8;
1211 put_bits(&s->pb, 1, 0); /* mb coded */
1213 inter_MCBPC_bits[cbpc + 4],
1214 inter_MCBPC_code[cbpc + 4]);
1216 put_bits(pb2, 1, s->ac_pred);
1218 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1220 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1222 if(!s->progressive_sequence){
1223 put_bits(dc_pb, 1, s->interlaced_dct);
1226 if(interleaved_stats){
1227 s->misc_bits+= get_bits_diff(s);
1230 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1232 if(interleaved_stats){
1233 s->i_tex_bits+= get_bits_diff(s);
1237 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1239 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1243 void h263_encode_mb(MpegEncContext * s,
1244 DCTELEM block[6][64],
1245 int motion_x, int motion_y)
1247 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1249 int16_t rec_intradc[6];
1251 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1252 const int dquant_code[5]= {1,0,9,2,3};
1254 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1257 cbp= get_p_cbp(s, block, motion_x, motion_y);
1259 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1260 /* skip macroblock */
1261 put_bits(&s->pb, 1, 1);
1262 if(interleaved_stats){
1270 put_bits(&s->pb, 1, 0); /* mb coded */
1274 if(s->alt_inter_vlc==0 || cbpc!=3)
1276 if(s->dquant) cbpc+= 8;
1277 if(s->mv_type==MV_TYPE_16X16){
1279 inter_MCBPC_bits[cbpc],
1280 inter_MCBPC_code[cbpc]);
1282 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1284 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1286 if(interleaved_stats){
1287 s->misc_bits+= get_bits_diff(s);
1290 /* motion vectors: 16x16 mode */
1291 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1294 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1295 motion_y - pred_y, 1);
1298 h263p_encode_umotion(s, motion_x - pred_x);
1299 h263p_encode_umotion(s, motion_y - pred_y);
1300 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1301 /* To prevent Start Code emulation */
1302 put_bits(&s->pb,1,1);
1306 inter_MCBPC_bits[cbpc+16],
1307 inter_MCBPC_code[cbpc+16]);
1308 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1310 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1312 if(interleaved_stats){
1313 s->misc_bits+= get_bits_diff(s);
1317 /* motion vectors: 8x8 mode*/
1318 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1320 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1321 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1323 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1324 motion_y - pred_y, 1);
1327 h263p_encode_umotion(s, motion_x - pred_x);
1328 h263p_encode_umotion(s, motion_y - pred_y);
1329 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1330 /* To prevent Start Code emulation */
1331 put_bits(&s->pb,1,1);
1336 if(interleaved_stats){
1337 s->mv_bits+= get_bits_diff(s);
1340 assert(s->mb_intra);
1345 for(i=0; i<6; i++) {
1346 int16_t level = block[i][0];
1349 if(i<4) scale= s->y_dc_scale;
1350 else scale= s->c_dc_scale;
1352 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1356 level = (level + (scale>>1))/scale;
1358 level = (level - (scale>>1))/scale;
1360 /* AIC can change CBP */
1361 if (level == 0 && s->block_last_index[i] == 0)
1362 s->block_last_index[i] = -1;
1364 if(!s->modified_quant){
1367 else if (level > 127)
1371 block[i][0] = level;
1372 /* Reconstruction */
1373 rec_intradc[i] = scale*level + pred_dc;
1375 rec_intradc[i] |= 1;
1376 //if ((rec_intradc[i] % 2) == 0)
1377 // rec_intradc[i]++;
1379 if (rec_intradc[i] < 0)
1381 else if (rec_intradc[i] > 2047)
1382 rec_intradc[i] = 2047;
1384 /* Update AC/DC tables */
1385 *dc_ptr[i] = rec_intradc[i];
1386 if (s->block_last_index[i] >= 0)
1387 cbp |= 1 << (5 - i);
1390 for(i=0; i<6; i++) {
1392 if (s->block_last_index[i] >= 1)
1393 cbp |= 1 << (5 - i);
1398 if (s->pict_type == I_TYPE) {
1399 if(s->dquant) cbpc+=4;
1401 intra_MCBPC_bits[cbpc],
1402 intra_MCBPC_code[cbpc]);
1404 if(s->dquant) cbpc+=8;
1405 put_bits(&s->pb, 1, 0); /* mb coded */
1407 inter_MCBPC_bits[cbpc + 4],
1408 inter_MCBPC_code[cbpc + 4]);
1411 /* XXX: currently, we do not try to use ac prediction */
1412 put_bits(&s->pb, 1, 0); /* no AC prediction */
1415 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1417 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1419 if(interleaved_stats){
1420 s->misc_bits+= get_bits_diff(s);
1424 for(i=0; i<6; i++) {
1425 /* encode each block */
1426 h263_encode_block(s, block[i], i);
1428 /* Update INTRADC for decoding */
1429 if (s->h263_aic && s->mb_intra) {
1430 block[i][0] = rec_intradc[i];
1435 if(interleaved_stats){
1437 s->p_tex_bits+= get_bits_diff(s);
1440 s->i_tex_bits+= get_bits_diff(s);
1447 void ff_h263_loop_filter(MpegEncContext * s){
1449 const int linesize = s->linesize;
1450 const int uvlinesize= s->uvlinesize;
1451 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1452 uint8_t *dest_y = s->dest[0];
1453 uint8_t *dest_cb= s->dest[1];
1454 uint8_t *dest_cr= s->dest[2];
1456 // if(s->pict_type==B_TYPE && !s->readable) return;
1462 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1464 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1465 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1470 int qp_dt, qp_t, qp_tc;
1472 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1475 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1483 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1484 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1485 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1487 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1488 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1492 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1495 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1498 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1501 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1502 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1503 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1504 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1510 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1511 if(s->mb_y + 1 == s->mb_height)
1512 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1517 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1520 qp_lc= s->current_picture.qscale_table[xy-1];
1523 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1524 if(s->mb_y + 1 == s->mb_height){
1525 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1526 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1527 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1528 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1534 #ifdef CONFIG_ENCODERS
1535 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1537 int x, y, wrap, a, c, pred_dc, scale;
1540 /* find prediction */
1542 x = 2 * s->mb_x + (n & 1);
1543 y = 2 * s->mb_y + ((n & 2) >> 1);
1544 wrap = s->b8_stride;
1545 dc_val = s->dc_val[0];
1546 scale = s->y_dc_scale;
1550 wrap = s->mb_stride;
1551 dc_val = s->dc_val[n - 4 + 1];
1552 scale = s->c_dc_scale;
1557 a = dc_val[(x - 1) + (y) * wrap];
1558 c = dc_val[(x) + (y - 1) * wrap];
1560 /* No prediction outside GOB boundary */
1561 if(s->first_slice_line && n!=3){
1563 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1566 /* just DC prediction */
1567 if (a != 1024 && c != 1024)
1568 pred_dc = (a + c) >> 1;
1574 /* we assume pred is positive */
1575 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1576 *dc_val_ptr = &dc_val[x + y * wrap];
1579 #endif /* CONFIG_ENCODERS */
1581 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1583 int x, y, wrap, a, c, pred_dc, scale, i;
1584 int16_t *dc_val, *ac_val, *ac_val1;
1586 /* find prediction */
1588 x = 2 * s->mb_x + (n & 1);
1589 y = 2 * s->mb_y + (n>> 1);
1590 wrap = s->b8_stride;
1591 dc_val = s->dc_val[0];
1592 ac_val = s->ac_val[0][0];
1593 scale = s->y_dc_scale;
1597 wrap = s->mb_stride;
1598 dc_val = s->dc_val[n - 4 + 1];
1599 ac_val = s->ac_val[n - 4 + 1][0];
1600 scale = s->c_dc_scale;
1603 ac_val += ((y) * wrap + (x)) * 16;
1609 a = dc_val[(x - 1) + (y) * wrap];
1610 c = dc_val[(x) + (y - 1) * wrap];
1612 /* No prediction outside GOB boundary */
1613 if(s->first_slice_line && n!=3){
1615 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1620 if (s->h263_aic_dir) {
1621 /* left prediction */
1625 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1630 /* top prediction */
1632 ac_val -= 16 * wrap;
1634 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1640 /* just DC prediction */
1641 if (a != 1024 && c != 1024)
1642 pred_dc = (a + c) >> 1;
1649 /* we assume pred is positive */
1650 block[0]=block[0]*scale + pred_dc;
1657 /* Update AC/DC tables */
1658 dc_val[(x) + (y) * wrap] = block[0];
1662 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1665 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1668 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1672 int16_t *A, *B, *C, (*mot_val)[2];
1673 static const int off[4]= {2, 1, 1, -1};
1675 wrap = s->b8_stride;
1676 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1679 /* special case for first (slice) line */
1680 if (s->first_slice_line && block<3) {
1681 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1682 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1683 if(block==0){ //most common case
1684 if(s->mb_x == s->resync_mb_x){ //rare
1686 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1687 C = mot_val[off[block] - wrap];
1692 *px = mid_pred(A[0], 0, C[0]);
1693 *py = mid_pred(A[1], 0, C[1]);
1700 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1701 C = mot_val[off[block] - wrap];
1702 *px = mid_pred(A[0], 0, C[0]);
1703 *py = mid_pred(A[1], 0, C[1]);
1708 }else{ /* block==2*/
1709 B = mot_val[ - wrap];
1710 C = mot_val[off[block] - wrap];
1711 if(s->mb_x == s->resync_mb_x) //rare
1714 *px = mid_pred(A[0], B[0], C[0]);
1715 *py = mid_pred(A[1], B[1], C[1]);
1718 B = mot_val[ - wrap];
1719 C = mot_val[off[block] - wrap];
1720 *px = mid_pred(A[0], B[0], C[0]);
1721 *py = mid_pred(A[1], B[1], C[1]);
1726 #ifdef CONFIG_ENCODERS
1727 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1729 int range, l, bit_size, sign, code, bits;
1734 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1736 bit_size = f_code - 1;
1737 range = 1 << bit_size;
1738 /* modulo encoding */
1739 l= INT_BIT - 6 - bit_size;
1742 val= (val^sign)-sign;
1746 code = (val >> bit_size) + 1;
1747 bits = val & (range - 1);
1749 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1751 put_bits(&s->pb, bit_size, bits);
1756 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1757 static void h263p_encode_umotion(MpegEncContext * s, int val)
1767 put_bits(&s->pb, 1, 1);
1769 put_bits(&s->pb, 3, 0);
1771 put_bits(&s->pb, 3, 2);
1774 sval = ((val < 0) ? (short)(-val):(short)val);
1777 while (temp_val != 0) {
1778 temp_val = temp_val >> 1;
1784 tcode = (sval & (1 << (i-1))) >> (i-1);
1785 tcode = (tcode << 1) | 1;
1786 code = (code << 2) | tcode;
1789 code = ((code << 1) | (val < 0)) << 1;
1790 put_bits(&s->pb, (2*n_bits)+1, code);
1791 //printf("\nVal = %d\tCode = %d", sval, code);
1795 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1800 if(mv_penalty==NULL)
1801 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1803 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1804 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1807 if(mv==0) len= mvtab[0][1];
1809 int val, bit_size, range, code;
1811 bit_size = f_code - 1;
1812 range = 1 << bit_size;
1818 code = (val >> bit_size) + 1;
1820 len= mvtab[code][1] + 1 + bit_size;
1822 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1826 mv_penalty[f_code][mv+MAX_MV]= len;
1830 for(f_code=MAX_FCODE; f_code>0; f_code--){
1831 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1832 fcode_tab[mv+MAX_MV]= f_code;
1836 for(mv=0; mv<MAX_MV*2+1; mv++){
1837 umv_fcode_tab[mv]= 1;
1842 #ifdef CONFIG_ENCODERS
1844 static void init_uni_dc_tab(void)
1846 int level, uni_code, uni_len;
1848 for(level=-256; level<256; level++){
1850 /* find number of bits */
1859 l= (-level) ^ ((1 << size) - 1);
1864 uni_code= DCtab_lum[size][0];
1865 uni_len = DCtab_lum[size][1];
1868 uni_code<<=size; uni_code|=l;
1871 uni_code<<=1; uni_code|=1;
1875 uni_DCtab_lum_bits[level+256]= uni_code;
1876 uni_DCtab_lum_len [level+256]= uni_len;
1879 uni_code= DCtab_chrom[size][0];
1880 uni_len = DCtab_chrom[size][1];
1883 uni_code<<=size; uni_code|=l;
1886 uni_code<<=1; uni_code|=1;
1890 uni_DCtab_chrom_bits[level+256]= uni_code;
1891 uni_DCtab_chrom_len [level+256]= uni_len;
1896 #endif //CONFIG_ENCODERS
1898 #ifdef CONFIG_ENCODERS
1899 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1900 int slevel, run, last;
1902 assert(MAX_LEVEL >= 64);
1903 assert(MAX_RUN >= 63);
1905 for(slevel=-64; slevel<64; slevel++){
1906 if(slevel==0) continue;
1907 for(run=0; run<64; run++){
1908 for(last=0; last<=1; last++){
1909 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1910 int level= slevel < 0 ? -slevel : slevel;
1911 int sign= slevel < 0 ? 1 : 0;
1912 int bits, len, code;
1915 len_tab[index]= 100;
1918 code= get_rl_index(rl, last, run, level);
1919 bits= rl->table_vlc[code][0];
1920 len= rl->table_vlc[code][1];
1921 bits=bits*2+sign; len++;
1923 if(code!=rl->n && len < len_tab[index]){
1924 bits_tab[index]= bits;
1925 len_tab [index]= len;
1929 bits= rl->table_vlc[rl->n][0];
1930 len= rl->table_vlc[rl->n][1];
1931 bits=bits*2; len++; //esc1
1932 level1= level - rl->max_level[last][run];
1934 code= get_rl_index(rl, last, run, level1);
1935 bits<<= rl->table_vlc[code][1];
1936 len += rl->table_vlc[code][1];
1937 bits += rl->table_vlc[code][0];
1938 bits=bits*2+sign; len++;
1940 if(code!=rl->n && len < len_tab[index]){
1941 bits_tab[index]= bits;
1942 len_tab [index]= len;
1948 bits= rl->table_vlc[rl->n][0];
1949 len= rl->table_vlc[rl->n][1];
1950 bits=bits*4+2; len+=2; //esc2
1951 run1 = run - rl->max_run[last][level] - 1;
1953 code= get_rl_index(rl, last, run1, level);
1954 bits<<= rl->table_vlc[code][1];
1955 len += rl->table_vlc[code][1];
1956 bits += rl->table_vlc[code][0];
1957 bits=bits*2+sign; len++;
1959 if(code!=rl->n && len < len_tab[index]){
1960 bits_tab[index]= bits;
1961 len_tab [index]= len;
1966 bits= rl->table_vlc[rl->n][0];
1967 len = rl->table_vlc[rl->n][1];
1968 bits=bits*4+3; len+=2; //esc3
1969 bits=bits*2+last; len++;
1970 bits=bits*64+run; len+=6;
1971 bits=bits*2+1; len++; //marker
1972 bits=bits*4096+(slevel&0xfff); len+=12;
1973 bits=bits*2+1; len++; //marker
1975 if(len < len_tab[index]){
1976 bits_tab[index]= bits;
1977 len_tab [index]= len;
1984 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1985 int slevel, run, last;
1987 assert(MAX_LEVEL >= 64);
1988 assert(MAX_RUN >= 63);
1990 for(slevel=-64; slevel<64; slevel++){
1991 if(slevel==0) continue;
1992 for(run=0; run<64; run++){
1993 for(last=0; last<=1; last++){
1994 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1995 int level= slevel < 0 ? -slevel : slevel;
1996 int sign= slevel < 0 ? 1 : 0;
1997 int bits, len, code;
1999 len_tab[index]= 100;
2002 code= get_rl_index(rl, last, run, level);
2003 bits= rl->table_vlc[code][0];
2004 len= rl->table_vlc[code][1];
2005 bits=bits*2+sign; len++;
2007 if(code!=rl->n && len < len_tab[index]){
2008 if(bits_tab) bits_tab[index]= bits;
2009 len_tab [index]= len;
2012 bits= rl->table_vlc[rl->n][0];
2013 len = rl->table_vlc[rl->n][1];
2014 bits=bits*2+last; len++;
2015 bits=bits*64+run; len+=6;
2016 bits=bits*256+(level&0xff); len+=8;
2018 if(len < len_tab[index]){
2019 if(bits_tab) bits_tab[index]= bits;
2020 len_tab [index]= len;
2027 void h263_encode_init(MpegEncContext *s)
2029 static int done = 0;
2036 init_rl(&rl_inter, 1);
2037 init_rl(&rl_intra, 1);
2038 init_rl(&rl_intra_aic, 1);
2040 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2041 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2043 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2044 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2046 init_mv_penalty_and_fcode(s);
2048 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2050 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2051 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2053 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2054 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2056 s->ac_esc_length= 7+1+6+8;
2058 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2059 switch(s->codec_id){
2060 case CODEC_ID_MPEG4:
2061 s->fcode_tab= fcode_tab;
2062 s->min_qcoeff= -2048;
2063 s->max_qcoeff= 2047;
2064 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2065 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2066 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2067 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2068 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2069 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2070 s->ac_esc_length= 7+2+1+6+1+12+1;
2071 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2072 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2074 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2076 s->avctx->extradata= av_malloc(1024);
2077 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2079 if(!(s->workaround_bugs & FF_BUG_MS))
2080 mpeg4_encode_visual_object_header(s);
2081 mpeg4_encode_vol_header(s, 0, 0);
2083 // ff_mpeg4_stuffing(&s->pb); ?
2084 flush_put_bits(&s->pb);
2085 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2089 case CODEC_ID_H263P:
2091 s->fcode_tab= umv_fcode_tab;
2092 if(s->modified_quant){
2093 s->min_qcoeff= -2047;
2094 s->max_qcoeff= 2047;
2096 s->min_qcoeff= -127;
2100 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2102 if (s->h263_flv > 1) {
2103 s->min_qcoeff= -1023;
2104 s->max_qcoeff= 1023;
2106 s->min_qcoeff= -127;
2109 s->y_dc_scale_table=
2110 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2112 default: //nothing needed - default table already set in mpegvideo.c
2113 s->min_qcoeff= -127;
2115 s->y_dc_scale_table=
2116 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2121 * encodes a 8x8 block.
2122 * @param block the 8x8 block
2123 * @param n block index (0-3 are luma, 4-5 are chroma)
2125 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2127 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2131 if (s->mb_intra && !s->h263_aic) {
2134 /* 255 cannot be represented, so we clamp */
2139 /* 0 cannot be represented also */
2140 else if (level < 1) {
2144 if (level == 128) //FIXME check rv10
2145 put_bits(&s->pb, 8, 0xff);
2147 put_bits(&s->pb, 8, level);
2151 if (s->h263_aic && s->mb_intra)
2154 if(s->alt_inter_vlc && !s->mb_intra){
2156 int inter_vlc_bits=0;
2160 last_index = s->block_last_index[n];
2161 last_non_zero = i - 1;
2162 for (; i <= last_index; i++) {
2163 j = s->intra_scantable.permutated[i];
2166 run = i - last_non_zero - 1;
2167 last = (i == last_index);
2169 if(level<0) level= -level;
2171 code = get_rl_index(rl, last, run, level);
2172 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2173 inter_vlc_bits += rl->table_vlc[code][1]+1;
2174 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2176 if (code == rl->n) {
2177 inter_vlc_bits += 1+6+8-1;
2179 if (aic_code == rl_intra_aic.n) {
2180 aic_vlc_bits += 1+6+8-1;
2181 wrong_pos += run + 1;
2183 wrong_pos += wrong_run[aic_code];
2188 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2194 last_index = s->block_last_index[n];
2195 last_non_zero = i - 1;
2196 for (; i <= last_index; i++) {
2197 j = s->intra_scantable.permutated[i];
2200 run = i - last_non_zero - 1;
2201 last = (i == last_index);
2208 code = get_rl_index(rl, last, run, level);
2209 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2210 if (code == rl->n) {
2211 if(s->h263_flv <= 1){
2212 put_bits(&s->pb, 1, last);
2213 put_bits(&s->pb, 6, run);
2215 assert(slevel != 0);
2218 put_bits(&s->pb, 8, slevel & 0xff);
2220 put_bits(&s->pb, 8, 128);
2221 put_bits(&s->pb, 5, slevel & 0x1f);
2222 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2225 if(level < 64) { // 7-bit level
2226 put_bits(&s->pb, 1, 0);
2227 put_bits(&s->pb, 1, last);
2228 put_bits(&s->pb, 6, run);
2230 put_bits(&s->pb, 7, slevel & 0x7f);
2233 put_bits(&s->pb, 1, 1);
2234 put_bits(&s->pb, 1, last);
2235 put_bits(&s->pb, 6, run);
2237 put_bits(&s->pb, 11, slevel & 0x7ff);
2241 put_bits(&s->pb, 1, sign);
2249 #ifdef CONFIG_ENCODERS
2251 /***************************************************/
2253 * add mpeg4 stuffing bits (01...1)
2255 void ff_mpeg4_stuffing(PutBitContext * pbc)
2258 put_bits(pbc, 1, 0);
2259 length= (-put_bits_count(pbc))&7;
2260 if(length) put_bits(pbc, length, (1<<length)-1);
2263 /* must be called before writing the header */
2264 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2265 int time_div, time_mod;
2267 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2268 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2270 time_div= s->time/s->avctx->time_base.den;
2271 time_mod= s->time%s->avctx->time_base.den;
2273 if(s->pict_type==B_TYPE){
2274 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2275 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2276 ff_mpeg4_init_direct_mv(s);
2278 s->last_time_base= s->time_base;
2279 s->time_base= time_div;
2280 s->pp_time= s->time - s->last_non_b_time;
2281 s->last_non_b_time= s->time;
2282 assert(picture_number==0 || s->pp_time > 0);
2286 static void mpeg4_encode_gop_header(MpegEncContext * s){
2287 int hours, minutes, seconds;
2290 put_bits(&s->pb, 16, 0);
2291 put_bits(&s->pb, 16, GOP_STARTCODE);
2293 time= s->current_picture_ptr->pts;
2294 if(s->reordered_input_picture[1])
2295 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2296 time= time*s->avctx->time_base.num;
2298 seconds= time/s->avctx->time_base.den;
2299 minutes= seconds/60; seconds %= 60;
2300 hours= minutes/60; minutes %= 60;
2303 put_bits(&s->pb, 5, hours);
2304 put_bits(&s->pb, 6, minutes);
2305 put_bits(&s->pb, 1, 1);
2306 put_bits(&s->pb, 6, seconds);
2308 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2309 put_bits(&s->pb, 1, 0); //broken link == NO
2311 s->last_time_base= time / s->avctx->time_base.den;
2313 ff_mpeg4_stuffing(&s->pb);
2316 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2317 int profile_and_level_indication;
2320 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2321 profile_and_level_indication = s->avctx->profile << 4;
2322 }else if(s->max_b_frames || s->quarter_sample){
2323 profile_and_level_indication= 0xF0; // adv simple
2325 profile_and_level_indication= 0x00; // simple
2328 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2329 profile_and_level_indication |= s->avctx->level;
2331 profile_and_level_indication |= 1; //level 1
2334 if(profile_and_level_indication>>4 == 0xF){
2342 put_bits(&s->pb, 16, 0);
2343 put_bits(&s->pb, 16, VOS_STARTCODE);
2345 put_bits(&s->pb, 8, profile_and_level_indication);
2347 put_bits(&s->pb, 16, 0);
2348 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2350 put_bits(&s->pb, 1, 1);
2351 put_bits(&s->pb, 4, vo_ver_id);
2352 put_bits(&s->pb, 3, 1); //priority
2354 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2356 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2358 ff_mpeg4_stuffing(&s->pb);
2361 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2365 if(s->max_b_frames || s->quarter_sample){
2367 s->vo_type= ADV_SIMPLE_VO_TYPE;
2370 s->vo_type= SIMPLE_VO_TYPE;
2373 put_bits(&s->pb, 16, 0);
2374 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2375 put_bits(&s->pb, 16, 0);
2376 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2378 put_bits(&s->pb, 1, 0); /* random access vol */
2379 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2380 if(s->workaround_bugs & FF_BUG_MS) {
2381 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2383 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2384 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2385 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2388 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2390 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2391 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2392 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2393 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2396 if(s->workaround_bugs & FF_BUG_MS) { //
2397 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2399 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2400 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2401 put_bits(&s->pb, 1, s->low_delay);
2402 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2405 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2406 put_bits(&s->pb, 1, 1); /* marker bit */
2408 put_bits(&s->pb, 16, s->avctx->time_base.den);
2409 if (s->time_increment_bits < 1)
2410 s->time_increment_bits = 1;
2411 put_bits(&s->pb, 1, 1); /* marker bit */
2412 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2413 put_bits(&s->pb, 1, 1); /* marker bit */
2414 put_bits(&s->pb, 13, s->width); /* vol width */
2415 put_bits(&s->pb, 1, 1); /* marker bit */
2416 put_bits(&s->pb, 13, s->height); /* vol height */
2417 put_bits(&s->pb, 1, 1); /* marker bit */
2418 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2419 put_bits(&s->pb, 1, 1); /* obmc disable */
2420 if (vo_ver_id == 1) {
2421 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2423 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2426 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2427 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2430 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2431 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2435 put_bits(&s->pb, 1, s->quarter_sample);
2436 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2437 s->resync_marker= s->rtp_mode;
2438 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2439 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2440 if(s->data_partitioning){
2441 put_bits(&s->pb, 1, 0); /* no rvlc */
2444 if (vo_ver_id != 1){
2445 put_bits(&s->pb, 1, 0); /* newpred */
2446 put_bits(&s->pb, 1, 0); /* reduced res vop */
2448 put_bits(&s->pb, 1, 0); /* scalability */
2450 ff_mpeg4_stuffing(&s->pb);
2453 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2454 put_bits(&s->pb, 16, 0);
2455 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2456 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2460 /* write mpeg4 VOP header */
2461 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2464 int time_div, time_mod;
2466 if(s->pict_type==I_TYPE){
2467 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2468 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2469 mpeg4_encode_visual_object_header(s);
2470 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2471 mpeg4_encode_vol_header(s, 0, 0);
2473 if(!(s->workaround_bugs & FF_BUG_MS))
2474 mpeg4_encode_gop_header(s);
2477 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2479 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2481 put_bits(&s->pb, 16, 0); /* vop header */
2482 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2483 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2486 time_div= s->time/s->avctx->time_base.den;
2487 time_mod= s->time%s->avctx->time_base.den;
2488 time_incr= time_div - s->last_time_base;
2489 assert(time_incr >= 0);
2491 put_bits(&s->pb, 1, 1);
2493 put_bits(&s->pb, 1, 0);
2495 put_bits(&s->pb, 1, 1); /* marker */
2496 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2497 put_bits(&s->pb, 1, 1); /* marker */
2498 put_bits(&s->pb, 1, 1); /* vop coded */
2499 if ( s->pict_type == P_TYPE
2500 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2501 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2503 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2504 if(!s->progressive_sequence){
2505 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2506 put_bits(&s->pb, 1, s->alternate_scan);
2508 //FIXME sprite stuff
2510 put_bits(&s->pb, 5, s->qscale);
2512 if (s->pict_type != I_TYPE)
2513 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2514 if (s->pict_type == B_TYPE)
2515 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2516 // printf("****frame %d\n", picture_number);
2519 #endif //CONFIG_ENCODERS
2522 * set qscale and update qscale dependant variables.
2524 void ff_set_qscale(MpegEncContext * s, int qscale)
2528 else if (qscale > 31)
2532 s->chroma_qscale= s->chroma_qscale_table[qscale];
2534 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2535 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2540 * encoding quantized level -> quantized diff
2541 * decoding quantized diff -> quantized level
2542 * @param n block index (0-3 are luma, 4-5 are chroma)
2543 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2545 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2547 int a, b, c, wrap, pred, scale, ret;
2550 /* find prediction */
2552 scale = s->y_dc_scale;
2554 scale = s->c_dc_scale;
2559 wrap= s->block_wrap[n];
2560 dc_val = s->dc_val[0] + s->block_index[n];
2566 b = dc_val[ - 1 - wrap];
2567 c = dc_val[ - wrap];
2569 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2570 if(s->first_slice_line && n!=3){
2572 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2574 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2575 if(n==0 || n==4 || n==5)
2579 if (abs(a - b) < abs(b - c)) {
2581 *dir_ptr = 1; /* top */
2584 *dir_ptr = 0; /* left */
2586 /* we assume pred is positive */
2587 pred = FASTDIV((pred + (scale >> 1)), scale);
2594 if(s->error_resilience>=3){
2596 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2599 if(level*scale > 2048 + scale){
2600 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2609 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2619 * @param n block index (0-3 are luma, 4-5 are chroma)
2620 * @param dir the ac prediction direction
2622 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2626 int16_t *ac_val, *ac_val1;
2627 int8_t * const qscale_table= s->current_picture.qscale_table;
2629 /* find prediction */
2630 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2634 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2635 /* left prediction */
2638 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2641 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2644 /* different qscale, we must rescale */
2646 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2650 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2651 /* top prediction */
2652 ac_val -= 16 * s->block_wrap[n];
2654 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2657 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2660 /* different qscale, we must rescale */
2662 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2669 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2673 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2677 #ifdef CONFIG_ENCODERS
2680 * encodes the dc value.
2681 * @param n block index (0-3 are luma, 4-5 are chroma)
2683 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2686 // if(level<-255 || level>255) printf("dc overflow\n");
2690 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2693 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2697 /* find number of bits */
2707 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2710 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2713 /* encode remaining bits */
2716 level = (-level) ^ ((1 << size) - 1);
2717 put_bits(&s->pb, size, level);
2719 put_bits(&s->pb, 1, 1);
2724 static inline int mpeg4_get_dc_length(int level, int n){
2726 return uni_DCtab_lum_len[level + 256];
2728 return uni_DCtab_chrom_len[level + 256];
2733 * encodes a 8x8 block
2734 * @param n block index (0-3 are luma, 4-5 are chroma)
2736 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2737 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2739 int i, last_non_zero;
2740 #if 0 //variables for the outcommented version
2741 int code, sign, last;
2746 const int last_index = s->block_last_index[n];
2748 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2749 /* mpeg4 based DC predictor */
2750 mpeg4_encode_dc(dc_pb, intra_dc, n);
2751 if(last_index<1) return;
2754 bits_tab= uni_mpeg4_intra_rl_bits;
2755 len_tab = uni_mpeg4_intra_rl_len;
2757 if(last_index<0) return;
2760 bits_tab= uni_mpeg4_inter_rl_bits;
2761 len_tab = uni_mpeg4_inter_rl_len;
2765 last_non_zero = i - 1;
2767 for (; i < last_index; i++) {
2768 int level = block[ scan_table[i] ];
2770 int run = i - last_non_zero - 1;
2772 if((level&(~127)) == 0){
2773 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2774 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2776 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);
2781 /*if(i<=last_index)*/{
2782 int level = block[ scan_table[i] ];
2783 int run = i - last_non_zero - 1;
2785 if((level&(~127)) == 0){
2786 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2787 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2789 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);
2793 for (; i <= last_index; i++) {
2794 const int slevel = block[ scan_table[i] ];
2797 int run = i - last_non_zero - 1;
2798 last = (i == last_index);
2805 code = get_rl_index(rl, last, run, level);
2806 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2807 if (code == rl->n) {
2809 level1 = level - rl->max_level[last][run];
2812 code = get_rl_index(rl, last, run, level1);
2813 if (code == rl->n) {
2815 put_bits(ac_pb, 1, 1);
2816 if (level > MAX_LEVEL)
2818 run1 = run - rl->max_run[last][level] - 1;
2821 code = get_rl_index(rl, last, run1, level);
2822 if (code == rl->n) {
2825 put_bits(ac_pb, 1, 1);
2826 put_bits(ac_pb, 1, last);
2827 put_bits(ac_pb, 6, run);
2828 put_bits(ac_pb, 1, 1);
2829 put_bits(ac_pb, 12, slevel & 0xfff);
2830 put_bits(ac_pb, 1, 1);
2833 put_bits(ac_pb, 1, 0);
2834 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2835 put_bits(ac_pb, 1, sign);
2839 put_bits(ac_pb, 1, 0);
2840 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2841 put_bits(ac_pb, 1, sign);
2844 put_bits(ac_pb, 1, sign);
2852 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2853 uint8_t *scan_table)
2855 int i, last_non_zero;
2858 const int last_index = s->block_last_index[n];
2861 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2862 /* mpeg4 based DC predictor */
2863 len += mpeg4_get_dc_length(intra_dc, n);
2864 if(last_index<1) return len;
2867 len_tab = uni_mpeg4_intra_rl_len;
2869 if(last_index<0) return 0;
2872 len_tab = uni_mpeg4_inter_rl_len;
2876 last_non_zero = i - 1;
2877 for (; i < last_index; i++) {
2878 int level = block[ scan_table[i] ];
2880 int run = i - last_non_zero - 1;
2882 if((level&(~127)) == 0){
2883 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2884 len += len_tab[index];
2886 len += 7+2+1+6+1+12+1;
2891 /*if(i<=last_index)*/{
2892 int level = block[ scan_table[i] ];
2893 int run = i - last_non_zero - 1;
2895 if((level&(~127)) == 0){
2896 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2897 len += len_tab[index];
2899 len += 7+2+1+6+1+12+1;
2909 /***********************************************/
2912 static VLC intra_MCBPC_vlc;
2913 static VLC inter_MCBPC_vlc;
2914 static VLC cbpy_vlc;
2916 static VLC dc_lum, dc_chrom;
2917 static VLC sprite_trajectory;
2918 static VLC mb_type_b_vlc;
2919 static VLC h263_mbtype_b_vlc;
2920 static VLC cbpc_b_vlc;
2922 void init_vlc_rl(RLTable *rl, int use_static)
2926 /* Return if static table is already initialized */
2927 if(use_static && rl->rl_vlc[0])
2930 init_vlc(&rl->vlc, 9, rl->n + 1,
2931 &rl->table_vlc[0][1], 4, 2,
2932 &rl->table_vlc[0][0], 4, 2, use_static);
2935 for(q=0; q<32; q++){
2944 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2946 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2947 for(i=0; i<rl->vlc.table_size; i++){
2948 int code= rl->vlc.table[i][0];
2949 int len = rl->vlc.table[i][1];
2952 if(len==0){ // illegal code
2955 }else if(len<0){ //more bits needed
2959 if(code==rl->n){ //esc
2963 run= rl->table_run [code] + 1;
2964 level= rl->table_level[code] * qmul + qadd;
2965 if(code >= rl->last) run+=192;
2968 rl->rl_vlc[q][i].len= len;
2969 rl->rl_vlc[q][i].level= level;
2970 rl->rl_vlc[q][i].run= run;
2977 /* XXX: find a better solution to handle static init */
2978 void h263_decode_init_vlc(MpegEncContext *s)
2980 static int done = 0;
2985 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2986 intra_MCBPC_bits, 1, 1,
2987 intra_MCBPC_code, 1, 1, 1);
2988 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2989 inter_MCBPC_bits, 1, 1,
2990 inter_MCBPC_code, 1, 1, 1);
2991 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2992 &cbpy_tab[0][1], 2, 1,
2993 &cbpy_tab[0][0], 2, 1, 1);
2994 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2996 &mvtab[0][0], 2, 1, 1);
2997 init_rl(&rl_inter, 1);
2998 init_rl(&rl_intra, 1);
2999 init_rl(&rvlc_rl_inter, 1);
3000 init_rl(&rvlc_rl_intra, 1);
3001 init_rl(&rl_intra_aic, 1);
3002 init_vlc_rl(&rl_inter, 1);
3003 init_vlc_rl(&rl_intra, 1);
3004 init_vlc_rl(&rvlc_rl_inter, 1);
3005 init_vlc_rl(&rvlc_rl_intra, 1);
3006 init_vlc_rl(&rl_intra_aic, 1);
3007 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
3008 &DCtab_lum[0][1], 2, 1,
3009 &DCtab_lum[0][0], 2, 1, 1);
3010 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
3011 &DCtab_chrom[0][1], 2, 1,
3012 &DCtab_chrom[0][0], 2, 1, 1);
3013 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
3014 &sprite_trajectory_tab[0][1], 4, 2,
3015 &sprite_trajectory_tab[0][0], 4, 2, 1);
3016 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3017 &mb_type_b_tab[0][1], 2, 1,
3018 &mb_type_b_tab[0][0], 2, 1, 1);
3019 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3020 &h263_mbtype_b_tab[0][1], 2, 1,
3021 &h263_mbtype_b_tab[0][0], 2, 1, 1);
3022 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3023 &cbpc_b_tab[0][1], 2, 1,
3024 &cbpc_b_tab[0][0], 2, 1, 1);
3029 * Get the GOB height based on picture height.
3031 int ff_h263_get_gob_height(MpegEncContext *s){
3032 if (s->height <= 400)
3034 else if (s->height <= 800)
3040 int ff_h263_decode_mba(MpegEncContext *s)
3045 if(s->mb_num-1 <= ff_mba_max[i]) break;
3047 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3048 s->mb_x= mb_pos % s->mb_width;
3049 s->mb_y= mb_pos / s->mb_width;
3054 void ff_h263_encode_mba(MpegEncContext *s)
3059 if(s->mb_num-1 <= ff_mba_max[i]) break;
3061 mb_pos= s->mb_x + s->mb_width*s->mb_y;
3062 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3066 * decodes the group of blocks header or slice header.
3067 * @return <0 if an error occured
3069 static int h263_decode_gob_header(MpegEncContext *s)
3071 unsigned int val, gfid, gob_number;
3074 /* Check for GOB Start Code */
3075 val = show_bits(&s->gb, 16);
3079 /* We have a GBSC probably with GSTUFF */
3080 skip_bits(&s->gb, 16); /* Drop the zeros */
3081 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3082 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3083 for(;left>13; left--){
3084 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3089 if(s->h263_slice_structured){
3090 if(get_bits1(&s->gb)==0)
3093 ff_h263_decode_mba(s);
3095 if(s->mb_num > 1583)
3096 if(get_bits1(&s->gb)==0)
3099 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3100 if(get_bits1(&s->gb)==0)
3102 gfid = get_bits(&s->gb, 2); /* GFID */
3104 gob_number = get_bits(&s->gb, 5); /* GN */
3106 s->mb_y= s->gob_index* gob_number;
3107 gfid = get_bits(&s->gb, 2); /* GFID */
3108 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3111 if(s->mb_y >= s->mb_height)
3120 static inline void memsetw(short *tab, int val, int n)
3127 #ifdef CONFIG_ENCODERS
3129 void ff_mpeg4_init_partitions(MpegEncContext *s)
3131 uint8_t *start= pbBufPtr(&s->pb);
3132 uint8_t *end= s->pb.buf_end;
3133 int size= end - start;
3134 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3135 int tex_size= (size - 2*pb_size)&(~3);
3137 set_put_bits_buffer_size(&s->pb, pb_size);
3138 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3139 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3142 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3144 const int pb2_len = put_bits_count(&s->pb2 );
3145 const int tex_pb_len= put_bits_count(&s->tex_pb);
3146 const int bits= put_bits_count(&s->pb);
3148 if(s->pict_type==I_TYPE){
3149 put_bits(&s->pb, 19, DC_MARKER);
3150 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3151 s->i_tex_bits+= tex_pb_len;
3153 put_bits(&s->pb, 17, MOTION_MARKER);
3154 s->misc_bits+=17 + pb2_len;
3155 s->mv_bits+= bits - s->last_bits;
3156 s->p_tex_bits+= tex_pb_len;
3159 flush_put_bits(&s->pb2);
3160 flush_put_bits(&s->tex_pb);
3162 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3163 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3164 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3165 s->last_bits= put_bits_count(&s->pb);
3168 #endif //CONFIG_ENCODERS
3170 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3171 switch(s->pict_type){
3176 return s->f_code+15;
3178 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3184 #ifdef CONFIG_ENCODERS
3186 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3188 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3190 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3191 put_bits(&s->pb, 1, 1);
3193 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3194 put_bits(&s->pb, s->quant_precision, s->qscale);
3195 put_bits(&s->pb, 1, 0); /* no HEC */
3198 #endif //CONFIG_ENCODERS
3201 * check if the next stuff is a resync marker or the end.
3204 static inline int mpeg4_is_resync(MpegEncContext *s){
3205 int bits_count= get_bits_count(&s->gb);
3206 int v= show_bits(&s->gb, 16);
3208 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3213 if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3215 skip_bits(&s->gb, 8+s->pict_type);
3216 bits_count+= 8+s->pict_type;
3217 v= show_bits(&s->gb, 16);
3220 if(bits_count + 8 >= s->gb.size_in_bits){
3222 v|= 0x7F >> (7-(bits_count&7));
3227 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3229 GetBitContext gb= s->gb;
3231 skip_bits(&s->gb, 1);
3232 align_get_bits(&s->gb);
3234 for(len=0; len<32; len++){
3235 if(get_bits1(&s->gb)) break;
3240 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3248 * decodes the next video packet.
3249 * @return <0 if something went wrong
3251 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3253 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3254 int header_extension=0, mb_num, len;
3256 /* is there enough space left for a video packet + header */
3257 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3259 for(len=0; len<32; len++){
3260 if(get_bits1(&s->gb)) break;
3263 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3264 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3268 if(s->shape != RECT_SHAPE){
3269 header_extension= get_bits1(&s->gb);
3270 //FIXME more stuff here
3273 mb_num= get_bits(&s->gb, mb_num_bits);
3274 if(mb_num>=s->mb_num){
3275 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3278 if(s->pict_type == B_TYPE){
3279 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3280 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3283 s->mb_x= mb_num % s->mb_width;
3284 s->mb_y= mb_num / s->mb_width;
3286 if(s->shape != BIN_ONLY_SHAPE){
3287 int qscale= get_bits(&s->gb, s->quant_precision);
3289 s->chroma_qscale=s->qscale= qscale;
3292 if(s->shape == RECT_SHAPE){
3293 header_extension= get_bits1(&s->gb);
3295 if(header_extension){
3299 while (get_bits1(&s->gb) != 0)
3302 check_marker(&s->gb, "before time_increment in video packed header");
3303 time_increment= get_bits(&s->gb, s->time_increment_bits);
3304 check_marker(&s->gb, "before vop_coding_type in video packed header");
3306 skip_bits(&s->gb, 2); /* vop coding type */
3307 //FIXME not rect stuff here
3309 if(s->shape != BIN_ONLY_SHAPE){
3310 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3311 //FIXME don't just ignore everything
3312 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3313 mpeg4_decode_sprite_trajectory(s, &s->gb);
3314 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3317 //FIXME reduced res stuff here
3319 if (s->pict_type != I_TYPE) {
3320 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3322 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3325 if (s->pict_type == B_TYPE) {
3326 int b_code = get_bits(&s->gb, 3);
3328 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3333 //FIXME new-pred stuff
3335 //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));
3340 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3342 int c_wrap, c_xy, l_wrap, l_xy;
3344 l_wrap= s->b8_stride;
3345 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3346 c_wrap= s->mb_stride;
3347 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3351 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3352 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3353 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3357 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3358 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3359 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3362 // we can't clear the MVs as they might be needed by a b frame
3363 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3364 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3365 s->last_mv[0][0][0]=
3366 s->last_mv[0][0][1]=
3367 s->last_mv[1][0][0]=
3368 s->last_mv[1][0][1]= 0;
3372 * decodes the group of blocks / video packet header.
3373 * @return <0 if no resync found
3375 int ff_h263_resync(MpegEncContext *s){
3378 if(s->codec_id==CODEC_ID_MPEG4){
3380 align_get_bits(&s->gb);
3383 if(show_bits(&s->gb, 16)==0){
3384 if(s->codec_id==CODEC_ID_MPEG4)
3385 ret= mpeg4_decode_video_packet_header(s);
3387 ret= h263_decode_gob_header(s);
3391 //ok, it's not where its supposed to be ...
3392 s->gb= s->last_resync_gb;
3393 align_get_bits(&s->gb);
3394 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3396 for(;left>16+1+5+5; left-=8){
3397 if(show_bits(&s->gb, 16)==0){
3398 GetBitContext bak= s->gb;
3400 if(s->codec_id==CODEC_ID_MPEG4)
3401 ret= mpeg4_decode_video_packet_header(s);
3403 ret= h263_decode_gob_header(s);
3409 skip_bits(&s->gb, 8);
3416 * gets the average motion vector for a GMC MB.
3417 * @param n either 0 for the x component or 1 for y
3418 * @returns the average MV for a GMC MB
3420 static inline int get_amv(MpegEncContext *s, int n){
3421 int x, y, mb_v, sum, dx, dy, shift;
3422 int len = 1 << (s->f_code + 4);
3423 const int a= s->sprite_warping_accuracy;
3425 if(s->workaround_bugs & FF_BUG_AMV)
3426 len >>= s->quarter_sample;
3428 if(s->real_sprite_warping_points==1){
3429 if(s->divx_version==500 && s->divx_build==413)
3430 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3432 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3434 dx= s->sprite_delta[n][0];
3435 dy= s->sprite_delta[n][1];
3436 shift= s->sprite_shift[0];
3437 if(n) dy -= 1<<(shift + a + 1);
3438 else dx -= 1<<(shift + a + 1);
3439 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3442 for(y=0; y<16; y++){
3446 //XXX FIXME optimize
3447 for(x=0; x<16; x++){
3452 sum= RSHIFT(sum, a+8-s->quarter_sample);
3455 if (sum < -len) sum= -len;
3456 else if (sum >= len) sum= len-1;
3462 * decodes first partition.
3463 * @return number of MBs decoded or <0 if an error occured
3465 static int mpeg4_decode_partition_a(MpegEncContext *s){
3467 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3469 /* decode first partition */
3471 s->first_slice_line=1;
3472 for(; s->mb_y<s->mb_height; s->mb_y++){
3473 ff_init_block_index(s);
3474 for(; s->mb_x<s->mb_width; s->mb_x++){
3475 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3480 ff_update_block_index(s);
3481 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3482 s->first_slice_line=0;
3484 if(s->pict_type==I_TYPE){
3488 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3492 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3494 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3499 s->cbp_table[xy]= cbpc & 3;
3500 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3504 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3506 s->current_picture.qscale_table[xy]= s->qscale;
3508 s->mbintra_table[xy]= 1;
3511 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3513 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3517 if(dc_pred_dir) dir|=1;
3519 s->pred_dir_table[xy]= dir;
3520 }else{ /* P/S_TYPE */
3521 int mx, my, pred_x, pred_y, bits;
3522 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3523 const int stride= s->b8_stride*2;
3526 bits= show_bits(&s->gb, 17);
3527 if(bits==MOTION_MARKER){
3533 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3534 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3538 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3541 mot_val[0 ]= mot_val[2 ]=
3542 mot_val[0+stride]= mot_val[2+stride]= mx;
3543 mot_val[1 ]= mot_val[3 ]=
3544 mot_val[1+stride]= mot_val[3+stride]= my;
3546 if(s->mbintra_table[xy])
3547 ff_clean_intra_table_entries(s);
3551 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3553 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3559 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3561 s->mb_intra = ((cbpc & 4) != 0);
3564 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3565 s->mbintra_table[xy]= 1;
3566 mot_val[0 ]= mot_val[2 ]=
3567 mot_val[0+stride]= mot_val[2+stride]= 0;
3568 mot_val[1 ]= mot_val[3 ]=
3569 mot_val[1+stride]= mot_val[3+stride]= 0;
3571 if(s->mbintra_table[xy])
3572 ff_clean_intra_table_entries(s);
3574 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3575 s->mcsel= get_bits1(&s->gb);
3578 if ((cbpc & 16) == 0) {
3579 /* 16x16 motion prediction */
3581 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3583 mx = h263_decode_motion(s, pred_x, s->f_code);
3587 my = h263_decode_motion(s, pred_y, s->f_code);
3590 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3594 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3597 mot_val[0 ]= mot_val[2 ] =
3598 mot_val[0+stride]= mot_val[2+stride]= mx;
3599 mot_val[1 ]= mot_val[3 ]=
3600 mot_val[1+stride]= mot_val[3+stride]= my;
3603 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3605 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3606 mx = h263_decode_motion(s, pred_x, s->f_code);
3610 my = h263_decode_motion(s, pred_y, s->f_code);
3627 * decode second partition.
3628 * @return <0 if an error occured
3630 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3632 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3634 s->mb_x= s->resync_mb_x;
3635 s->first_slice_line=1;
3636 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3637 ff_init_block_index(s);
3638 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3639 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3642 ff_update_block_index(s);
3643 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3644 s->first_slice_line=0;
3646 if(s->pict_type==I_TYPE){
3647 int ac_pred= get_bits1(&s->gb);
3648 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3650 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3654 s->cbp_table[xy]|= cbpy<<2;
3655 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3656 }else{ /* P || S_TYPE */
3657 if(IS_INTRA(s->current_picture.mb_type[xy])){
3659 int ac_pred = get_bits1(&s->gb);
3660 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3663 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3667 if(s->cbp_table[xy] & 8) {
3668 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3670 s->current_picture.qscale_table[xy]= s->qscale;
3674 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3676 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3680 if(dc_pred_dir) dir|=1;
3682 s->cbp_table[xy]&= 3; //remove dquant
3683 s->cbp_table[xy]|= cbpy<<2;
3684 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3685 s->pred_dir_table[xy]= dir;
3686 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3687 s->current_picture.qscale_table[xy]= s->qscale;
3688 s->cbp_table[xy]= 0;
3690 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3693 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3697 if(s->cbp_table[xy] & 8) {
3698 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3700 s->current_picture.qscale_table[xy]= s->qscale;
3702 s->cbp_table[xy]&= 3; //remove dquant
3703 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3707 if(mb_num >= mb_count) return 0;
3714 * decodes the first & second partition
3715 * @return <0 if error (and sets error type in the error_status_table)
3717 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3720 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3721 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3723 mb_num= mpeg4_decode_partition_a(s);
3725 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3729 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3730 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3731 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3735 s->mb_num_left= mb_num;
3737 if(s->pict_type==I_TYPE){
3738 while(show_bits(&s->gb, 9) == 1)
3739 skip_bits(&s->gb, 9);
3740 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3741 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3745 while(show_bits(&s->gb, 10) == 1)
3746 skip_bits(&s->gb, 10);
3747 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3748 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3752 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3754 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3755 if(s->pict_type==P_TYPE)
3756 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3759 if(s->pict_type==P_TYPE)
3760 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3767 * decode partition C of one MB.
3768 * @return <0 if an error occured
3770 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3773 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3775 mb_type= s->current_picture.mb_type[xy];
3776 cbp = s->cbp_table[xy];
3778 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3780 if(s->current_picture.qscale_table[xy] != s->qscale){
3781 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3784 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3787 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3788 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3790 s->mb_intra = IS_INTRA(mb_type);
3792 if (IS_SKIP(mb_type)) {
3795 s->block_last_index[i] = -1;
3796 s->mv_dir = MV_DIR_FORWARD;
3797 s->mv_type = MV_TYPE_16X16;
3798 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3805 }else if(s->mb_intra){
3806 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3807 }else if(!s->mb_intra){
3808 // s->mcsel= 0; //FIXME do we need to init that
3810 s->mv_dir = MV_DIR_FORWARD;
3811 if (IS_8X8(mb_type)) {
3812 s->mv_type = MV_TYPE_8X8;
3814 s->mv_type = MV_TYPE_16X16;
3817 } else { /* I-Frame */
3819 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3822 if (!IS_SKIP(mb_type)) {
3824 s->dsp.clear_blocks(s->block[0]);
3825 /* decode each block */
3826 for (i = 0; i < 6; i++) {
3827 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3828 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3835 /* per-MB end of slice check */
3837 if(--s->mb_num_left <= 0){
3838 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3839 if(mpeg4_is_resync(s))
3844 if(mpeg4_is_resync(s)){
3845 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3846 if(s->cbp_table[xy+delta])
3854 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3856 static void preview_obmc(MpegEncContext *s){
3857 GetBitContext gb= s->gb;
3859 int cbpc, i, pred_x, pred_y, mx, my;
3861 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3862 const int stride= s->b8_stride*2;
3865 s->block_index[i]+= 2;
3867 s->block_index[i]+= 1;
3870 assert(s->pict_type == P_TYPE);
3873 if (get_bits1(&s->gb)) {
3875 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3876 mot_val[0 ]= mot_val[2 ]=
3877 mot_val[0+stride]= mot_val[2+stride]= 0;
3878 mot_val[1 ]= mot_val[3 ]=
3879 mot_val[1+stride]= mot_val[3+stride]= 0;
3881 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3884 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3888 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3890 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3892 if(s->modified_quant){
3893 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3894 else skip_bits(&s->gb, 5);
3896 skip_bits(&s->gb, 2);
3899 if ((cbpc & 16) == 0) {
3900 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3901 /* 16x16 motion prediction */
3902 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3904 mx = h263p_decode_umotion(s, pred_x);
3906 mx = h263_decode_motion(s, pred_x, 1);
3909 my = h263p_decode_umotion(s, pred_y);
3911 my = h263_decode_motion(s, pred_y, 1);
3913 mot_val[0 ]= mot_val[2 ]=
3914 mot_val[0+stride]= mot_val[2+stride]= mx;
3915 mot_val[1 ]= mot_val[3 ]=
3916 mot_val[1+stride]= mot_val[3+stride]= my;
3918 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3920 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3922 mx = h263p_decode_umotion(s, pred_x);
3924 mx = h263_decode_motion(s, pred_x, 1);
3927 my = h263p_decode_umotion(s, pred_y);
3929 my = h263_decode_motion(s, pred_y, 1);
3930 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3931 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3940 s->block_index[i]-= 2;
3942 s->block_index[i]-= 1;
3948 static void h263_decode_dquant(MpegEncContext *s){
3949 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3951 if(s->modified_quant){
3952 if(get_bits1(&s->gb))
3953 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3955 s->qscale= get_bits(&s->gb, 5);
3957 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3958 ff_set_qscale(s, s->qscale);
3961 int ff_h263_decode_mb(MpegEncContext *s,
3962 DCTELEM block[6][64])
3964 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3966 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3968 assert(!s->h263_pred);
3970 if (s->pict_type == P_TYPE) {
3972 if (get_bits1(&s->gb)) {
3976 s->block_last_index[i] = -1;
3977 s->mv_dir = MV_DIR_FORWARD;
3978 s->mv_type = MV_TYPE_16X16;
3979 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3982 s->mb_skipped = !(s->obmc | s->loop_filter);
3985 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3986 //fprintf(stderr, "\tCBPC: %d", cbpc);
3988 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3993 s->dsp.clear_blocks(s->block[0]);
3996 s->mb_intra = ((cbpc & 4) != 0);
3997 if (s->mb_intra) goto intra;
3999 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4001 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4004 cbp = (cbpc & 3) | (cbpy << 2);
4006 h263_decode_dquant(s);
4009 s->mv_dir = MV_DIR_FORWARD;
4010 if ((cbpc & 16) == 0) {
4011 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4012 /* 16x16 motion prediction */
4013 s->mv_type = MV_TYPE_16X16;
4014 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4016 mx = h263p_decode_umotion(s, pred_x);
4018 mx = h263_decode_motion(s, pred_x, 1);
4024 my = h263p_decode_umotion(s, pred_y);
4026 my = h263_decode_motion(s, pred_y, 1);
4030 s->mv[0][0][0] = mx;
4031 s->mv[0][0][1] = my;
4033 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4034 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4036 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4037 s->mv_type = MV_TYPE_8X8;
4039 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4041 mx = h263p_decode_umotion(s, pred_x);
4043 mx = h263_decode_motion(s, pred_x, 1);
4048 my = h263p_decode_umotion(s, pred_y);
4050 my = h263_decode_motion(s, pred_y, 1);
4053 s->mv[0][i][0] = mx;
4054 s->mv[0][i][1] = my;
4055 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4056 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4062 /* decode each block */
4063 for (i = 0; i < 6; i++) {
4064 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4070 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4073 } else if(s->pict_type==B_TYPE) {
4075 const int stride= s->b8_stride;
4076 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4077 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4078 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4081 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4082 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4083 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4084 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4087 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4089 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4093 mb_type= h263_mb_type_b_map[ mb_type ];
4096 s->mb_intra = IS_INTRA(mb_type);
4097 if(HAS_CBP(mb_type)){
4098 s->dsp.clear_blocks(s->block[0]);
4099 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4101 dquant = IS_QUANT(mb_type);
4105 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4108 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4112 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4115 cbp = (cbpc & 3) | (cbpy << 2);
4119 assert(!s->mb_intra);
4121 if(IS_QUANT(mb_type)){
4122 h263_decode_dquant(s);
4125 if(IS_DIRECT(mb_type)){
4126 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4127 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4130 s->mv_type= MV_TYPE_16X16;
4133 if(USES_LIST(mb_type, 0)){
4134 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4135 s->mv_dir = MV_DIR_FORWARD;
4137 mx = h263_decode_motion(s, mx, 1);
4138 my = h263_decode_motion(s, my, 1);
4140 s->mv[0][0][0] = mx;
4141 s->mv[0][0][1] = my;
4142 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4143 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4146 if(USES_LIST(mb_type, 1)){
4147 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4148 s->mv_dir |= MV_DIR_BACKWARD;
4150 mx = h263_decode_motion(s, mx, 1);
4151 my = h263_decode_motion(s, my, 1);
4153 s->mv[1][0][0] = mx;
4154 s->mv[1][0][1] = my;
4155 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4156 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4160 s->current_picture.mb_type[xy]= mb_type;
4162 /* decode each block */
4163 for (i = 0; i < 6; i++) {
4164 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4168 } else { /* I-Frame */
4170 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4172 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4177 s->dsp.clear_blocks(s->block[0]);
4182 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4184 s->ac_pred = get_bits1(&s->gb);
4186 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4188 s->h263_aic_dir = get_bits1(&s->gb);
4193 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4195 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4198 cbp = (cbpc & 3) | (cbpy << 2);
4200 h263_decode_dquant(s);
4203 /* decode each block */
4204 for (i = 0; i < 6; i++) {
4205 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4212 /* per-MB end of slice check */
4214 int v= show_bits(&s->gb, 16);
4216 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4217 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4227 int ff_mpeg4_decode_mb(MpegEncContext *s,
4228 DCTELEM block[6][64])
4230 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4232 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4233 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4235 assert(s->h263_pred);
4237 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4239 if (get_bits1(&s->gb)) {
4243 s->block_last_index[i] = -1;
4244 s->mv_dir = MV_DIR_FORWARD;
4245 s->mv_type = MV_TYPE_16X16;
4246 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4247 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4249 s->mv[0][0][0]= get_amv(s, 0);
4250 s->mv[0][0][1]= get_amv(s, 1);
4254 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4262 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4263 //fprintf(stderr, "\tCBPC: %d", cbpc);
4265 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4270 s->dsp.clear_blocks(s->block[0]);
4272 s->mb_intra = ((cbpc & 4) != 0);
4273 if (s->mb_intra) goto intra;
4275 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4276 s->mcsel= get_bits1(&s->gb);
4278 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4280 cbp = (cbpc & 3) | (cbpy << 2);
4282 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4284 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4285 s->interlaced_dct= get_bits1(&s->gb);
4287 s->mv_dir = MV_DIR_FORWARD;
4288 if ((cbpc & 16) == 0) {
4290 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4291 /* 16x16 global motion prediction */
4292 s->mv_type = MV_TYPE_16X16;
4295 s->mv[0][0][0] = mx;
4296 s->mv[0][0][1] = my;
4297 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4298 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4299 /* 16x8 field motion prediction */
4300 s->mv_type= MV_TYPE_FIELD;
4302 s->field_select[0][0]= get_bits1(&s->gb);
4303 s->field_select[0][1]= get_bits1(&s->gb);
4305 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4308 mx = h263_decode_motion(s, pred_x, s->f_code);
4312 my = h263_decode_motion(s, pred_y/2, s->f_code);
4316 s->mv[0][i][0] = mx;
4317 s->mv[0][i][1] = my;
4320 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4321 /* 16x16 motion prediction */
4322 s->mv_type = MV_TYPE_16X16;
4323 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4324 mx = h263_decode_motion(s, pred_x, s->f_code);
4329 my = h263_decode_motion(s, pred_y, s->f_code);
4333 s->mv[0][0][0] = mx;
4334 s->mv[0][0][1] = my;
4337 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4338 s->mv_type = MV_TYPE_8X8;
4340 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4341 mx = h263_decode_motion(s, pred_x, s->f_code);
4345 my = h263_decode_motion(s, pred_y, s->f_code);
4348 s->mv[0][i][0] = mx;
4349 s->mv[0][i][1] = my;
4354 } else if(s->pict_type==B_TYPE) {
4355 int modb1; // first bit of modb
4356 int modb2; // second bit of modb
4359 s->mb_intra = 0; //B-frames never contain intra blocks
4360 s->mcsel=0; // ... true gmc blocks
4364 s->last_mv[i][0][0]=
4365 s->last_mv[i][0][1]=
4366 s->last_mv[i][1][0]=
4367 s->last_mv[i][1][1]= 0;
4371 /* if we skipped it in the future P Frame than skip it now too */
4372 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4377 s->block_last_index[i] = -1;
4379 s->mv_dir = MV_DIR_FORWARD;
4380 s->mv_type = MV_TYPE_16X16;
4385 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4389 modb1= get_bits1(&s->gb);
4391 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4394 modb2= get_bits1(&s->gb);
4395 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4397 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4400 mb_type= mb_type_b_map[ mb_type ];
4403 s->dsp.clear_blocks(s->block[0]);
4404 cbp= get_bits(&s->gb, 6);
4407 if ((!IS_DIRECT(mb_type)) && cbp) {
4408 if(get_bits1(&s->gb)){
4409 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4413 if(!s->progressive_sequence){
4415 s->interlaced_dct= get_bits1(&s->gb);
4417 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4418 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4419 mb_type &= ~MB_TYPE_16x16;
4421 if(USES_LIST(mb_type, 0)){
4422 s->field_select[0][0]= get_bits1(&s->gb);
4423 s->field_select[0][1]= get_bits1(&s->gb);
4425 if(USES_LIST(mb_type, 1)){
4426 s->field_select[1][0]= get_bits1(&s->gb);
4427 s->field_select[1][1]= get_bits1(&s->gb);
4433 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4434 s->mv_type= MV_TYPE_16X16;
4436 if(USES_LIST(mb_type, 0)){
4437 s->mv_dir = MV_DIR_FORWARD;
4439 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4440 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4441 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4442 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4445 if(USES_LIST(mb_type, 1)){
4446 s->mv_dir |= MV_DIR_BACKWARD;
4448 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4449 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4450 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4451 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4453 }else if(!IS_DIRECT(mb_type)){
4454 s->mv_type= MV_TYPE_FIELD;
4456 if(USES_LIST(mb_type, 0)){
4457 s->mv_dir = MV_DIR_FORWARD;
4460 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4461 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4462 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4463 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4467 if(USES_LIST(mb_type, 1)){
4468 s->mv_dir |= MV_DIR_BACKWARD;
4471 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4472 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4473 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4474 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4480 if(IS_DIRECT(mb_type)){
4481 if(IS_SKIP(mb_type))
4484 mx = h263_decode_motion(s, 0, 1);
4485 my = h263_decode_motion(s, 0, 1);
4488 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4489 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4491 s->current_picture.mb_type[xy]= mb_type;
4492 } else { /* I-Frame */
4494 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4496 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4504 s->ac_pred = get_bits1(&s->gb);
4506 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4508 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4510 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4512 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4515 cbp = (cbpc & 3) | (cbpy << 2);
4517 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4520 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4523 if(!s->progressive_sequence)
4524 s->interlaced_dct= get_bits1(&s->gb);
4526 s->dsp.clear_blocks(s->block[0]);
4527 /* decode each block */
4528 for (i = 0; i < 6; i++) {
4529 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4536 /* decode each block */
4537 for (i = 0; i < 6; i++) {
4538 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4544 /* per-MB end of slice check */
4545 if(s->codec_id==CODEC_ID_MPEG4){
4546 if(mpeg4_is_resync(s)){
4547 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4548 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4557 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4559 int code, val, sign, shift, l;
4560 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4567 sign = get_bits1(&s->gb);
4571 val = (val - 1) << shift;
4572 val |= get_bits(&s->gb, shift);
4579 /* modulo decoding */
4580 if (!s->h263_long_vectors) {
4581 l = INT_BIT - 5 - f_code;
4584 /* horrible h263 long vector mode */
4585 if (pred < -31 && val < -63)
4587 if (pred > 32 && val > 63)
4594 /* Decodes RVLC of H.263+ UMV */
4595 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4599 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4602 code = 2 + get_bits1(&s->gb);
4604 while (get_bits1(&s->gb))
4607 code += get_bits1(&s->gb);
4612 code = (sign) ? (pred - code) : (pred + code);
4614 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4620 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4623 int code, level, i, j, last, run;
4624 RLTable *rl = &rl_inter;
4625 const uint8_t *scan_table;
4626 GetBitContext gb= s->gb;
4628 scan_table = s->intra_scantable.permutated;
4629 if (s->h263_aic && s->mb_intra) {
4633 if (s->h263_aic_dir)
4634 scan_table = s->intra_v_scantable.permutated; /* left */
4636 scan_table = s->intra_h_scantable.permutated; /* top */
4638 } else if (s->mb_intra) {
4640 if(s->codec_id == CODEC_ID_RV10){
4641 #ifdef CONFIG_RV10_DECODER
4642 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4643 int component, diff;
4644 component = (n <= 3 ? 0 : n - 4 + 1);
4645 level = s->last_dc[component];
4646 if (s->rv10_first_dc_coded[component]) {
4647 diff = rv_decode_dc(s, n);
4651 level = level & 0xff; /* handle wrap round */
4652 s->last_dc[component] = level;
4654 s->rv10_first_dc_coded[component] = 1;
4657 level = get_bits(&s->gb, 8);
4663 level = get_bits(&s->gb, 8);
4664 if((level&0x7F) == 0){
4665 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4666 if(s->error_resilience >= FF_ER_COMPLIANT)
4678 if (s->mb_intra && s->h263_aic)
4680 s->block_last_index[n] = i - 1;
4685 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4687 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4690 if (code == rl->n) {
4692 if (s->h263_flv > 1) {
4693 int is11 = get_bits1(&s->gb);
4694 last = get_bits1(&s->gb);
4695 run = get_bits(&s->gb, 6);
4697 level = get_sbits(&s->gb, 11);
4699 level = get_sbits(&s->gb, 7);
4702 last = get_bits1(&s->gb);
4703 run = get_bits(&s->gb, 6);
4704 level = (int8_t)get_bits(&s->gb, 8);
4706 if (s->codec_id == CODEC_ID_RV10) {
4707 /* XXX: should patch encoder too */
4708 level = get_sbits(&s->gb, 12);
4710 level = get_bits(&s->gb, 5);
4711 level |= get_sbits(&s->gb, 6)<<5;
4716 run = rl->table_run[code];
4717 level = rl->table_level[code];
4718 last = code >= rl->last;
4719 if (get_bits1(&s->gb))
4724 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4725 //looks like a hack but no, it's the way its supposed to work ...
4729 memset(block, 0, sizeof(DCTELEM)*64);
4732 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4742 if (s->mb_intra && s->h263_aic) {
4743 h263_pred_acdc(s, block, n);
4746 s->block_last_index[n] = i;
4751 * decodes the dc value.
4752 * @param n block index (0-3 are luma, 4-5 are chroma)
4753 * @param dir_ptr the prediction direction will be stored here
4754 * @return the quantized dc
4756 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4761 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4763 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4764 if (code < 0 || code > 9 /* && s->nbit<9 */){
4765 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4773 level= 2*get_bits1(&s->gb)-1;
4775 if(get_bits1(&s->gb))
4776 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4778 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4781 level = get_xbits(&s->gb, code);
4785 if(get_bits1(&s->gb)==0){ /* marker */
4786 if(s->error_resilience>=2){
4787 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4794 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4799 * @return <0 if an error occured
4801 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4802 int n, int coded, int intra, int rvlc)
4804 int level, i, last, run;
4807 RL_VLC_ELEM * rl_vlc;
4808 const uint8_t * scan_table;
4811 //Note intra & rvlc should be optimized away if this is inlined
4814 if(s->use_intra_dc_vlc){
4816 if(s->partitioned_frame){
4817 level = s->dc_val[0][ s->block_index[n] ];
4818 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4819 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4820 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4822 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4830 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4836 rl = &rvlc_rl_intra;
4837 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4840 rl_vlc = rl_intra.rl_vlc[0];
4843 if (dc_pred_dir == 0)
4844 scan_table = s->intra_v_scantable.permutated; /* left */
4846 scan_table = s->intra_h_scantable.permutated; /* top */
4848 scan_table = s->intra_scantable.permutated;
4855 s->block_last_index[n] = i;
4858 if(rvlc) rl = &rvlc_rl_inter;
4859 else rl = &rl_inter;
4861 scan_table = s->intra_scantable.permutated;
4867 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4869 rl_vlc = rl_inter.rl_vlc[0];
4872 qmul = s->qscale << 1;
4873 qadd = (s->qscale - 1) | 1;
4875 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4877 rl_vlc = rl_inter.rl_vlc[s->qscale];
4882 OPEN_READER(re, &s->gb);
4884 UPDATE_CACHE(re, &s->gb);
4885 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4889 if(SHOW_UBITS(re, &s->gb, 1)==0){
4890 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4892 }; SKIP_CACHE(re, &s->gb, 1);
4894 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4895 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4896 SKIP_COUNTER(re, &s->gb, 1+1+6);
4897 UPDATE_CACHE(re, &s->gb);
4899 if(SHOW_UBITS(re, &s->gb, 1)==0){
4900 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4902 }; SKIP_CACHE(re, &s->gb, 1);
4904 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4906 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4907 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4909 }; SKIP_CACHE(re, &s->gb, 5);
4911 level= level * qmul + qadd;
4912 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4913 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4919 cache= GET_CACHE(re, &s->gb);
4922 cache ^= 0xC0000000;
4924 if (cache&0x80000000) {
4925 if (cache&0x40000000) {
4927 SKIP_CACHE(re, &s->gb, 2);
4928 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4929 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4930 SKIP_COUNTER(re, &s->gb, 2+1+6);
4931 UPDATE_CACHE(re, &s->gb);
4934 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4936 if(SHOW_UBITS(re, &s->gb, 1)==0){
4937 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4939 }; SKIP_CACHE(re, &s->gb, 1);
4941 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4943 if(SHOW_UBITS(re, &s->gb, 1)==0){
4944 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4946 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4948 SKIP_COUNTER(re, &s->gb, 1+12+1);
4952 if(s->error_resilience >= FF_ER_COMPLIANT){
4953 const int abs_level= FFABS(level);
4954 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4955 const int run1= run - rl->max_run[last][abs_level] - 1;
4956 if(abs_level <= rl->max_level[last][run]){
4957 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4960 if(s->error_resilience > FF_ER_COMPLIANT){
4961 if(abs_level <= rl->max_level[last][run]*2){
4962 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4965 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4966 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4973 if (level>0) level= level * qmul + qadd;
4974 else level= level * qmul - qadd;
4976 if((unsigned)(level + 2048) > 4095){
4977 if(s->error_resilience > FF_ER_COMPLIANT){
4978 if(level > 2560 || level<-2560){
4979 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4983 level= level<0 ? -2048 : 2047;
4990 #if MIN_CACHE_BITS < 20
4991 LAST_SKIP_BITS(re, &s->gb, 2);
4992 UPDATE_CACHE(re, &s->gb);
4994 SKIP_BITS(re, &s->gb, 2);
4996 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4997 i+= run + rl->max_run[run>>7][level/qmul] +1; //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);
5003 #if MIN_CACHE_BITS < 19
5004 LAST_SKIP_BITS(re, &s->gb, 1);
5005 UPDATE_CACHE(re, &s->gb);
5007 SKIP_BITS(re, &s->gb, 1);
5009 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
5011 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
5012 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
5013 LAST_SKIP_BITS(re, &s->gb, 1);
5018 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
5019 LAST_SKIP_BITS(re, &s->gb, 1);
5024 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5028 block[scan_table[i]] = level;
5032 block[scan_table[i]] = level;
5034 CLOSE_READER(re, &s->gb);
5038 if(!s->use_intra_dc_vlc){
5039 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5041 i -= i>>31; //if(i == -1) i=0;
5044 mpeg4_pred_ac(s, block, n, dc_pred_dir);
5046 i = 63; /* XXX: not optimal */
5049 s->block_last_index[n] = i;
5053 /* most is hardcoded. should extend to handle all h263 streams */
5054 int h263_decode_picture_header(MpegEncContext *s)
5056 int format, width, height, i;
5059 align_get_bits(&s->gb);
5061 startcode= get_bits(&s->gb, 22-8);
5063 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5064 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5066 if(startcode == 0x20)
5070 if (startcode != 0x20) {
5071 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5074 /* temporal reference */
5075 i = get_bits(&s->gb, 8); /* picture timestamp */
5076 if( (s->picture_number&~0xFF)+i < s->picture_number)
5078 s->current_picture_ptr->pts=
5079 s->picture_number= (s->picture_number&~0xFF) + i;
5081 /* PTYPE starts here */
5082 if (get_bits1(&s->gb) != 1) {
5084 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5087 if (get_bits1(&s->gb) != 0) {
5088 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5089 return -1; /* h263 id */
5091 skip_bits1(&s->gb); /* split screen off */
5092 skip_bits1(&s->gb); /* camera off */
5093 skip_bits1(&s->gb); /* freeze picture release off */
5095 format = get_bits(&s->gb, 3);
5100 7 extended PTYPE (PLUSPTYPE)
5103 if (format != 7 && format != 6) {
5106 width = h263_format[format][0];
5107 height = h263_format[format][1];
5111 s->pict_type = I_TYPE + get_bits1(&s->gb);
5113 s->h263_long_vectors = get_bits1(&s->gb);
5115 if (get_bits1(&s->gb) != 0) {
5116 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5117 return -1; /* SAC: off */
5119 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5120 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5122 if (get_bits1(&s->gb) != 0) {
5123 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5124 return -1; /* not PB frame */
5126 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5127 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5131 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5132 s->avctx->time_base= (AVRational){1001, 30000};
5138 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5140 /* ufep other than 0 and 1 are reserved */
5143 format = get_bits(&s->gb, 3);
5144 dprintf("ufep=1, format: %d\n", format);
5145 s->custom_pcf= get_bits1(&s->gb);
5146 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5147 if (get_bits1(&s->gb) != 0) {
5148 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5150 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5151 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5152 s->loop_filter= get_bits1(&s->gb);
5153 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5155 s->h263_slice_structured= get_bits1(&s->gb);
5156 if (get_bits1(&s->gb) != 0) {
5157 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5159 if (get_bits1(&s->gb) != 0) {
5160 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5162 s->alt_inter_vlc= get_bits1(&s->gb);
5163 s->modified_quant= get_bits1(&s->gb);
5164 if(s->modified_quant)
5165 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5167 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5169 skip_bits(&s->gb, 3); /* Reserved */
5170 } else if (ufep != 0) {
5171 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5176 s->pict_type = get_bits(&s->gb, 3);
5177 switch(s->pict_type){
5178 case 0: s->pict_type= I_TYPE;break;
5179 case 1: s->pict_type= P_TYPE;break;
5180 case 3: s->pict_type= B_TYPE;break;
5181 case 7: s->pict_type= I_TYPE;break; //ZYGO
5185 skip_bits(&s->gb, 2);
5186 s->no_rounding = get_bits1(&s->gb);
5187 skip_bits(&s->gb, 4);
5189 /* Get the picture dimensions */
5192 /* Custom Picture Format (CPFMT) */
5193 s->aspect_ratio_info = get_bits(&s->gb, 4);
5194 dprintf("aspect: %d\n", s->aspect_ratio_info);
5199 3 - 10:11 (525-type 4:3)
5200 4 - 16:11 (CIF 16:9)
5201 5 - 40:33 (525-type 16:9)
5204 width = (get_bits(&s->gb, 9) + 1) * 4;
5206 height = get_bits(&s->gb, 9) * 4;
5207 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5208 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5209 /* aspected dimensions */
5210 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5211 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5213 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5216 width = h263_format[format][0];
5217 height = h263_format[format][1];
5218 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5220 if ((width == 0) || (height == 0))
5227 s->avctx->time_base.den= 1800000;
5228 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5229 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5230 if(s->avctx->time_base.num == 0){
5231 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5234 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5235 s->avctx->time_base.den /= gcd;
5236 s->avctx->time_base.num /= gcd;
5237 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5239 s->avctx->time_base= (AVRational){1001, 30000};
5244 skip_bits(&s->gb, 2); //extended Temporal reference
5249 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5252 if(s->h263_slice_structured){
5253 if (get_bits1(&s->gb) != 0) {
5254 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5256 if (get_bits1(&s->gb) != 0) {
5257 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5262 s->qscale = get_bits(&s->gb, 5);
5265 s->mb_width = (s->width + 15) / 16;
5266 s->mb_height = (s->height + 15) / 16;
5267 s->mb_num = s->mb_width * s->mb_height;
5270 while (get_bits1(&s->gb) != 0) {
5271 skip_bits(&s->gb, 8);
5274 if(s->h263_slice_structured){
5275 if (get_bits1(&s->gb) != 1) {
5276 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5280 ff_h263_decode_mba(s);
5282 if (get_bits1(&s->gb) != 1) {
5283 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5290 s->y_dc_scale_table=
5291 s->c_dc_scale_table= ff_aic_dc_scale_table;
5293 s->y_dc_scale_table=
5294 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5297 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5298 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",
5299 s->qscale, av_get_pict_type_char(s->pict_type),
5300 s->gb.size_in_bits, 1-s->no_rounding,
5301 s->obmc ? " AP" : "",
5302 s->umvplus ? " UMV" : "",
5303 s->h263_long_vectors ? " LONG" : "",
5304 s->h263_plus ? " +" : "",
5305 s->h263_aic ? " AIC" : "",
5306 s->alt_inter_vlc ? " AIV" : "",
5307 s->modified_quant ? " MQ" : "",
5308 s->loop_filter ? " LOOP" : "",
5309 s->h263_slice_structured ? " SS" : "",
5310 s->avctx->time_base.den, s->avctx->time_base.num
5314 if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){
5316 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5317 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5318 for(i=0; i<13; i++){
5320 int v= get_bits(&s->gb, 8);
5321 v |= get_sbits(&s->gb, 8)<<8;
5322 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5324 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5326 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5333 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5336 int a= 2<<s->sprite_warping_accuracy;
5337 int rho= 3-s->sprite_warping_accuracy;
5339 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5340 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5341 int sprite_ref[4][2];
5342 int virtual_ref[2][2];
5344 int alpha=0, beta=0;
5349 for(i=0; i<s->num_sprite_warping_points; i++){
5353 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5355 x= get_xbits(gb, length);
5357 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5359 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5361 y=get_xbits(gb, length);
5363 skip_bits1(gb); /* marker bit */
5364 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5369 while((1<<alpha)<w) alpha++;
5370 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5374 // Note, the 4th point isn't used for GMC
5375 if(s->divx_version==500 && s->divx_build==413){
5376 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5377 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5378 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5379 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5380 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5381 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5383 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5384 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5385 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5386 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5387 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5388 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5390 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5391 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5393 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5394 // perhaps it should be reordered to be more readable ...
5395 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5396 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5397 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5398 + 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);
5399 virtual_ref[0][1]= 16*vop_ref[0][1]
5400 + 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);
5401 virtual_ref[1][0]= 16*vop_ref[0][0]
5402 + 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);
5403 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5404 + 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);
5406 switch(s->num_sprite_warping_points)
5409 s->sprite_offset[0][0]= 0;
5410 s->sprite_offset[0][1]= 0;
5411 s->sprite_offset[1][0]= 0;
5412 s->sprite_offset[1][1]= 0;
5413 s->sprite_delta[0][0]= a;
5414 s->sprite_delta[0][1]= 0;
5415 s->sprite_delta[1][0]= 0;
5416 s->sprite_delta[1][1]= a;
5417 s->sprite_shift[0]= 0;
5418 s->sprite_shift[1]= 0;
5421 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5422 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5423 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5424 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5425 s->sprite_delta[0][0]= a;
5426 s->sprite_delta[0][1]= 0;
5427 s->sprite_delta[1][0]= 0;
5428 s->sprite_delta[1][1]= a;
5429 s->sprite_shift[0]= 0;
5430 s->sprite_shift[1]= 0;
5433 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5434 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5435 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5436 + (1<<(alpha+rho-1));
5437 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5438 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5439 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5440 + (1<<(alpha+rho-1));
5441 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5442 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5443 +2*w2*r*sprite_ref[0][0]
5445 + (1<<(alpha+rho+1)));
5446 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5447 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5448 +2*w2*r*sprite_ref[0][1]
5450 + (1<<(alpha+rho+1)));
5451 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5452 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5453 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5454 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5456 s->sprite_shift[0]= alpha+rho;
5457 s->sprite_shift[1]= alpha+rho+2;
5460 min_ab= FFMIN(alpha, beta);
5463 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5464 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5465 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5466 + (1<<(alpha+beta+rho-min_ab-1));
5467 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5468 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5469 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5470 + (1<<(alpha+beta+rho-min_ab-1));
5471 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5472 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5473 + 2*w2*h3*r*sprite_ref[0][0]
5475 + (1<<(alpha+beta+rho-min_ab+1));
5476 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5477 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5478 + 2*w2*h3*r*sprite_ref[0][1]
5480 + (1<<(alpha+beta+rho-min_ab+1));
5481 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5482 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5483 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5484 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5486 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5487 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5490 /* try to simplify the situation */
5491 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5492 && s->sprite_delta[0][1] == 0
5493 && s->sprite_delta[1][0] == 0
5494 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5496 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5497 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5498 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5499 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5500 s->sprite_delta[0][0]= a;
5501 s->sprite_delta[0][1]= 0;
5502 s->sprite_delta[1][0]= 0;
5503 s->sprite_delta[1][1]= a;
5504 s->sprite_shift[0]= 0;
5505 s->sprite_shift[1]= 0;
5506 s->real_sprite_warping_points=1;
5509 int shift_y= 16 - s->sprite_shift[0];
5510 int shift_c= 16 - s->sprite_shift[1];
5511 //printf("shifts %d %d\n", shift_y, shift_c);
5513 s->sprite_offset[0][i]<<= shift_y;
5514 s->sprite_offset[1][i]<<= shift_c;
5515 s->sprite_delta[0][i]<<= shift_y;
5516 s->sprite_delta[1][i]<<= shift_y;
5517 s->sprite_shift[i]= 16;
5519 s->real_sprite_warping_points= s->num_sprite_warping_points;
5522 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5523 vop_ref[0][0], vop_ref[0][1],
5524 vop_ref[1][0], vop_ref[1][1],
5525 vop_ref[2][0], vop_ref[2][1],
5526 sprite_ref[0][0], sprite_ref[0][1],
5527 sprite_ref[1][0], sprite_ref[1][1],
5528 sprite_ref[2][0], sprite_ref[2][1],
5529 virtual_ref[0][0], virtual_ref[0][1],
5530 virtual_ref[1][0], virtual_ref[1][1]
5533 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5534 s->sprite_offset[0][0], s->sprite_offset[0][1],
5535 s->sprite_delta[0][0], s->sprite_delta[0][1],
5536 s->sprite_delta[1][0], s->sprite_delta[1][1],
5542 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5543 int hours, minutes, seconds;
5545 hours= get_bits(gb, 5);
5546 minutes= get_bits(gb, 6);
5548 seconds= get_bits(gb, 6);
5550 s->time_base= seconds + 60*(minutes + 60*hours);
5558 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5559 int width, height, vo_ver_id;
5562 skip_bits(gb, 1); /* random access */
5563 s->vo_type= get_bits(gb, 8);
5564 if (get_bits1(gb) != 0) { /* is_ol_id */
5565 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5566 skip_bits(gb, 3); /* vo_priority */
5570 //printf("vo type:%d\n",s->vo_type);
5571 s->aspect_ratio_info= get_bits(gb, 4);
5572 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5573 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5574 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5576 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5579 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5580 int chroma_format= get_bits(gb, 2);
5581 if(chroma_format!=1){
5582 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5584 s->low_delay= get_bits1(gb);
5585 if(get_bits1(gb)){ /* vbv parameters */
5586 get_bits(gb, 15); /* first_half_bitrate */
5587 skip_bits1(gb); /* marker */
5588 get_bits(gb, 15); /* latter_half_bitrate */
5589 skip_bits1(gb); /* marker */
5590 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5591 skip_bits1(gb); /* marker */
5592 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5593 get_bits(gb, 11); /* first_half_vbv_occupancy */
5594 skip_bits1(gb); /* marker */
5595 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5596 skip_bits1(gb); /* marker */
5599 // set low delay flag only once the smartest? low delay detection won't be overriden
5600 if(s->picture_number==0)
5604 s->shape = get_bits(gb, 2); /* vol shape */
5605 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5606 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5607 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5608 skip_bits(gb, 4); //video_object_layer_shape_extension
5611 check_marker(gb, "before time_increment_resolution");
5613 s->avctx->time_base.den = get_bits(gb, 16);
5614 if(!s->avctx->time_base.den){
5615 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5619 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5620 if (s->time_increment_bits < 1)
5621 s->time_increment_bits = 1;
5623 check_marker(gb, "before fixed_vop_rate");
5625 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5626 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5628 s->avctx->time_base.num = 1;
5632 if (s->shape != BIN_ONLY_SHAPE) {
5633 if (s->shape == RECT_SHAPE) {
5634 skip_bits1(gb); /* marker */
5635 width = get_bits(gb, 13);
5636 skip_bits1(gb); /* marker */
5637 height = get_bits(gb, 13);
5638 skip_bits1(gb); /* marker */
5639 if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5642 // printf("width/height: %d %d\n", width, height);
5646 s->progressive_sequence=
5647 s->progressive_frame= get_bits1(gb)^1;
5648 s->interlaced_dct=0;
5649 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5650 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5651 if (vo_ver_id == 1) {
5652 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5654 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5656 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5657 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5658 if(s->vol_sprite_usage==STATIC_SPRITE){
5659 s->sprite_width = get_bits(gb, 13);
5660 skip_bits1(gb); /* marker */
5661 s->sprite_height= get_bits(gb, 13);
5662 skip_bits1(gb); /* marker */
5663 s->sprite_left = get_bits(gb, 13);
5664 skip_bits1(gb); /* marker */
5665 s->sprite_top = get_bits(gb, 13);
5666 skip_bits1(gb); /* marker */
5668 s->num_sprite_warping_points= get_bits(gb, 6);
5669 s->sprite_warping_accuracy = get_bits(gb, 2);
5670 s->sprite_brightness_change= get_bits1(gb);
5671 if(s->vol_sprite_usage==STATIC_SPRITE)
5672 s->low_latency_sprite= get_bits1(gb);
5674 // FIXME sadct disable bit if verid!=1 && shape not rect
5676 if (get_bits1(gb) == 1) { /* not_8_bit */
5677 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5678 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5679 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5681 s->quant_precision = 5;
5684 // FIXME a bunch of grayscale shape things
5686 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5689 /* load default matrixes */
5690 for(i=0; i<64; i++){
5691 int j= s->dsp.idct_permutation[i];
5692 v= ff_mpeg4_default_intra_matrix[i];
5693 s->intra_matrix[j]= v;
5694 s->chroma_intra_matrix[j]= v;
5696 v= ff_mpeg4_default_non_intra_matrix[i];
5697 s->inter_matrix[j]= v;
5698 s->chroma_inter_matrix[j]= v;
5701 /* load custom intra matrix */
5704 for(i=0; i<64; i++){
5710 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5711 s->intra_matrix[j]= v;
5712 s->chroma_intra_matrix[j]= v;
5715 /* replicate last value */
5717 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5718 s->intra_matrix[j]= last;
5719 s->chroma_intra_matrix[j]= last;
5723 /* load custom non intra matrix */
5726 for(i=0; i<64; i++){
5732 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5733 s->inter_matrix[j]= v;
5734 s->chroma_inter_matrix[j]= v;
5737 /* replicate last value */
5739 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5740 s->inter_matrix[j]= last;
5741 s->chroma_inter_matrix[j]= last;
5745 // FIXME a bunch of grayscale shape things
5749 s->quarter_sample= get_bits1(gb);
5750 else s->quarter_sample=0;
5752 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5754 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5756 s->data_partitioning= get_bits1(gb);
5757 if(s->data_partitioning){
5758 s->rvlc= get_bits1(gb);
5761 if(vo_ver_id != 1) {
5762 s->new_pred= get_bits1(gb);
5764 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5765 skip_bits(gb, 2); /* requested upstream message type */
5766 skip_bits1(gb); /* newpred segment type */
5768 s->reduced_res_vop= get_bits1(gb);
5769 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5773 s->reduced_res_vop= 0;
5776 s->scalability= get_bits1(gb);
5778 if (s->scalability) {
5779 GetBitContext bak= *gb;
5781 int ref_layer_sampling_dir;
5782 int h_sampling_factor_n;
5783 int h_sampling_factor_m;
5784 int v_sampling_factor_n;
5785 int v_sampling_factor_m;
5787 s->hierachy_type= get_bits1(gb);
5788 ref_layer_id= get_bits(gb, 4);
5789 ref_layer_sampling_dir= get_bits1(gb);
5790 h_sampling_factor_n= get_bits(gb, 5);
5791 h_sampling_factor_m= get_bits(gb, 5);
5792 v_sampling_factor_n= get_bits(gb, 5);
5793 v_sampling_factor_m= get_bits(gb, 5);
5794 s->enhancement_type= get_bits1(gb);
5796 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5797 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5799 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5804 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5806 // bin shape stuff FIXME
5813 * decodes the user data stuff in the header.
5814 * allso inits divx/xvid/lavc_version/build
5816 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5820 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5823 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5824 if(show_bits(gb, 23) == 0) break;
5825 buf[i]= get_bits(gb, 8);
5829 /* divx detection */
5830 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5832 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5834 s->divx_version= ver;
5835 s->divx_build= build;
5836 s->divx_packed= e==3 && last=='p';
5839 /* ffmpeg detection */
5840 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5842 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5844 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5846 build= (ver<<16) + (ver2<<8) + ver3;
5849 if(strcmp(buf, "ffmpeg")==0){
5850 s->lavc_build= 4600;
5854 s->lavc_build= build;
5857 /* xvid detection */
5858 e=sscanf(buf, "XviD%d", &build);
5860 s->xvid_build= build;
5863 //printf("User Data: %s\n", buf);
5867 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5868 int time_incr, time_increment;
5870 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5871 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5872 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5876 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5877 if(s->partitioned_frame)
5878 s->decode_mb= mpeg4_decode_partitioned_mb;
5880 s->decode_mb= ff_mpeg4_decode_mb;
5883 while (get_bits1(gb) != 0)
5886 check_marker(gb, "before time_increment");
5888 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5889 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5891 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5892 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5895 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5898 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5899 else time_increment= get_bits(gb, s->time_increment_bits);
5901 // printf("%d %X\n", s->time_increment_bits, time_increment);
5902 //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);
5903 if(s->pict_type!=B_TYPE){
5904 s->last_time_base= s->time_base;
5905 s->time_base+= time_incr;
5906 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5907 if(s->workaround_bugs&FF_BUG_UMP4){
5908 if(s->time < s->last_non_b_time){
5909 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5911 s->time+= s->avctx->time_base.den;
5914 s->pp_time= s->time - s->last_non_b_time;
5915 s->last_non_b_time= s->time;
5917 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5918 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5919 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5920 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5921 return FRAME_SKIPPED;
5923 ff_mpeg4_init_direct_mv(s);
5925 if(s->t_frame==0) s->t_frame= s->pb_time;
5926 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5927 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5928 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5929 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5930 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5932 //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);
5934 if(s->avctx->time_base.num)
5935 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5937 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5938 if(s->avctx->debug&FF_DEBUG_PTS)
5939 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5941 check_marker(gb, "before vop_coded");
5944 if (get_bits1(gb) != 1){
5945 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5946 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5947 return FRAME_SKIPPED;
5949 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5950 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5951 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5952 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5953 /* rounding type for motion estimation */
5954 s->no_rounding = get_bits1(gb);
5958 //FIXME reduced res stuff
5960 if (s->shape != RECT_SHAPE) {
5961 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5962 int width, height, hor_spat_ref, ver_spat_ref;
5964 width = get_bits(gb, 13);
5965 skip_bits1(gb); /* marker */
5966 height = get_bits(gb, 13);
5967 skip_bits1(gb); /* marker */
5968 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5969 skip_bits1(gb); /* marker */
5970 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5972 skip_bits1(gb); /* change_CR_disable */
5974 if (get_bits1(gb) != 0) {
5975 skip_bits(gb, 8); /* constant_alpha_value */
5978 //FIXME complexity estimation stuff
5980 if (s->shape != BIN_ONLY_SHAPE) {
5981 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5982 if(!s->progressive_sequence){
5983 s->top_field_first= get_bits1(gb);
5984 s->alternate_scan= get_bits1(gb);
5986 s->alternate_scan= 0;
5989 if(s->alternate_scan){
5990 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5991 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5992 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5993 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5995 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5996 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5997 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5998 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
6001 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
6002 mpeg4_decode_sprite_trajectory(s, gb);
6003 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
6004 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
6007 if (s->shape != BIN_ONLY_SHAPE) {
6008 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
6010 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
6011 return -1; // makes no sense to continue, as there is nothing left from the image then
6014 if (s->pict_type != I_TYPE) {
6015 s->f_code = get_bits(gb, 3); /* fcode_for */
6017 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
6018 return -1; // makes no sense to continue, as the MV decoding will break very quickly
6023 if (s->pict_type == B_TYPE) {
6024 s->b_code = get_bits(gb, 3);
6028 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6029 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",
6030 s->qscale, s->f_code, s->b_code,
6031 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6032 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6033 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6034 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
6037 if(!s->scalability){
6038 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
6039 skip_bits1(gb); // vop shape coding type
6042 if(s->enhancement_type){
6043 int load_backward_shape= get_bits1(gb);
6044 if(load_backward_shape){
6045 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6048 skip_bits(gb, 2); //ref_select_code
6051 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6052 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6053 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6054 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6058 s->picture_number++; // better than pic number==0 always ;)
6060 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6061 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6063 if(s->workaround_bugs&FF_BUG_EDGE){
6064 s->h_edge_pos= s->width;
6065 s->v_edge_pos= s->height;
6071 * decode mpeg4 headers
6072 * @return <0 if no VOP found (or a damaged one)
6073 * FRAME_SKIPPED if a not coded VOP is found
6074 * 0 if a VOP is found
6076 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6080 /* search next start code */
6083 if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6085 if(get_bits(gb, 8) == 0xF0)
6086 return decode_vop_header(s, gb);
6091 if(get_bits_count(gb) >= gb->size_in_bits){
6092 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6093 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6094 return FRAME_SKIPPED; //divx bug
6096 return -1; //end of stream
6099 /* use the bits after the test */
6100 v = get_bits(gb, 8);
6101 startcode = ((startcode << 8) | v) & 0xffffffff;
6103 if((startcode&0xFFFFFF00) != 0x100)
6104 continue; //no startcode
6106 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6107 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6108 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6109 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6110 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6111 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6112 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6113 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6114 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6115 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6116 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6117 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6118 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6119 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6120 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6121 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6122 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6123 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6124 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6125 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6126 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6127 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6128 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6129 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6130 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6131 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6132 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6133 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6134 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6135 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6138 if(startcode >= 0x120 && startcode <= 0x12F){
6139 if(decode_vol_header(s, gb) < 0)
6142 else if(startcode == USER_DATA_STARTCODE){
6143 decode_user_data(s, gb);
6145 else if(startcode == GOP_STARTCODE){
6146 mpeg4_decode_gop_header(s, gb);
6148 else if(startcode == VOP_STARTCODE){
6149 return decode_vop_header(s, gb);
6157 /* don't understand why they choose a different header ! */
6158 int intel_h263_decode_picture_header(MpegEncContext *s)
6162 /* picture header */
6163 if (get_bits_long(&s->gb, 22) != 0x20) {
6164 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6167 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6169 if (get_bits1(&s->gb) != 1) {
6170 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6171 return -1; /* marker */
6173 if (get_bits1(&s->gb) != 0) {
6174 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6175 return -1; /* h263 id */
6177 skip_bits1(&s->gb); /* split screen off */
6178 skip_bits1(&s->gb); /* camera off */
6179 skip_bits1(&s->gb); /* freeze picture release off */
6181 format = get_bits(&s->gb, 3);
6183 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6188 s->pict_type = I_TYPE + get_bits1(&s->gb);
6190 s->unrestricted_mv = get_bits1(&s->gb);
6191 s->h263_long_vectors = s->unrestricted_mv;
6193 if (get_bits1(&s->gb) != 0) {
6194 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6195 return -1; /* SAC: off */
6197 if (get_bits1(&s->gb) != 0) {
6199 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6200 // return -1; /* advanced prediction mode: off */
6202 if (get_bits1(&s->gb) != 0) {
6203 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6204 return -1; /* PB frame mode */
6207 /* skip unknown header garbage */
6208 skip_bits(&s->gb, 41);
6210 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6211 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6214 while (get_bits1(&s->gb) != 0) {
6215 skip_bits(&s->gb, 8);
6219 s->y_dc_scale_table=
6220 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6225 int flv_h263_decode_picture_header(MpegEncContext *s)
6227 int format, width, height;
6229 /* picture header */
6230 if (get_bits_long(&s->gb, 17) != 1) {
6231 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6234 format = get_bits(&s->gb, 5);
6235 if (format != 0 && format != 1) {
6236 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6239 s->h263_flv = format+1;
6240 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6241 format = get_bits(&s->gb, 3);
6244 width = get_bits(&s->gb, 8);
6245 height = get_bits(&s->gb, 8);
6248 width = get_bits(&s->gb, 16);
6249 height = get_bits(&s->gb, 16);
6275 if(avcodec_check_dimensions(s->avctx, width, height))
6280 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6281 s->dropable= s->pict_type > P_TYPE;
6283 s->pict_type = P_TYPE;
6285 skip_bits1(&s->gb); /* deblocking flag */
6286 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6290 s->unrestricted_mv = 1;
6291 s->h263_long_vectors = 0;
6294 while (get_bits1(&s->gb) != 0) {
6295 skip_bits(&s->gb, 8);
6299 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6300 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6301 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6304 s->y_dc_scale_table=
6305 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;