2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
5 * Copyright (c) 2001 Juan J. Sierralta P.
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * ac prediction encoding, b-frame support, error resilience, optimizations,
23 * qpel decoding, gmc decoding, interlaced decoding,
24 * by Michael Niedermayer <michaelni@gmx.at>
38 #include "mpegvideo.h"
40 #include "mpeg4data.h"
45 #define INTRA_MCBPC_VLC_BITS 6
46 #define INTER_MCBPC_VLC_BITS 7
47 #define CBPY_VLC_BITS 6
50 #define SPRITE_TRAJ_VLC_BITS 6
51 #define MB_TYPE_B_VLC_BITS 4
52 #define TEX_VLC_BITS 9
53 #define H263_MBTYPE_B_VLC_BITS 6
54 #define CBPC_B_VLC_BITS 3
56 #ifdef CONFIG_ENCODERS
57 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59 static void h263p_encode_umotion(MpegEncContext * s, int val);
60 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61 int n, int dc, uint8_t *scan_table,
62 PutBitContext *dc_pb, PutBitContext *ac_pb);
63 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
67 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
68 static int h263p_decode_umotion(MpegEncContext * s, int pred);
69 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
71 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
72 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
73 int n, int coded, int intra, int rvlc);
74 #ifdef CONFIG_ENCODERS
75 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
76 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
77 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
78 #endif //CONFIG_ENCODERS
79 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
80 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82 #ifdef CONFIG_ENCODERS
83 static uint8_t uni_DCtab_lum_len[512];
84 static uint8_t uni_DCtab_chrom_len[512];
85 static uint16_t uni_DCtab_lum_bits[512];
86 static uint16_t uni_DCtab_chrom_bits[512];
88 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
89 static uint8_t fcode_tab[MAX_MV*2+1];
90 static uint8_t umv_fcode_tab[MAX_MV*2+1];
92 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
93 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
94 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
95 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
96 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
97 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
98 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
100 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
113 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
114 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
119 int h263_get_picture_format(int width, int height)
123 if (width == 128 && height == 96)
125 else if (width == 176 && height == 144)
127 else if (width == 352 && height == 288)
129 else if (width == 704 && height == 576)
131 else if (width == 1408 && height == 1152)
138 #ifdef CONFIG_ENCODERS
140 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
143 if(aspect.num==0) aspect= (AVRational){1,1};
146 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
147 s->aspect_ratio_info=i;
152 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
155 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
159 align_put_bits(&s->pb);
161 put_bits(&s->pb, 17, 1);
162 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
163 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
164 s->avctx->time_base.den) & 0xff); /* TemporalReference */
165 if (s->width == 352 && s->height == 288)
167 else if (s->width == 176 && s->height == 144)
169 else if (s->width == 128 && s->height == 96)
171 else if (s->width == 320 && s->height == 240)
173 else if (s->width == 160 && s->height == 120)
175 else if (s->width <= 255 && s->height <= 255)
176 format = 0; /* use 1 byte width & height */
178 format = 1; /* use 2 bytes width & height */
179 put_bits(&s->pb, 3, format); /* PictureSize */
181 put_bits(&s->pb, 8, s->width);
182 put_bits(&s->pb, 8, s->height);
183 } else if (format == 1) {
184 put_bits(&s->pb, 16, s->width);
185 put_bits(&s->pb, 16, s->height);
187 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
188 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
189 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
190 put_bits(&s->pb, 1, 0); /* ExtraInformation */
194 s->c_dc_scale_table= ff_aic_dc_scale_table;
197 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
201 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
203 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
204 int best_clock_code=1;
206 int best_error= INT_MAX;
211 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
212 div= clip(1, div, 127);
213 error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
214 if(error < best_error){
221 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
222 coded_frame_rate= 1800000;
223 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
225 align_put_bits(&s->pb);
227 /* Update the pointer to last GOB */
228 s->ptr_lastgob = pbBufPtr(&s->pb);
229 put_bits(&s->pb, 22, 0x20); /* PSC */
230 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
231 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
232 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
234 put_bits(&s->pb, 1, 1); /* marker */
235 put_bits(&s->pb, 1, 0); /* h263 id */
236 put_bits(&s->pb, 1, 0); /* split screen off */
237 put_bits(&s->pb, 1, 0); /* camera off */
238 put_bits(&s->pb, 1, 0); /* freeze picture release off */
240 format = h263_get_picture_format(s->width, s->height);
243 put_bits(&s->pb, 3, format);
244 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
245 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
246 of H.263v1 UMV implies to check the predicted MV after
247 calculation of the current MB to see if we're on the limits */
248 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
249 put_bits(&s->pb, 1, 0); /* SAC: off */
250 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
251 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
252 put_bits(&s->pb, 5, s->qscale);
253 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
257 /* H.263 Plus PTYPE */
259 put_bits(&s->pb, 3, 7);
260 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
262 put_bits(&s->pb,3,6); /* Custom Source Format */
264 put_bits(&s->pb, 3, format);
266 put_bits(&s->pb,1, s->custom_pcf);
267 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
268 put_bits(&s->pb,1,0); /* SAC: off */
269 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
270 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
271 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
272 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
273 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
274 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
275 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
276 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
277 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278 put_bits(&s->pb,3,0); /* Reserved */
280 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
282 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
283 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
284 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
285 put_bits(&s->pb,2,0); /* Reserved */
286 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
288 /* This should be here if PLUSPTYPE */
289 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
292 /* Custom Picture Format (CPFMT) */
293 aspect_to_info(s, s->avctx->sample_aspect_ratio);
295 put_bits(&s->pb,4,s->aspect_ratio_info);
296 put_bits(&s->pb,9,(s->width >> 2) - 1);
297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298 put_bits(&s->pb,9,(s->height >> 2));
299 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
300 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
301 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
306 put_bits(&s->pb, 1, best_clock_code);
307 put_bits(&s->pb, 7, best_divisor);
309 put_bits(&s->pb, 2, (temp_ref>>8)&3);
312 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
314 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
315 //FIXME check actual requested range
316 put_bits(&s->pb,2,1); /* unlimited */
317 if(s->h263_slice_structured)
318 put_bits(&s->pb,2,0); /* no weird submodes */
320 put_bits(&s->pb, 5, s->qscale);
323 put_bits(&s->pb, 1, 0); /* no PEI */
325 if(s->h263_slice_structured){
326 put_bits(&s->pb, 1, 1);
328 assert(s->mb_x == 0 && s->mb_y == 0);
329 ff_h263_encode_mba(s);
331 put_bits(&s->pb, 1, 1);
336 s->c_dc_scale_table= ff_aic_dc_scale_table;
339 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344 * Encodes a group of blocks header.
346 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
348 put_bits(&s->pb, 17, 1); /* GBSC */
350 if(s->h263_slice_structured){
351 put_bits(&s->pb, 1, 1);
353 ff_h263_encode_mba(s);
356 put_bits(&s->pb, 1, 1);
357 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
358 put_bits(&s->pb, 1, 1);
359 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
361 int gob_number= mb_line / s->gob_index;
363 put_bits(&s->pb, 5, gob_number); /* GN */
364 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
365 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
369 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
374 for(j=1; j<=block_last_index; j++){
375 const int index= scantable[j];
376 int level= block[index];
379 if((level&(~127)) == 0){
380 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
381 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
383 rate += s->ac_esc_length;
393 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
397 int8_t * const qscale_table= s->current_picture.qscale_table;
399 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
402 int16_t *ac_val, *ac_val1;
404 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
406 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
409 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
411 ac_val-= s->block_wrap[n]*16;
412 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
415 const int level= block[n][s->dsp.idct_permutation[i ]];
416 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
417 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
421 /* different qscale, we must rescale */
423 const int level= block[n][s->dsp.idct_permutation[i ]];
424 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
425 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
429 st[n]= s->intra_h_scantable.permutated;
431 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
432 /* left prediction */
434 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
437 const int level= block[n][s->dsp.idct_permutation[i<<3]];
438 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
440 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
443 /* different qscale, we must rescale */
445 const int level= block[n][s->dsp.idct_permutation[i<<3]];
446 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
448 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
451 st[n]= s->intra_v_scantable.permutated;
454 for(i=63; i>0; i--) //FIXME optimize
455 if(block[n][ st[n][i] ]) break;
456 s->block_last_index[n]= i;
458 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
464 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
467 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
470 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
472 st[n]= s->intra_scantable.permutated;
476 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
479 /* left prediction */
481 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
488 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
490 void ff_clean_h263_qscales(MpegEncContext *s){
492 int8_t * const qscale_table= s->current_picture.qscale_table;
494 for(i=1; i<s->mb_num; i++){
495 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
496 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
498 for(i=s->mb_num-2; i>=0; i--){
499 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
500 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
503 if(s->codec_id != CODEC_ID_H263P){
504 for(i=1; i<s->mb_num; i++){
505 int mb_xy= s->mb_index2xy[i];
507 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
508 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
509 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
516 * modify mb_type & qscale so that encoding is acually possible in mpeg4
518 void ff_clean_mpeg4_qscales(MpegEncContext *s){
520 int8_t * const qscale_table= s->current_picture.qscale_table;
522 ff_clean_h263_qscales(s);
524 if(s->pict_type== B_TYPE){
526 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
528 for(i=0; i<s->mb_num; i++){
529 int mb_xy= s->mb_index2xy[i];
530 odd += qscale_table[mb_xy]&1;
533 if(2*odd > s->mb_num) odd=1;
536 for(i=0; i<s->mb_num; i++){
537 int mb_xy= s->mb_index2xy[i];
538 if((qscale_table[mb_xy]&1) != odd)
539 qscale_table[mb_xy]++;
540 if(qscale_table[mb_xy] > 31)
541 qscale_table[mb_xy]= 31;
544 for(i=1; i<s->mb_num; i++){
545 int mb_xy= s->mb_index2xy[i];
546 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
547 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
548 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
554 #endif //CONFIG_ENCODERS
556 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
557 #define tab_bias (tab_size/2)
559 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
561 for(i=0; i<tab_size; i++){
562 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
563 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
567 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
568 int xy= s->block_index[i];
569 uint16_t time_pp= s->pp_time;
570 uint16_t time_pb= s->pb_time;
573 p_mx= s->next_picture.motion_val[0][xy][0];
574 if((unsigned)(p_mx + tab_bias) < tab_size){
575 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
576 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
577 : s->direct_scale_mv[1][p_mx + tab_bias];
579 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
580 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
581 : p_mx*(time_pb - time_pp)/time_pp;
583 p_my= s->next_picture.motion_val[0][xy][1];
584 if((unsigned)(p_my + tab_bias) < tab_size){
585 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
586 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
587 : s->direct_scale_mv[1][p_my + tab_bias];
589 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
590 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
591 : p_my*(time_pb - time_pp)/time_pp;
600 * @return the mb_type
602 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
603 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
604 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
605 uint16_t time_pp= s->pp_time;
606 uint16_t time_pb= s->pb_time;
609 //FIXME avoid divides
610 // try special case with shifts for 1 and 3 B-frames?
612 if(IS_8X8(colocated_mb_type)){
613 s->mv_type = MV_TYPE_8X8;
615 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
617 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
618 } else if(IS_INTERLACED(colocated_mb_type)){
619 s->mv_type = MV_TYPE_FIELD;
621 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
622 s->field_select[0][i]= field_select;
623 s->field_select[1][i]= i;
624 if(s->top_field_first){
625 time_pp= s->pp_field_time - field_select + i;
626 time_pb= s->pb_field_time - field_select + i;
628 time_pp= s->pp_field_time + field_select - i;
629 time_pb= s->pb_field_time + field_select - i;
631 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
632 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
633 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
634 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
635 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
636 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
638 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
640 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
641 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
642 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
643 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
644 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
645 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
646 s->mv_type= MV_TYPE_16X16;
648 s->mv_type= MV_TYPE_8X8;
649 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
653 void ff_h263_update_motion_val(MpegEncContext * s){
654 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
655 //FIXME a lot of that is only needed for !low_delay
656 const int wrap = s->b8_stride;
657 const int xy = s->block_index[0];
659 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
661 if(s->mv_type != MV_TYPE_8X8){
662 int motion_x, motion_y;
666 } else if (s->mv_type == MV_TYPE_16X16) {
667 motion_x = s->mv[0][0][0];
668 motion_y = s->mv[0][0][1];
669 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
671 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
672 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
673 motion_x = (motion_x>>1) | (motion_x&1);
675 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
676 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
678 s->current_picture.ref_index[0][xy ]=
679 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
680 s->current_picture.ref_index[0][xy + wrap ]=
681 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
684 /* no update if 8X8 because it has been done during parsing */
685 s->current_picture.motion_val[0][xy][0] = motion_x;
686 s->current_picture.motion_val[0][xy][1] = motion_y;
687 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
688 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
689 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
690 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
691 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
692 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
695 if(s->encoding){ //FIXME encoding MUST be cleaned up
696 if (s->mv_type == MV_TYPE_8X8)
697 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
699 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
701 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
705 #ifdef CONFIG_ENCODERS
707 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
708 int l, bit_size, code;
713 bit_size = f_code - 1;
714 /* modulo encoding */
715 l= INT_BIT - 6 - bit_size;
718 code = (val >> bit_size) + 1;
720 return mvtab[code][1] + 1 + bit_size;
724 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
725 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
726 skip_put_bits(&s->pb,
727 h263_get_motion_length(s, x, f_code)
728 +h263_get_motion_length(s, y, f_code));
730 ff_h263_encode_motion(s, x, f_code);
731 ff_h263_encode_motion(s, y, f_code);
735 static inline int get_p_cbp(MpegEncContext * s,
736 DCTELEM block[6][64],
737 int motion_x, int motion_y){
740 if(s->flags & CODEC_FLAG_CBP_RD){
741 int best_cbpy_score= INT_MAX;
742 int best_cbpc_score= INT_MAX;
743 int cbpc = (-1), cbpy= (-1);
744 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
745 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
748 int score= inter_MCBPC_bits[i + offset] * lambda;
749 if(i&1) score += s->coded_score[5];
750 if(i&2) score += s->coded_score[4];
752 if(score < best_cbpc_score){
753 best_cbpc_score= score;
759 int score= cbpy_tab[i ^ 0xF][1] * lambda;
760 if(i&1) score += s->coded_score[3];
761 if(i&2) score += s->coded_score[2];
762 if(i&4) score += s->coded_score[1];
763 if(i&8) score += s->coded_score[0];
765 if(score < best_cbpy_score){
766 best_cbpy_score= score;
771 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
772 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
776 for (i = 0; i < 6; i++) {
777 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
778 s->block_last_index[i]= -1;
779 memset(s->block[i], 0, sizeof(DCTELEM)*64);
784 for (i = 0; i < 6; i++) {
785 if (s->block_last_index[i] >= 0)
792 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
793 int motion_x, int motion_y, int mb_type){
796 if(s->flags & CODEC_FLAG_CBP_RD){
798 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
801 if(s->coded_score[i] < 0){
802 score += s->coded_score[i];
809 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
810 zero_score-= 4; //2*MV + mb_type + cbp bit
814 if(zero_score <= score){
819 for (i = 0; i < 6; i++) {
820 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
821 s->block_last_index[i]= -1;
822 memset(s->block[i], 0, sizeof(DCTELEM)*64);
826 for (i = 0; i < 6; i++) {
827 if (s->block_last_index[i] >= 0)
834 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
835 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
839 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
840 for (i = 0; i < 6; i++) {
841 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
844 /* encode each block */
845 for (i = 0; i < 6; i++) {
846 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
850 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
851 for (i = 0; i < 6; i++) {
852 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
855 /* encode each block */
856 for (i = 0; i < 6; i++) {
857 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
863 void mpeg4_encode_mb(MpegEncContext * s,
864 DCTELEM block[6][64],
865 int motion_x, int motion_y)
867 int cbpc, cbpy, pred_x, pred_y;
868 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
869 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
870 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
871 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
872 const int dquant_code[5]= {1,0,9,2,3};
874 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
878 if(s->pict_type==B_TYPE){
879 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
880 int mb_type= mb_type_table[s->mv_dir];
887 s->last_mv[i][1][1]= 0;
891 assert(s->dquant>=-2 && s->dquant<=2);
892 assert((s->dquant&1)==0);
895 /* nothing to do if this MB was skipped in the next P Frame */
896 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
902 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
903 s->qscale -= s->dquant;
909 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
911 if ((cbp | motion_x | motion_y | mb_type) ==0) {
912 /* direct MB with MV={0,0} */
913 assert(s->dquant==0);
915 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
917 if(interleaved_stats){
925 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
926 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
927 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
928 if(cbp) put_bits(&s->pb, 6, cbp);
932 put_bits(&s->pb, 2, (s->dquant>>2)+3);
934 put_bits(&s->pb, 1, 0);
936 s->qscale -= s->dquant;
938 if(!s->progressive_sequence){
940 put_bits(&s->pb, 1, s->interlaced_dct);
941 if(mb_type) // not direct mode
942 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
945 if(interleaved_stats){
946 s->misc_bits+= get_bits_diff(s);
950 assert(s->mv_dir & MV_DIRECT);
951 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
955 assert(mb_type > 0 && mb_type < 4);
956 if(s->mv_type != MV_TYPE_FIELD){
957 if(s->mv_dir & MV_DIR_FORWARD){
958 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
959 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
960 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
961 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
964 if(s->mv_dir & MV_DIR_BACKWARD){
965 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
966 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
967 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
968 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
972 if(s->mv_dir & MV_DIR_FORWARD){
973 put_bits(&s->pb, 1, s->field_select[0][0]);
974 put_bits(&s->pb, 1, s->field_select[0][1]);
976 if(s->mv_dir & MV_DIR_BACKWARD){
977 put_bits(&s->pb, 1, s->field_select[1][0]);
978 put_bits(&s->pb, 1, s->field_select[1][1]);
980 if(s->mv_dir & MV_DIR_FORWARD){
982 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
983 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
984 s->last_mv[0][i][0]= s->mv[0][i][0];
985 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
989 if(s->mv_dir & MV_DIR_BACKWARD){
991 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
992 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
993 s->last_mv[1][i][0]= s->mv[1][i][0];
994 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1001 if(interleaved_stats){
1002 s->mv_bits+= get_bits_diff(s);
1005 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1007 if(interleaved_stats){
1008 s->p_tex_bits+= get_bits_diff(s);
1011 }else{ /* s->pict_type==B_TYPE */
1012 cbp= get_p_cbp(s, block, motion_x, motion_y);
1014 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1015 /* check if the B frames can skip it too, as we must skip it if we skip here
1016 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1017 if(s->max_b_frames>0){
1024 if(x+16 > s->width) x= s->width-16;
1025 if(y+16 > s->height) y= s->height-16;
1027 offset= x + y*s->linesize;
1028 p_pic= s->new_picture.data[0] + offset;
1031 for(i=0; i<s->max_b_frames; i++){
1034 Picture *pic= s->reordered_input_picture[i+1];
1036 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1038 b_pic= pic->data[0] + offset;
1039 if(pic->type != FF_BUFFER_TYPE_SHARED)
1040 b_pic+= INPLACE_OFFSET;
1041 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1042 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1050 if(s->mb_skipped==1){
1051 /* skip macroblock */
1052 put_bits(&s->pb, 1, 1);
1054 if(interleaved_stats){
1064 put_bits(&s->pb, 1, 0); /* mb coded */
1068 if(s->mv_type==MV_TYPE_16X16){
1069 if(s->dquant) cbpc+= 8;
1071 inter_MCBPC_bits[cbpc],
1072 inter_MCBPC_code[cbpc]);
1074 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1076 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1078 if(!s->progressive_sequence){
1080 put_bits(pb2, 1, s->interlaced_dct);
1081 put_bits(pb2, 1, 0);
1084 if(interleaved_stats){
1085 s->misc_bits+= get_bits_diff(s);
1088 /* motion vectors: 16x16 mode */
1089 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1091 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1092 motion_y - pred_y, s->f_code);
1093 }else if(s->mv_type==MV_TYPE_FIELD){
1094 if(s->dquant) cbpc+= 8;
1096 inter_MCBPC_bits[cbpc],
1097 inter_MCBPC_code[cbpc]);
1099 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1101 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1103 assert(!s->progressive_sequence);
1105 put_bits(pb2, 1, s->interlaced_dct);
1106 put_bits(pb2, 1, 1);
1108 if(interleaved_stats){
1109 s->misc_bits+= get_bits_diff(s);
1112 /* motion vectors: 16x8 interlaced mode */
1113 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1116 put_bits(&s->pb, 1, s->field_select[0][0]);
1117 put_bits(&s->pb, 1, s->field_select[0][1]);
1119 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1120 s->mv[0][0][1] - pred_y, s->f_code);
1121 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1122 s->mv[0][1][1] - pred_y, s->f_code);
1124 assert(s->mv_type==MV_TYPE_8X8);
1126 inter_MCBPC_bits[cbpc+16],
1127 inter_MCBPC_code[cbpc+16]);
1128 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1130 if(!s->progressive_sequence){
1132 put_bits(pb2, 1, s->interlaced_dct);
1135 if(interleaved_stats){
1136 s->misc_bits+= get_bits_diff(s);
1140 /* motion vectors: 8x8 mode*/
1141 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1143 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1144 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1148 if(interleaved_stats){
1149 s->mv_bits+= get_bits_diff(s);
1152 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1154 if(interleaved_stats){
1155 s->p_tex_bits+= get_bits_diff(s);
1161 int dc_diff[6]; //dc values with the dc prediction subtracted
1162 int dir[6]; //prediction direction
1163 int zigzag_last_index[6];
1164 uint8_t *scan_table[6];
1168 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1171 if(s->flags & CODEC_FLAG_AC_PRED){
1172 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1174 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1177 scan_table[i]= s->intra_scantable.permutated;
1182 for (i = 0; i < 6; i++) {
1183 if (s->block_last_index[i] >= 1)
1184 cbp |= 1 << (5 - i);
1188 if (s->pict_type == I_TYPE) {
1189 if(s->dquant) cbpc+=4;
1191 intra_MCBPC_bits[cbpc],
1192 intra_MCBPC_code[cbpc]);
1194 if(s->dquant) cbpc+=8;
1195 put_bits(&s->pb, 1, 0); /* mb coded */
1197 inter_MCBPC_bits[cbpc + 4],
1198 inter_MCBPC_code[cbpc + 4]);
1200 put_bits(pb2, 1, s->ac_pred);
1202 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1204 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1206 if(!s->progressive_sequence){
1207 put_bits(dc_pb, 1, s->interlaced_dct);
1210 if(interleaved_stats){
1211 s->misc_bits+= get_bits_diff(s);
1214 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1216 if(interleaved_stats){
1217 s->i_tex_bits+= get_bits_diff(s);
1221 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1223 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1227 void h263_encode_mb(MpegEncContext * s,
1228 DCTELEM block[6][64],
1229 int motion_x, int motion_y)
1231 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1233 int16_t rec_intradc[6];
1235 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1236 const int dquant_code[5]= {1,0,9,2,3};
1238 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1241 cbp= get_p_cbp(s, block, motion_x, motion_y);
1243 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1244 /* skip macroblock */
1245 put_bits(&s->pb, 1, 1);
1246 if(interleaved_stats){
1254 put_bits(&s->pb, 1, 0); /* mb coded */
1258 if(s->alt_inter_vlc==0 || cbpc!=3)
1260 if(s->dquant) cbpc+= 8;
1261 if(s->mv_type==MV_TYPE_16X16){
1263 inter_MCBPC_bits[cbpc],
1264 inter_MCBPC_code[cbpc]);
1266 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1268 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1270 if(interleaved_stats){
1271 s->misc_bits+= get_bits_diff(s);
1274 /* motion vectors: 16x16 mode */
1275 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1278 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1279 motion_y - pred_y, 1);
1282 h263p_encode_umotion(s, motion_x - pred_x);
1283 h263p_encode_umotion(s, motion_y - pred_y);
1284 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1285 /* To prevent Start Code emulation */
1286 put_bits(&s->pb,1,1);
1290 inter_MCBPC_bits[cbpc+16],
1291 inter_MCBPC_code[cbpc+16]);
1292 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1294 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1296 if(interleaved_stats){
1297 s->misc_bits+= get_bits_diff(s);
1301 /* motion vectors: 8x8 mode*/
1302 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1304 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1305 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1307 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1308 motion_y - pred_y, 1);
1311 h263p_encode_umotion(s, motion_x - pred_x);
1312 h263p_encode_umotion(s, motion_y - pred_y);
1313 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1314 /* To prevent Start Code emulation */
1315 put_bits(&s->pb,1,1);
1320 if(interleaved_stats){
1321 s->mv_bits+= get_bits_diff(s);
1324 assert(s->mb_intra);
1329 for(i=0; i<6; i++) {
1330 int16_t level = block[i][0];
1333 if(i<4) scale= s->y_dc_scale;
1334 else scale= s->c_dc_scale;
1336 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1340 level = (level + (scale>>1))/scale;
1342 level = (level - (scale>>1))/scale;
1344 /* AIC can change CBP */
1345 if (level == 0 && s->block_last_index[i] == 0)
1346 s->block_last_index[i] = -1;
1348 if(!s->modified_quant){
1351 else if (level > 127)
1355 block[i][0] = level;
1356 /* Reconstruction */
1357 rec_intradc[i] = scale*level + pred_dc;
1359 rec_intradc[i] |= 1;
1360 //if ((rec_intradc[i] % 2) == 0)
1361 // rec_intradc[i]++;
1363 if (rec_intradc[i] < 0)
1365 else if (rec_intradc[i] > 2047)
1366 rec_intradc[i] = 2047;
1368 /* Update AC/DC tables */
1369 *dc_ptr[i] = rec_intradc[i];
1370 if (s->block_last_index[i] >= 0)
1371 cbp |= 1 << (5 - i);
1374 for(i=0; i<6; i++) {
1376 if (s->block_last_index[i] >= 1)
1377 cbp |= 1 << (5 - i);
1382 if (s->pict_type == I_TYPE) {
1383 if(s->dquant) cbpc+=4;
1385 intra_MCBPC_bits[cbpc],
1386 intra_MCBPC_code[cbpc]);
1388 if(s->dquant) cbpc+=8;
1389 put_bits(&s->pb, 1, 0); /* mb coded */
1391 inter_MCBPC_bits[cbpc + 4],
1392 inter_MCBPC_code[cbpc + 4]);
1395 /* XXX: currently, we do not try to use ac prediction */
1396 put_bits(&s->pb, 1, 0); /* no AC prediction */
1399 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1401 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1403 if(interleaved_stats){
1404 s->misc_bits+= get_bits_diff(s);
1408 for(i=0; i<6; i++) {
1409 /* encode each block */
1410 h263_encode_block(s, block[i], i);
1412 /* Update INTRADC for decoding */
1413 if (s->h263_aic && s->mb_intra) {
1414 block[i][0] = rec_intradc[i];
1419 if(interleaved_stats){
1421 s->p_tex_bits+= get_bits_diff(s);
1424 s->i_tex_bits+= get_bits_diff(s);
1431 void ff_h263_loop_filter(MpegEncContext * s){
1433 const int linesize = s->linesize;
1434 const int uvlinesize= s->uvlinesize;
1435 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1436 uint8_t *dest_y = s->dest[0];
1437 uint8_t *dest_cb= s->dest[1];
1438 uint8_t *dest_cr= s->dest[2];
1440 // if(s->pict_type==B_TYPE && !s->readable) return;
1446 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1448 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1449 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1454 int qp_dt, qp_t, qp_tc;
1456 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1459 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1467 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1468 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1469 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1471 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1472 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1476 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1479 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1482 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1485 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1486 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1487 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1488 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1494 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1495 if(s->mb_y + 1 == s->mb_height)
1496 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1501 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1504 qp_lc= s->current_picture.qscale_table[xy-1];
1507 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1508 if(s->mb_y + 1 == s->mb_height){
1509 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1510 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1511 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1512 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1518 #ifdef CONFIG_ENCODERS
1519 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1521 int x, y, wrap, a, c, pred_dc, scale;
1524 /* find prediction */
1526 x = 2 * s->mb_x + (n & 1);
1527 y = 2 * s->mb_y + ((n & 2) >> 1);
1528 wrap = s->b8_stride;
1529 dc_val = s->dc_val[0];
1530 scale = s->y_dc_scale;
1534 wrap = s->mb_stride;
1535 dc_val = s->dc_val[n - 4 + 1];
1536 scale = s->c_dc_scale;
1541 a = dc_val[(x - 1) + (y) * wrap];
1542 c = dc_val[(x) + (y - 1) * wrap];
1544 /* No prediction outside GOB boundary */
1545 if(s->first_slice_line && n!=3){
1547 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1550 /* just DC prediction */
1551 if (a != 1024 && c != 1024)
1552 pred_dc = (a + c) >> 1;
1558 /* we assume pred is positive */
1559 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1560 *dc_val_ptr = &dc_val[x + y * wrap];
1563 #endif /* CONFIG_ENCODERS */
1565 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1567 int x, y, wrap, a, c, pred_dc, scale, i;
1568 int16_t *dc_val, *ac_val, *ac_val1;
1570 /* find prediction */
1572 x = 2 * s->mb_x + (n & 1);
1573 y = 2 * s->mb_y + (n>> 1);
1574 wrap = s->b8_stride;
1575 dc_val = s->dc_val[0];
1576 ac_val = s->ac_val[0][0];
1577 scale = s->y_dc_scale;
1581 wrap = s->mb_stride;
1582 dc_val = s->dc_val[n - 4 + 1];
1583 ac_val = s->ac_val[n - 4 + 1][0];
1584 scale = s->c_dc_scale;
1587 ac_val += ((y) * wrap + (x)) * 16;
1593 a = dc_val[(x - 1) + (y) * wrap];
1594 c = dc_val[(x) + (y - 1) * wrap];
1596 /* No prediction outside GOB boundary */
1597 if(s->first_slice_line && n!=3){
1599 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1604 if (s->h263_aic_dir) {
1605 /* left prediction */
1609 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1614 /* top prediction */
1616 ac_val -= 16 * wrap;
1618 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1624 /* just DC prediction */
1625 if (a != 1024 && c != 1024)
1626 pred_dc = (a + c) >> 1;
1633 /* we assume pred is positive */
1634 block[0]=block[0]*scale + pred_dc;
1641 /* Update AC/DC tables */
1642 dc_val[(x) + (y) * wrap] = block[0];
1646 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1649 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1652 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1656 int16_t *A, *B, *C, (*mot_val)[2];
1657 static const int off[4]= {2, 1, 1, -1};
1659 wrap = s->b8_stride;
1660 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1663 /* special case for first (slice) line */
1664 if (s->first_slice_line && block<3) {
1665 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1666 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1667 if(block==0){ //most common case
1668 if(s->mb_x == s->resync_mb_x){ //rare
1670 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1671 C = mot_val[off[block] - wrap];
1676 *px = mid_pred(A[0], 0, C[0]);
1677 *py = mid_pred(A[1], 0, C[1]);
1684 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1685 C = mot_val[off[block] - wrap];
1686 *px = mid_pred(A[0], 0, C[0]);
1687 *py = mid_pred(A[1], 0, C[1]);
1692 }else{ /* block==2*/
1693 B = mot_val[ - wrap];
1694 C = mot_val[off[block] - wrap];
1695 if(s->mb_x == s->resync_mb_x) //rare
1698 *px = mid_pred(A[0], B[0], C[0]);
1699 *py = mid_pred(A[1], B[1], C[1]);
1702 B = mot_val[ - wrap];
1703 C = mot_val[off[block] - wrap];
1704 *px = mid_pred(A[0], B[0], C[0]);
1705 *py = mid_pred(A[1], B[1], C[1]);
1710 #ifdef CONFIG_ENCODERS
1711 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1713 int range, l, bit_size, sign, code, bits;
1718 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1720 bit_size = f_code - 1;
1721 range = 1 << bit_size;
1722 /* modulo encoding */
1723 l= INT_BIT - 6 - bit_size;
1726 val= (val^sign)-sign;
1730 code = (val >> bit_size) + 1;
1731 bits = val & (range - 1);
1733 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1735 put_bits(&s->pb, bit_size, bits);
1740 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1741 static void h263p_encode_umotion(MpegEncContext * s, int val)
1751 put_bits(&s->pb, 1, 1);
1753 put_bits(&s->pb, 3, 0);
1755 put_bits(&s->pb, 3, 2);
1758 sval = ((val < 0) ? (short)(-val):(short)val);
1761 while (temp_val != 0) {
1762 temp_val = temp_val >> 1;
1768 tcode = (sval & (1 << (i-1))) >> (i-1);
1769 tcode = (tcode << 1) | 1;
1770 code = (code << 2) | tcode;
1773 code = ((code << 1) | (val < 0)) << 1;
1774 put_bits(&s->pb, (2*n_bits)+1, code);
1775 //printf("\nVal = %d\tCode = %d", sval, code);
1779 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1784 if(mv_penalty==NULL)
1785 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1787 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1788 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1791 if(mv==0) len= mvtab[0][1];
1793 int val, bit_size, range, code;
1795 bit_size = f_code - 1;
1796 range = 1 << bit_size;
1802 code = (val >> bit_size) + 1;
1804 len= mvtab[code][1] + 1 + bit_size;
1806 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1810 mv_penalty[f_code][mv+MAX_MV]= len;
1814 for(f_code=MAX_FCODE; f_code>0; f_code--){
1815 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1816 fcode_tab[mv+MAX_MV]= f_code;
1820 for(mv=0; mv<MAX_MV*2+1; mv++){
1821 umv_fcode_tab[mv]= 1;
1826 #ifdef CONFIG_ENCODERS
1828 static void init_uni_dc_tab(void)
1830 int level, uni_code, uni_len;
1832 for(level=-256; level<256; level++){
1834 /* find number of bits */
1843 l= (-level) ^ ((1 << size) - 1);
1848 uni_code= DCtab_lum[size][0];
1849 uni_len = DCtab_lum[size][1];
1852 uni_code<<=size; uni_code|=l;
1855 uni_code<<=1; uni_code|=1;
1859 uni_DCtab_lum_bits[level+256]= uni_code;
1860 uni_DCtab_lum_len [level+256]= uni_len;
1863 uni_code= DCtab_chrom[size][0];
1864 uni_len = DCtab_chrom[size][1];
1867 uni_code<<=size; uni_code|=l;
1870 uni_code<<=1; uni_code|=1;
1874 uni_DCtab_chrom_bits[level+256]= uni_code;
1875 uni_DCtab_chrom_len [level+256]= uni_len;
1880 #endif //CONFIG_ENCODERS
1882 #ifdef CONFIG_ENCODERS
1883 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1884 int slevel, run, last;
1886 assert(MAX_LEVEL >= 64);
1887 assert(MAX_RUN >= 63);
1889 for(slevel=-64; slevel<64; slevel++){
1890 if(slevel==0) continue;
1891 for(run=0; run<64; run++){
1892 for(last=0; last<=1; last++){
1893 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1894 int level= slevel < 0 ? -slevel : slevel;
1895 int sign= slevel < 0 ? 1 : 0;
1896 int bits, len, code;
1899 len_tab[index]= 100;
1902 code= get_rl_index(rl, last, run, level);
1903 bits= rl->table_vlc[code][0];
1904 len= rl->table_vlc[code][1];
1905 bits=bits*2+sign; len++;
1907 if(code!=rl->n && len < len_tab[index]){
1908 bits_tab[index]= bits;
1909 len_tab [index]= len;
1913 bits= rl->table_vlc[rl->n][0];
1914 len= rl->table_vlc[rl->n][1];
1915 bits=bits*2; len++; //esc1
1916 level1= level - rl->max_level[last][run];
1918 code= get_rl_index(rl, last, run, level1);
1919 bits<<= rl->table_vlc[code][1];
1920 len += rl->table_vlc[code][1];
1921 bits += rl->table_vlc[code][0];
1922 bits=bits*2+sign; len++;
1924 if(code!=rl->n && len < len_tab[index]){
1925 bits_tab[index]= bits;
1926 len_tab [index]= len;
1932 bits= rl->table_vlc[rl->n][0];
1933 len= rl->table_vlc[rl->n][1];
1934 bits=bits*4+2; len+=2; //esc2
1935 run1 = run - rl->max_run[last][level] - 1;
1937 code= get_rl_index(rl, last, run1, level);
1938 bits<<= rl->table_vlc[code][1];
1939 len += rl->table_vlc[code][1];
1940 bits += rl->table_vlc[code][0];
1941 bits=bits*2+sign; len++;
1943 if(code!=rl->n && len < len_tab[index]){
1944 bits_tab[index]= bits;
1945 len_tab [index]= len;
1950 bits= rl->table_vlc[rl->n][0];
1951 len = rl->table_vlc[rl->n][1];
1952 bits=bits*4+3; len+=2; //esc3
1953 bits=bits*2+last; len++;
1954 bits=bits*64+run; len+=6;
1955 bits=bits*2+1; len++; //marker
1956 bits=bits*4096+(slevel&0xfff); len+=12;
1957 bits=bits*2+1; len++; //marker
1959 if(len < len_tab[index]){
1960 bits_tab[index]= bits;
1961 len_tab [index]= len;
1968 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1969 int slevel, run, last;
1971 assert(MAX_LEVEL >= 64);
1972 assert(MAX_RUN >= 63);
1974 for(slevel=-64; slevel<64; slevel++){
1975 if(slevel==0) continue;
1976 for(run=0; run<64; run++){
1977 for(last=0; last<=1; last++){
1978 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1979 int level= slevel < 0 ? -slevel : slevel;
1980 int sign= slevel < 0 ? 1 : 0;
1981 int bits, len, code;
1983 len_tab[index]= 100;
1986 code= get_rl_index(rl, last, run, level);
1987 bits= rl->table_vlc[code][0];
1988 len= rl->table_vlc[code][1];
1989 bits=bits*2+sign; len++;
1991 if(code!=rl->n && len < len_tab[index]){
1992 if(bits_tab) bits_tab[index]= bits;
1993 len_tab [index]= len;
1996 bits= rl->table_vlc[rl->n][0];
1997 len = rl->table_vlc[rl->n][1];
1998 bits=bits*2+last; len++;
1999 bits=bits*64+run; len+=6;
2000 bits=bits*256+(level&0xff); len+=8;
2002 if(len < len_tab[index]){
2003 if(bits_tab) bits_tab[index]= bits;
2004 len_tab [index]= len;
2011 void h263_encode_init(MpegEncContext *s)
2013 static int done = 0;
2020 init_rl(&rl_inter, 1);
2021 init_rl(&rl_intra, 1);
2022 init_rl(&rl_intra_aic, 1);
2024 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2025 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2027 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2028 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2030 init_mv_penalty_and_fcode(s);
2032 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2034 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2035 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2037 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2038 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2040 s->ac_esc_length= 7+1+6+8;
2042 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2043 switch(s->codec_id){
2044 case CODEC_ID_MPEG4:
2045 s->fcode_tab= fcode_tab;
2046 s->min_qcoeff= -2048;
2047 s->max_qcoeff= 2047;
2048 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2049 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2050 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2051 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2052 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2053 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2054 s->ac_esc_length= 7+2+1+6+1+12+1;
2055 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2056 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2058 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2060 s->avctx->extradata= av_malloc(1024);
2061 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2063 if(!(s->workaround_bugs & FF_BUG_MS))
2064 mpeg4_encode_visual_object_header(s);
2065 mpeg4_encode_vol_header(s, 0, 0);
2067 // ff_mpeg4_stuffing(&s->pb); ?
2068 flush_put_bits(&s->pb);
2069 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2073 case CODEC_ID_H263P:
2075 s->fcode_tab= umv_fcode_tab;
2076 if(s->modified_quant){
2077 s->min_qcoeff= -2047;
2078 s->max_qcoeff= 2047;
2080 s->min_qcoeff= -127;
2084 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2086 if (s->h263_flv > 1) {
2087 s->min_qcoeff= -1023;
2088 s->max_qcoeff= 1023;
2090 s->min_qcoeff= -127;
2093 s->y_dc_scale_table=
2094 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2096 default: //nothing needed - default table already set in mpegvideo.c
2097 s->min_qcoeff= -127;
2099 s->y_dc_scale_table=
2100 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2105 * encodes a 8x8 block.
2106 * @param block the 8x8 block
2107 * @param n block index (0-3 are luma, 4-5 are chroma)
2109 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2111 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2115 if (s->mb_intra && !s->h263_aic) {
2118 /* 255 cannot be represented, so we clamp */
2123 /* 0 cannot be represented also */
2124 else if (level < 1) {
2128 if (level == 128) //FIXME check rv10
2129 put_bits(&s->pb, 8, 0xff);
2131 put_bits(&s->pb, 8, level);
2135 if (s->h263_aic && s->mb_intra)
2138 if(s->alt_inter_vlc && !s->mb_intra){
2140 int inter_vlc_bits=0;
2144 last_index = s->block_last_index[n];
2145 last_non_zero = i - 1;
2146 for (; i <= last_index; i++) {
2147 j = s->intra_scantable.permutated[i];
2150 run = i - last_non_zero - 1;
2151 last = (i == last_index);
2153 if(level<0) level= -level;
2155 code = get_rl_index(rl, last, run, level);
2156 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2157 inter_vlc_bits += rl->table_vlc[code][1]+1;
2158 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2160 if (code == rl->n) {
2161 inter_vlc_bits += 1+6+8-1;
2163 if (aic_code == rl_intra_aic.n) {
2164 aic_vlc_bits += 1+6+8-1;
2165 wrong_pos += run + 1;
2167 wrong_pos += wrong_run[aic_code];
2172 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2178 last_index = s->block_last_index[n];
2179 last_non_zero = i - 1;
2180 for (; i <= last_index; i++) {
2181 j = s->intra_scantable.permutated[i];
2184 run = i - last_non_zero - 1;
2185 last = (i == last_index);
2192 code = get_rl_index(rl, last, run, level);
2193 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2194 if (code == rl->n) {
2195 if(s->h263_flv <= 1){
2196 put_bits(&s->pb, 1, last);
2197 put_bits(&s->pb, 6, run);
2199 assert(slevel != 0);
2202 put_bits(&s->pb, 8, slevel & 0xff);
2204 put_bits(&s->pb, 8, 128);
2205 put_bits(&s->pb, 5, slevel & 0x1f);
2206 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2209 if(level < 64) { // 7-bit level
2210 put_bits(&s->pb, 1, 0);
2211 put_bits(&s->pb, 1, last);
2212 put_bits(&s->pb, 6, run);
2214 put_bits(&s->pb, 7, slevel & 0x7f);
2217 put_bits(&s->pb, 1, 1);
2218 put_bits(&s->pb, 1, last);
2219 put_bits(&s->pb, 6, run);
2221 put_bits(&s->pb, 11, slevel & 0x7ff);
2225 put_bits(&s->pb, 1, sign);
2233 #ifdef CONFIG_ENCODERS
2235 /***************************************************/
2237 * add mpeg4 stuffing bits (01...1)
2239 void ff_mpeg4_stuffing(PutBitContext * pbc)
2242 put_bits(pbc, 1, 0);
2243 length= (-put_bits_count(pbc))&7;
2244 if(length) put_bits(pbc, length, (1<<length)-1);
2247 /* must be called before writing the header */
2248 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2249 int time_div, time_mod;
2251 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2252 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2254 time_div= s->time/s->avctx->time_base.den;
2255 time_mod= s->time%s->avctx->time_base.den;
2257 if(s->pict_type==B_TYPE){
2258 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2259 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2260 ff_mpeg4_init_direct_mv(s);
2262 s->last_time_base= s->time_base;
2263 s->time_base= time_div;
2264 s->pp_time= s->time - s->last_non_b_time;
2265 s->last_non_b_time= s->time;
2266 assert(picture_number==0 || s->pp_time > 0);
2270 static void mpeg4_encode_gop_header(MpegEncContext * s){
2271 int hours, minutes, seconds;
2274 put_bits(&s->pb, 16, 0);
2275 put_bits(&s->pb, 16, GOP_STARTCODE);
2277 time= s->current_picture_ptr->pts;
2278 if(s->reordered_input_picture[1])
2279 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2280 time= time*s->avctx->time_base.num;
2282 seconds= time/s->avctx->time_base.den;
2283 minutes= seconds/60; seconds %= 60;
2284 hours= minutes/60; minutes %= 60;
2287 put_bits(&s->pb, 5, hours);
2288 put_bits(&s->pb, 6, minutes);
2289 put_bits(&s->pb, 1, 1);
2290 put_bits(&s->pb, 6, seconds);
2292 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2293 put_bits(&s->pb, 1, 0); //broken link == NO
2295 s->last_time_base= time / s->avctx->time_base.den;
2297 ff_mpeg4_stuffing(&s->pb);
2300 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2301 int profile_and_level_indication;
2304 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2305 profile_and_level_indication = s->avctx->profile << 4;
2306 }else if(s->max_b_frames || s->quarter_sample){
2307 profile_and_level_indication= 0xF0; // adv simple
2309 profile_and_level_indication= 0x00; // simple
2312 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2313 profile_and_level_indication |= s->avctx->level;
2315 profile_and_level_indication |= 1; //level 1
2318 if(profile_and_level_indication>>4 == 0xF){
2326 put_bits(&s->pb, 16, 0);
2327 put_bits(&s->pb, 16, VOS_STARTCODE);
2329 put_bits(&s->pb, 8, profile_and_level_indication);
2331 put_bits(&s->pb, 16, 0);
2332 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2334 put_bits(&s->pb, 1, 1);
2335 put_bits(&s->pb, 4, vo_ver_id);
2336 put_bits(&s->pb, 3, 1); //priority
2338 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2340 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2342 ff_mpeg4_stuffing(&s->pb);
2345 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2349 if(s->max_b_frames || s->quarter_sample){
2351 s->vo_type= ADV_SIMPLE_VO_TYPE;
2354 s->vo_type= SIMPLE_VO_TYPE;
2357 put_bits(&s->pb, 16, 0);
2358 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2359 put_bits(&s->pb, 16, 0);
2360 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2362 put_bits(&s->pb, 1, 0); /* random access vol */
2363 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2364 if(s->workaround_bugs & FF_BUG_MS) {
2365 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2367 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2368 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2369 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2372 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2374 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2375 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2376 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2377 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2380 if(s->workaround_bugs & FF_BUG_MS) { //
2381 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2383 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2384 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2385 put_bits(&s->pb, 1, s->low_delay);
2386 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2389 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2390 put_bits(&s->pb, 1, 1); /* marker bit */
2392 put_bits(&s->pb, 16, s->avctx->time_base.den);
2393 if (s->time_increment_bits < 1)
2394 s->time_increment_bits = 1;
2395 put_bits(&s->pb, 1, 1); /* marker bit */
2396 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2397 put_bits(&s->pb, 1, 1); /* marker bit */
2398 put_bits(&s->pb, 13, s->width); /* vol width */
2399 put_bits(&s->pb, 1, 1); /* marker bit */
2400 put_bits(&s->pb, 13, s->height); /* vol height */
2401 put_bits(&s->pb, 1, 1); /* marker bit */
2402 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2403 put_bits(&s->pb, 1, 1); /* obmc disable */
2404 if (vo_ver_id == 1) {
2405 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2407 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2410 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2411 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2414 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2415 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2419 put_bits(&s->pb, 1, s->quarter_sample);
2420 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2421 s->resync_marker= s->rtp_mode;
2422 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2423 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2424 if(s->data_partitioning){
2425 put_bits(&s->pb, 1, 0); /* no rvlc */
2428 if (vo_ver_id != 1){
2429 put_bits(&s->pb, 1, 0); /* newpred */
2430 put_bits(&s->pb, 1, 0); /* reduced res vop */
2432 put_bits(&s->pb, 1, 0); /* scalability */
2434 ff_mpeg4_stuffing(&s->pb);
2437 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2438 put_bits(&s->pb, 16, 0);
2439 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2440 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2444 /* write mpeg4 VOP header */
2445 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2448 int time_div, time_mod;
2450 if(s->pict_type==I_TYPE){
2451 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2452 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2453 mpeg4_encode_visual_object_header(s);
2454 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2455 mpeg4_encode_vol_header(s, 0, 0);
2457 if(!(s->workaround_bugs & FF_BUG_MS))
2458 mpeg4_encode_gop_header(s);
2461 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2463 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2465 put_bits(&s->pb, 16, 0); /* vop header */
2466 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2467 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2470 time_div= s->time/s->avctx->time_base.den;
2471 time_mod= s->time%s->avctx->time_base.den;
2472 time_incr= time_div - s->last_time_base;
2473 assert(time_incr >= 0);
2475 put_bits(&s->pb, 1, 1);
2477 put_bits(&s->pb, 1, 0);
2479 put_bits(&s->pb, 1, 1); /* marker */
2480 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2481 put_bits(&s->pb, 1, 1); /* marker */
2482 put_bits(&s->pb, 1, 1); /* vop coded */
2483 if ( s->pict_type == P_TYPE
2484 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2485 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2487 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2488 if(!s->progressive_sequence){
2489 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2490 put_bits(&s->pb, 1, s->alternate_scan);
2492 //FIXME sprite stuff
2494 put_bits(&s->pb, 5, s->qscale);
2496 if (s->pict_type != I_TYPE)
2497 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2498 if (s->pict_type == B_TYPE)
2499 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2500 // printf("****frame %d\n", picture_number);
2503 #endif //CONFIG_ENCODERS
2506 * set qscale and update qscale dependant variables.
2508 void ff_set_qscale(MpegEncContext * s, int qscale)
2512 else if (qscale > 31)
2516 s->chroma_qscale= s->chroma_qscale_table[qscale];
2518 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2519 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2524 * encoding quantized level -> quantized diff
2525 * decoding quantized diff -> quantized level
2526 * @param n block index (0-3 are luma, 4-5 are chroma)
2527 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2529 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2531 int a, b, c, wrap, pred, scale, ret;
2534 /* find prediction */
2536 scale = s->y_dc_scale;
2538 scale = s->c_dc_scale;
2543 wrap= s->block_wrap[n];
2544 dc_val = s->dc_val[0] + s->block_index[n];
2550 b = dc_val[ - 1 - wrap];
2551 c = dc_val[ - wrap];
2553 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2554 if(s->first_slice_line && n!=3){
2556 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2558 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2559 if(n==0 || n==4 || n==5)
2563 if (abs(a - b) < abs(b - c)) {
2565 *dir_ptr = 1; /* top */
2568 *dir_ptr = 0; /* left */
2570 /* we assume pred is positive */
2571 pred = FASTDIV((pred + (scale >> 1)), scale);
2578 if(s->error_resilience>=3){
2580 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2583 if(level*scale > 2048 + scale){
2584 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2593 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2603 * @param n block index (0-3 are luma, 4-5 are chroma)
2604 * @param dir the ac prediction direction
2606 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2610 int16_t *ac_val, *ac_val1;
2611 int8_t * const qscale_table= s->current_picture.qscale_table;
2613 /* find prediction */
2614 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2618 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2619 /* left prediction */
2622 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2625 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2628 /* different qscale, we must rescale */
2630 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2634 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2635 /* top prediction */
2636 ac_val -= 16 * s->block_wrap[n];
2638 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2641 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2644 /* different qscale, we must rescale */
2646 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2653 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2657 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2661 #ifdef CONFIG_ENCODERS
2664 * encodes the dc value.
2665 * @param n block index (0-3 are luma, 4-5 are chroma)
2667 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2670 // if(level<-255 || level>255) printf("dc overflow\n");
2674 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2677 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2681 /* find number of bits */
2691 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2694 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2697 /* encode remaining bits */
2700 level = (-level) ^ ((1 << size) - 1);
2701 put_bits(&s->pb, size, level);
2703 put_bits(&s->pb, 1, 1);
2708 static inline int mpeg4_get_dc_length(int level, int n){
2710 return uni_DCtab_lum_len[level + 256];
2712 return uni_DCtab_chrom_len[level + 256];
2717 * encodes a 8x8 block
2718 * @param n block index (0-3 are luma, 4-5 are chroma)
2720 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2721 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2723 int i, last_non_zero;
2724 #if 0 //variables for the outcommented version
2725 int code, sign, last;
2730 const int last_index = s->block_last_index[n];
2732 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2733 /* mpeg4 based DC predictor */
2734 mpeg4_encode_dc(dc_pb, intra_dc, n);
2735 if(last_index<1) return;
2738 bits_tab= uni_mpeg4_intra_rl_bits;
2739 len_tab = uni_mpeg4_intra_rl_len;
2741 if(last_index<0) return;
2744 bits_tab= uni_mpeg4_inter_rl_bits;
2745 len_tab = uni_mpeg4_inter_rl_len;
2749 last_non_zero = i - 1;
2751 for (; i < last_index; i++) {
2752 int level = block[ scan_table[i] ];
2754 int run = i - last_non_zero - 1;
2756 if((level&(~127)) == 0){
2757 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2758 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2760 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);
2765 /*if(i<=last_index)*/{
2766 int level = block[ scan_table[i] ];
2767 int run = i - last_non_zero - 1;
2769 if((level&(~127)) == 0){
2770 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2771 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2773 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);
2777 for (; i <= last_index; i++) {
2778 const int slevel = block[ scan_table[i] ];
2781 int run = i - last_non_zero - 1;
2782 last = (i == last_index);
2789 code = get_rl_index(rl, last, run, level);
2790 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2791 if (code == rl->n) {
2793 level1 = level - rl->max_level[last][run];
2796 code = get_rl_index(rl, last, run, level1);
2797 if (code == rl->n) {
2799 put_bits(ac_pb, 1, 1);
2800 if (level > MAX_LEVEL)
2802 run1 = run - rl->max_run[last][level] - 1;
2805 code = get_rl_index(rl, last, run1, level);
2806 if (code == rl->n) {
2809 put_bits(ac_pb, 1, 1);
2810 put_bits(ac_pb, 1, last);
2811 put_bits(ac_pb, 6, run);
2812 put_bits(ac_pb, 1, 1);
2813 put_bits(ac_pb, 12, slevel & 0xfff);
2814 put_bits(ac_pb, 1, 1);
2817 put_bits(ac_pb, 1, 0);
2818 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2819 put_bits(ac_pb, 1, sign);
2823 put_bits(ac_pb, 1, 0);
2824 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2825 put_bits(ac_pb, 1, sign);
2828 put_bits(ac_pb, 1, sign);
2836 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2837 uint8_t *scan_table)
2839 int i, last_non_zero;
2842 const int last_index = s->block_last_index[n];
2845 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2846 /* mpeg4 based DC predictor */
2847 len += mpeg4_get_dc_length(intra_dc, n);
2848 if(last_index<1) return len;
2851 len_tab = uni_mpeg4_intra_rl_len;
2853 if(last_index<0) return 0;
2856 len_tab = uni_mpeg4_inter_rl_len;
2860 last_non_zero = i - 1;
2861 for (; i < last_index; i++) {
2862 int level = block[ scan_table[i] ];
2864 int run = i - last_non_zero - 1;
2866 if((level&(~127)) == 0){
2867 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2868 len += len_tab[index];
2870 len += 7+2+1+6+1+12+1;
2875 /*if(i<=last_index)*/{
2876 int level = block[ scan_table[i] ];
2877 int run = i - last_non_zero - 1;
2879 if((level&(~127)) == 0){
2880 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2881 len += len_tab[index];
2883 len += 7+2+1+6+1+12+1;
2893 /***********************************************/
2896 static VLC intra_MCBPC_vlc;
2897 static VLC inter_MCBPC_vlc;
2898 static VLC cbpy_vlc;
2900 static VLC dc_lum, dc_chrom;
2901 static VLC sprite_trajectory;
2902 static VLC mb_type_b_vlc;
2903 static VLC h263_mbtype_b_vlc;
2904 static VLC cbpc_b_vlc;
2906 void init_vlc_rl(RLTable *rl, int use_static)
2910 /* Return if static table is already initialized */
2911 if(use_static && rl->rl_vlc[0])
2914 init_vlc(&rl->vlc, 9, rl->n + 1,
2915 &rl->table_vlc[0][1], 4, 2,
2916 &rl->table_vlc[0][0], 4, 2, use_static);
2919 for(q=0; q<32; q++){
2928 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2930 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2931 for(i=0; i<rl->vlc.table_size; i++){
2932 int code= rl->vlc.table[i][0];
2933 int len = rl->vlc.table[i][1];
2936 if(len==0){ // illegal code
2939 }else if(len<0){ //more bits needed
2943 if(code==rl->n){ //esc
2947 run= rl->table_run [code] + 1;
2948 level= rl->table_level[code] * qmul + qadd;
2949 if(code >= rl->last) run+=192;
2952 rl->rl_vlc[q][i].len= len;
2953 rl->rl_vlc[q][i].level= level;
2954 rl->rl_vlc[q][i].run= run;
2961 /* XXX: find a better solution to handle static init */
2962 void h263_decode_init_vlc(MpegEncContext *s)
2964 static int done = 0;
2969 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2970 intra_MCBPC_bits, 1, 1,
2971 intra_MCBPC_code, 1, 1, 1);
2972 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2973 inter_MCBPC_bits, 1, 1,
2974 inter_MCBPC_code, 1, 1, 1);
2975 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2976 &cbpy_tab[0][1], 2, 1,
2977 &cbpy_tab[0][0], 2, 1, 1);
2978 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2980 &mvtab[0][0], 2, 1, 1);
2981 init_rl(&rl_inter, 1);
2982 init_rl(&rl_intra, 1);
2983 init_rl(&rvlc_rl_inter, 1);
2984 init_rl(&rvlc_rl_intra, 1);
2985 init_rl(&rl_intra_aic, 1);
2986 init_vlc_rl(&rl_inter, 1);
2987 init_vlc_rl(&rl_intra, 1);
2988 init_vlc_rl(&rvlc_rl_inter, 1);
2989 init_vlc_rl(&rvlc_rl_intra, 1);
2990 init_vlc_rl(&rl_intra_aic, 1);
2991 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2992 &DCtab_lum[0][1], 2, 1,
2993 &DCtab_lum[0][0], 2, 1, 1);
2994 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2995 &DCtab_chrom[0][1], 2, 1,
2996 &DCtab_chrom[0][0], 2, 1, 1);
2997 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2998 &sprite_trajectory_tab[0][1], 4, 2,
2999 &sprite_trajectory_tab[0][0], 4, 2, 1);
3000 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3001 &mb_type_b_tab[0][1], 2, 1,
3002 &mb_type_b_tab[0][0], 2, 1, 1);
3003 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3004 &h263_mbtype_b_tab[0][1], 2, 1,
3005 &h263_mbtype_b_tab[0][0], 2, 1, 1);
3006 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3007 &cbpc_b_tab[0][1], 2, 1,
3008 &cbpc_b_tab[0][0], 2, 1, 1);
3013 * Get the GOB height based on picture height.
3015 int ff_h263_get_gob_height(MpegEncContext *s){
3016 if (s->height <= 400)
3018 else if (s->height <= 800)
3024 int ff_h263_decode_mba(MpegEncContext *s)
3029 if(s->mb_num-1 <= ff_mba_max[i]) break;
3031 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3032 s->mb_x= mb_pos % s->mb_width;
3033 s->mb_y= mb_pos / s->mb_width;
3038 void ff_h263_encode_mba(MpegEncContext *s)
3043 if(s->mb_num-1 <= ff_mba_max[i]) break;
3045 mb_pos= s->mb_x + s->mb_width*s->mb_y;
3046 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3050 * decodes the group of blocks header or slice header.
3051 * @return <0 if an error occured
3053 static int h263_decode_gob_header(MpegEncContext *s)
3055 unsigned int val, gfid, gob_number;
3058 /* Check for GOB Start Code */
3059 val = show_bits(&s->gb, 16);
3063 /* We have a GBSC probably with GSTUFF */
3064 skip_bits(&s->gb, 16); /* Drop the zeros */
3065 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3066 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3067 for(;left>13; left--){
3068 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3073 if(s->h263_slice_structured){
3074 if(get_bits1(&s->gb)==0)
3077 ff_h263_decode_mba(s);
3079 if(s->mb_num > 1583)
3080 if(get_bits1(&s->gb)==0)
3083 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3084 if(get_bits1(&s->gb)==0)
3086 gfid = get_bits(&s->gb, 2); /* GFID */
3088 gob_number = get_bits(&s->gb, 5); /* GN */
3090 s->mb_y= s->gob_index* gob_number;
3091 gfid = get_bits(&s->gb, 2); /* GFID */
3092 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3095 if(s->mb_y >= s->mb_height)
3104 static inline void memsetw(short *tab, int val, int n)
3111 #ifdef CONFIG_ENCODERS
3113 void ff_mpeg4_init_partitions(MpegEncContext *s)
3115 uint8_t *start= pbBufPtr(&s->pb);
3116 uint8_t *end= s->pb.buf_end;
3117 int size= end - start;
3118 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3119 int tex_size= (size - 2*pb_size)&(~3);
3121 set_put_bits_buffer_size(&s->pb, pb_size);
3122 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3123 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3126 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3128 const int pb2_len = put_bits_count(&s->pb2 );
3129 const int tex_pb_len= put_bits_count(&s->tex_pb);
3130 const int bits= put_bits_count(&s->pb);
3132 if(s->pict_type==I_TYPE){
3133 put_bits(&s->pb, 19, DC_MARKER);
3134 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3135 s->i_tex_bits+= tex_pb_len;
3137 put_bits(&s->pb, 17, MOTION_MARKER);
3138 s->misc_bits+=17 + pb2_len;
3139 s->mv_bits+= bits - s->last_bits;
3140 s->p_tex_bits+= tex_pb_len;
3143 flush_put_bits(&s->pb2);
3144 flush_put_bits(&s->tex_pb);
3146 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3147 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3148 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3149 s->last_bits= put_bits_count(&s->pb);
3152 #endif //CONFIG_ENCODERS
3154 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3155 switch(s->pict_type){
3160 return s->f_code+15;
3162 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3168 #ifdef CONFIG_ENCODERS
3170 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3172 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3174 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3175 put_bits(&s->pb, 1, 1);
3177 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3178 put_bits(&s->pb, s->quant_precision, s->qscale);
3179 put_bits(&s->pb, 1, 0); /* no HEC */
3182 #endif //CONFIG_ENCODERS
3185 * check if the next stuff is a resync marker or the end.
3188 static inline int mpeg4_is_resync(MpegEncContext *s){
3189 const int bits_count= get_bits_count(&s->gb);
3191 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3195 if(bits_count + 8 >= s->gb.size_in_bits){
3196 int v= show_bits(&s->gb, 8);
3197 v|= 0x7F >> (7-(bits_count&7));
3202 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3204 GetBitContext gb= s->gb;
3206 skip_bits(&s->gb, 1);
3207 align_get_bits(&s->gb);
3209 for(len=0; len<32; len++){
3210 if(get_bits1(&s->gb)) break;
3215 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3223 * decodes the next video packet.
3224 * @return <0 if something went wrong
3226 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3228 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3229 int header_extension=0, mb_num, len;
3231 /* is there enough space left for a video packet + header */
3232 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3234 for(len=0; len<32; len++){
3235 if(get_bits1(&s->gb)) break;
3238 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3239 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3243 if(s->shape != RECT_SHAPE){
3244 header_extension= get_bits1(&s->gb);
3245 //FIXME more stuff here
3248 mb_num= get_bits(&s->gb, mb_num_bits);
3249 if(mb_num>=s->mb_num){
3250 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3253 if(s->pict_type == B_TYPE){
3254 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3255 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3258 s->mb_x= mb_num % s->mb_width;
3259 s->mb_y= mb_num / s->mb_width;
3261 if(s->shape != BIN_ONLY_SHAPE){
3262 int qscale= get_bits(&s->gb, s->quant_precision);
3264 s->chroma_qscale=s->qscale= qscale;
3267 if(s->shape == RECT_SHAPE){
3268 header_extension= get_bits1(&s->gb);
3270 if(header_extension){
3274 while (get_bits1(&s->gb) != 0)
3277 check_marker(&s->gb, "before time_increment in video packed header");
3278 time_increment= get_bits(&s->gb, s->time_increment_bits);
3279 check_marker(&s->gb, "before vop_coding_type in video packed header");
3281 skip_bits(&s->gb, 2); /* vop coding type */
3282 //FIXME not rect stuff here
3284 if(s->shape != BIN_ONLY_SHAPE){
3285 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3286 //FIXME don't just ignore everything
3287 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3288 mpeg4_decode_sprite_trajectory(s, &s->gb);
3289 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3292 //FIXME reduced res stuff here
3294 if (s->pict_type != I_TYPE) {
3295 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3297 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3300 if (s->pict_type == B_TYPE) {
3301 int b_code = get_bits(&s->gb, 3);
3303 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3308 //FIXME new-pred stuff
3310 //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));
3315 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3317 int c_wrap, c_xy, l_wrap, l_xy;
3319 l_wrap= s->b8_stride;
3320 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3321 c_wrap= s->mb_stride;
3322 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3326 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3327 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3328 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3332 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3333 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3334 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3337 // we can't clear the MVs as they might be needed by a b frame
3338 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3339 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3340 s->last_mv[0][0][0]=
3341 s->last_mv[0][0][1]=
3342 s->last_mv[1][0][0]=
3343 s->last_mv[1][0][1]= 0;
3347 * decodes the group of blocks / video packet header.
3348 * @return <0 if no resync found
3350 int ff_h263_resync(MpegEncContext *s){
3353 if(s->codec_id==CODEC_ID_MPEG4){
3355 align_get_bits(&s->gb);
3358 if(show_bits(&s->gb, 16)==0){
3359 if(s->codec_id==CODEC_ID_MPEG4)
3360 ret= mpeg4_decode_video_packet_header(s);
3362 ret= h263_decode_gob_header(s);
3366 //ok, it's not where its supposed to be ...
3367 s->gb= s->last_resync_gb;
3368 align_get_bits(&s->gb);
3369 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3371 for(;left>16+1+5+5; left-=8){
3372 if(show_bits(&s->gb, 16)==0){
3373 GetBitContext bak= s->gb;
3375 if(s->codec_id==CODEC_ID_MPEG4)
3376 ret= mpeg4_decode_video_packet_header(s);
3378 ret= h263_decode_gob_header(s);
3384 skip_bits(&s->gb, 8);
3391 * gets the average motion vector for a GMC MB.
3392 * @param n either 0 for the x component or 1 for y
3393 * @returns the average MV for a GMC MB
3395 static inline int get_amv(MpegEncContext *s, int n){
3396 int x, y, mb_v, sum, dx, dy, shift;
3397 int len = 1 << (s->f_code + 4);
3398 const int a= s->sprite_warping_accuracy;
3400 if(s->workaround_bugs & FF_BUG_AMV)
3401 len >>= s->quarter_sample;
3403 if(s->real_sprite_warping_points==1){
3404 if(s->divx_version==500 && s->divx_build==413)
3405 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3407 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3409 dx= s->sprite_delta[n][0];
3410 dy= s->sprite_delta[n][1];
3411 shift= s->sprite_shift[0];
3412 if(n) dy -= 1<<(shift + a + 1);
3413 else dx -= 1<<(shift + a + 1);
3414 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3417 for(y=0; y<16; y++){
3421 //XXX FIXME optimize
3422 for(x=0; x<16; x++){
3427 sum= RSHIFT(sum, a+8-s->quarter_sample);
3430 if (sum < -len) sum= -len;
3431 else if (sum >= len) sum= len-1;
3437 * decodes first partition.
3438 * @return number of MBs decoded or <0 if an error occured
3440 static int mpeg4_decode_partition_a(MpegEncContext *s){
3442 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3444 /* decode first partition */
3446 s->first_slice_line=1;
3447 for(; s->mb_y<s->mb_height; s->mb_y++){
3448 ff_init_block_index(s);
3449 for(; s->mb_x<s->mb_width; s->mb_x++){
3450 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3455 ff_update_block_index(s);
3456 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3457 s->first_slice_line=0;
3459 if(s->pict_type==I_TYPE){
3463 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3467 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3469 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3474 s->cbp_table[xy]= cbpc & 3;
3475 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3479 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3481 s->current_picture.qscale_table[xy]= s->qscale;
3483 s->mbintra_table[xy]= 1;
3486 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3488 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3492 if(dc_pred_dir) dir|=1;
3494 s->pred_dir_table[xy]= dir;
3495 }else{ /* P/S_TYPE */
3496 int mx, my, pred_x, pred_y, bits;
3497 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3498 const int stride= s->b8_stride*2;
3501 bits= show_bits(&s->gb, 17);
3502 if(bits==MOTION_MARKER){
3508 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3509 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3513 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3516 mot_val[0 ]= mot_val[2 ]=
3517 mot_val[0+stride]= mot_val[2+stride]= mx;
3518 mot_val[1 ]= mot_val[3 ]=
3519 mot_val[1+stride]= mot_val[3+stride]= my;
3521 if(s->mbintra_table[xy])
3522 ff_clean_intra_table_entries(s);
3526 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3528 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3534 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3536 s->mb_intra = ((cbpc & 4) != 0);
3539 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3540 s->mbintra_table[xy]= 1;
3541 mot_val[0 ]= mot_val[2 ]=
3542 mot_val[0+stride]= mot_val[2+stride]= 0;
3543 mot_val[1 ]= mot_val[3 ]=
3544 mot_val[1+stride]= mot_val[3+stride]= 0;
3546 if(s->mbintra_table[xy])
3547 ff_clean_intra_table_entries(s);
3549 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3550 s->mcsel= get_bits1(&s->gb);
3553 if ((cbpc & 16) == 0) {
3554 /* 16x16 motion prediction */
3556 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3558 mx = h263_decode_motion(s, pred_x, s->f_code);
3562 my = h263_decode_motion(s, pred_y, s->f_code);
3565 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3569 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3572 mot_val[0 ]= mot_val[2 ] =
3573 mot_val[0+stride]= mot_val[2+stride]= mx;
3574 mot_val[1 ]= mot_val[3 ]=
3575 mot_val[1+stride]= mot_val[3+stride]= my;
3578 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3580 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3581 mx = h263_decode_motion(s, pred_x, s->f_code);
3585 my = h263_decode_motion(s, pred_y, s->f_code);
3602 * decode second partition.
3603 * @return <0 if an error occured
3605 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3607 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3609 s->mb_x= s->resync_mb_x;
3610 s->first_slice_line=1;
3611 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3612 ff_init_block_index(s);
3613 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3614 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3617 ff_update_block_index(s);
3618 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3619 s->first_slice_line=0;
3621 if(s->pict_type==I_TYPE){
3622 int ac_pred= get_bits1(&s->gb);
3623 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3625 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3629 s->cbp_table[xy]|= cbpy<<2;
3630 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3631 }else{ /* P || S_TYPE */
3632 if(IS_INTRA(s->current_picture.mb_type[xy])){
3634 int ac_pred = get_bits1(&s->gb);
3635 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3638 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3642 if(s->cbp_table[xy] & 8) {
3643 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3645 s->current_picture.qscale_table[xy]= s->qscale;
3649 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3651 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3655 if(dc_pred_dir) dir|=1;
3657 s->cbp_table[xy]&= 3; //remove dquant
3658 s->cbp_table[xy]|= cbpy<<2;
3659 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3660 s->pred_dir_table[xy]= dir;
3661 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3662 s->current_picture.qscale_table[xy]= s->qscale;
3663 s->cbp_table[xy]= 0;
3665 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3668 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3672 if(s->cbp_table[xy] & 8) {
3673 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3675 s->current_picture.qscale_table[xy]= s->qscale;
3677 s->cbp_table[xy]&= 3; //remove dquant
3678 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3682 if(mb_num >= mb_count) return 0;
3689 * decodes the first & second partition
3690 * @return <0 if error (and sets error type in the error_status_table)
3692 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3695 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3696 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3698 mb_num= mpeg4_decode_partition_a(s);
3700 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3704 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3705 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3706 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3710 s->mb_num_left= mb_num;
3712 if(s->pict_type==I_TYPE){
3713 while(show_bits(&s->gb, 9) == 1)
3714 skip_bits(&s->gb, 9);
3715 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3716 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3720 while(show_bits(&s->gb, 10) == 1)
3721 skip_bits(&s->gb, 10);
3722 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3723 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3727 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3729 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3730 if(s->pict_type==P_TYPE)
3731 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3734 if(s->pict_type==P_TYPE)
3735 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3742 * decode partition C of one MB.
3743 * @return <0 if an error occured
3745 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3748 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3750 mb_type= s->current_picture.mb_type[xy];
3751 cbp = s->cbp_table[xy];
3753 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3755 if(s->current_picture.qscale_table[xy] != s->qscale){
3756 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3759 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3762 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3763 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3765 s->mb_intra = IS_INTRA(mb_type);
3767 if (IS_SKIP(mb_type)) {
3770 s->block_last_index[i] = -1;
3771 s->mv_dir = MV_DIR_FORWARD;
3772 s->mv_type = MV_TYPE_16X16;
3773 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3780 }else if(s->mb_intra){
3781 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3782 }else if(!s->mb_intra){
3783 // s->mcsel= 0; //FIXME do we need to init that
3785 s->mv_dir = MV_DIR_FORWARD;
3786 if (IS_8X8(mb_type)) {
3787 s->mv_type = MV_TYPE_8X8;
3789 s->mv_type = MV_TYPE_16X16;
3792 } else { /* I-Frame */
3794 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3797 if (!IS_SKIP(mb_type)) {
3799 s->dsp.clear_blocks(s->block[0]);
3800 /* decode each block */
3801 for (i = 0; i < 6; i++) {
3802 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3803 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3810 /* per-MB end of slice check */
3812 if(--s->mb_num_left <= 0){
3813 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3814 if(mpeg4_is_resync(s))
3819 if(mpeg4_is_resync(s)){
3820 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3821 if(s->cbp_table[xy+delta])
3829 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3831 static void preview_obmc(MpegEncContext *s){
3832 GetBitContext gb= s->gb;
3834 int cbpc, i, pred_x, pred_y, mx, my;
3836 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3837 const int stride= s->b8_stride*2;
3840 s->block_index[i]+= 2;
3842 s->block_index[i]+= 1;
3845 assert(s->pict_type == P_TYPE);
3848 if (get_bits1(&s->gb)) {
3850 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3851 mot_val[0 ]= mot_val[2 ]=
3852 mot_val[0+stride]= mot_val[2+stride]= 0;
3853 mot_val[1 ]= mot_val[3 ]=
3854 mot_val[1+stride]= mot_val[3+stride]= 0;
3856 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3859 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3863 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3865 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3867 if(s->modified_quant){
3868 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3869 else skip_bits(&s->gb, 5);
3871 skip_bits(&s->gb, 2);
3874 if ((cbpc & 16) == 0) {
3875 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3876 /* 16x16 motion prediction */
3877 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3879 mx = h263p_decode_umotion(s, pred_x);
3881 mx = h263_decode_motion(s, pred_x, 1);
3884 my = h263p_decode_umotion(s, pred_y);
3886 my = h263_decode_motion(s, pred_y, 1);
3888 mot_val[0 ]= mot_val[2 ]=
3889 mot_val[0+stride]= mot_val[2+stride]= mx;
3890 mot_val[1 ]= mot_val[3 ]=
3891 mot_val[1+stride]= mot_val[3+stride]= my;
3893 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3895 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3897 mx = h263p_decode_umotion(s, pred_x);
3899 mx = h263_decode_motion(s, pred_x, 1);
3902 my = h263p_decode_umotion(s, pred_y);
3904 my = h263_decode_motion(s, pred_y, 1);
3905 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3906 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3915 s->block_index[i]-= 2;
3917 s->block_index[i]-= 1;
3923 static void h263_decode_dquant(MpegEncContext *s){
3924 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3926 if(s->modified_quant){
3927 if(get_bits1(&s->gb))
3928 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3930 s->qscale= get_bits(&s->gb, 5);
3932 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3933 ff_set_qscale(s, s->qscale);
3936 int ff_h263_decode_mb(MpegEncContext *s,
3937 DCTELEM block[6][64])
3939 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3941 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3943 assert(!s->h263_pred);
3945 if (s->pict_type == P_TYPE) {
3947 if (get_bits1(&s->gb)) {
3951 s->block_last_index[i] = -1;
3952 s->mv_dir = MV_DIR_FORWARD;
3953 s->mv_type = MV_TYPE_16X16;
3954 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3957 s->mb_skipped = !(s->obmc | s->loop_filter);
3960 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3961 //fprintf(stderr, "\tCBPC: %d", cbpc);
3963 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3968 s->dsp.clear_blocks(s->block[0]);
3971 s->mb_intra = ((cbpc & 4) != 0);
3972 if (s->mb_intra) goto intra;
3974 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3976 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3979 cbp = (cbpc & 3) | (cbpy << 2);
3981 h263_decode_dquant(s);
3984 s->mv_dir = MV_DIR_FORWARD;
3985 if ((cbpc & 16) == 0) {
3986 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3987 /* 16x16 motion prediction */
3988 s->mv_type = MV_TYPE_16X16;
3989 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3991 mx = h263p_decode_umotion(s, pred_x);
3993 mx = h263_decode_motion(s, pred_x, 1);
3999 my = h263p_decode_umotion(s, pred_y);
4001 my = h263_decode_motion(s, pred_y, 1);
4005 s->mv[0][0][0] = mx;
4006 s->mv[0][0][1] = my;
4008 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4009 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4011 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4012 s->mv_type = MV_TYPE_8X8;
4014 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4016 mx = h263p_decode_umotion(s, pred_x);
4018 mx = h263_decode_motion(s, pred_x, 1);
4023 my = h263p_decode_umotion(s, pred_y);
4025 my = h263_decode_motion(s, pred_y, 1);
4028 s->mv[0][i][0] = mx;
4029 s->mv[0][i][1] = my;
4030 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4031 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4037 /* decode each block */
4038 for (i = 0; i < 6; i++) {
4039 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4045 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4048 } else if(s->pict_type==B_TYPE) {
4050 const int stride= s->b8_stride;
4051 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4052 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4053 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4056 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4057 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4058 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4059 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4062 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4064 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4068 mb_type= h263_mb_type_b_map[ mb_type ];
4071 s->mb_intra = IS_INTRA(mb_type);
4072 if(HAS_CBP(mb_type)){
4073 s->dsp.clear_blocks(s->block[0]);
4074 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4076 dquant = IS_QUANT(mb_type);
4080 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4083 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4087 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4090 cbp = (cbpc & 3) | (cbpy << 2);
4094 assert(!s->mb_intra);
4096 if(IS_QUANT(mb_type)){
4097 h263_decode_dquant(s);
4100 if(IS_DIRECT(mb_type)){
4101 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4102 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4105 s->mv_type= MV_TYPE_16X16;
4108 if(USES_LIST(mb_type, 0)){
4109 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4110 s->mv_dir = MV_DIR_FORWARD;
4112 mx = h263_decode_motion(s, mx, 1);
4113 my = h263_decode_motion(s, my, 1);
4115 s->mv[0][0][0] = mx;
4116 s->mv[0][0][1] = my;
4117 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4118 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4121 if(USES_LIST(mb_type, 1)){
4122 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4123 s->mv_dir |= MV_DIR_BACKWARD;
4125 mx = h263_decode_motion(s, mx, 1);
4126 my = h263_decode_motion(s, my, 1);
4128 s->mv[1][0][0] = mx;
4129 s->mv[1][0][1] = my;
4130 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4131 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4135 s->current_picture.mb_type[xy]= mb_type;
4137 /* decode each block */
4138 for (i = 0; i < 6; i++) {
4139 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4143 } else { /* I-Frame */
4145 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4147 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4152 s->dsp.clear_blocks(s->block[0]);
4157 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4159 s->ac_pred = get_bits1(&s->gb);
4161 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4163 s->h263_aic_dir = get_bits1(&s->gb);
4168 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4170 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4173 cbp = (cbpc & 3) | (cbpy << 2);
4175 h263_decode_dquant(s);
4178 /* decode each block */
4179 for (i = 0; i < 6; i++) {
4180 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4187 /* per-MB end of slice check */
4189 int v= show_bits(&s->gb, 16);
4191 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4192 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4202 int ff_mpeg4_decode_mb(MpegEncContext *s,
4203 DCTELEM block[6][64])
4205 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4207 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4208 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4210 assert(s->h263_pred);
4212 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4214 if (get_bits1(&s->gb)) {
4218 s->block_last_index[i] = -1;
4219 s->mv_dir = MV_DIR_FORWARD;
4220 s->mv_type = MV_TYPE_16X16;
4221 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4222 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4224 s->mv[0][0][0]= get_amv(s, 0);
4225 s->mv[0][0][1]= get_amv(s, 1);
4229 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4237 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4238 //fprintf(stderr, "\tCBPC: %d", cbpc);
4240 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4245 s->dsp.clear_blocks(s->block[0]);
4247 s->mb_intra = ((cbpc & 4) != 0);
4248 if (s->mb_intra) goto intra;
4250 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4251 s->mcsel= get_bits1(&s->gb);
4253 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4255 cbp = (cbpc & 3) | (cbpy << 2);
4257 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4259 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4260 s->interlaced_dct= get_bits1(&s->gb);
4262 s->mv_dir = MV_DIR_FORWARD;
4263 if ((cbpc & 16) == 0) {
4265 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4266 /* 16x16 global motion prediction */
4267 s->mv_type = MV_TYPE_16X16;
4270 s->mv[0][0][0] = mx;
4271 s->mv[0][0][1] = my;
4272 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4273 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4274 /* 16x8 field motion prediction */
4275 s->mv_type= MV_TYPE_FIELD;
4277 s->field_select[0][0]= get_bits1(&s->gb);
4278 s->field_select[0][1]= get_bits1(&s->gb);
4280 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4283 mx = h263_decode_motion(s, pred_x, s->f_code);
4287 my = h263_decode_motion(s, pred_y/2, s->f_code);
4291 s->mv[0][i][0] = mx;
4292 s->mv[0][i][1] = my;
4295 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4296 /* 16x16 motion prediction */
4297 s->mv_type = MV_TYPE_16X16;
4298 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4299 mx = h263_decode_motion(s, pred_x, s->f_code);
4304 my = h263_decode_motion(s, pred_y, s->f_code);
4308 s->mv[0][0][0] = mx;
4309 s->mv[0][0][1] = my;
4312 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4313 s->mv_type = MV_TYPE_8X8;
4315 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4316 mx = h263_decode_motion(s, pred_x, s->f_code);
4320 my = h263_decode_motion(s, pred_y, s->f_code);
4323 s->mv[0][i][0] = mx;
4324 s->mv[0][i][1] = my;
4329 } else if(s->pict_type==B_TYPE) {
4330 int modb1; // first bit of modb
4331 int modb2; // second bit of modb
4334 s->mb_intra = 0; //B-frames never contain intra blocks
4335 s->mcsel=0; // ... true gmc blocks
4339 s->last_mv[i][0][0]=
4340 s->last_mv[i][0][1]=
4341 s->last_mv[i][1][0]=
4342 s->last_mv[i][1][1]= 0;
4346 /* if we skipped it in the future P Frame than skip it now too */
4347 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4352 s->block_last_index[i] = -1;
4354 s->mv_dir = MV_DIR_FORWARD;
4355 s->mv_type = MV_TYPE_16X16;
4360 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4364 modb1= get_bits1(&s->gb);
4366 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4369 modb2= get_bits1(&s->gb);
4370 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4372 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4375 mb_type= mb_type_b_map[ mb_type ];
4378 s->dsp.clear_blocks(s->block[0]);
4379 cbp= get_bits(&s->gb, 6);
4382 if ((!IS_DIRECT(mb_type)) && cbp) {
4383 if(get_bits1(&s->gb)){
4384 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4388 if(!s->progressive_sequence){
4390 s->interlaced_dct= get_bits1(&s->gb);
4392 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4393 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4394 mb_type &= ~MB_TYPE_16x16;
4396 if(USES_LIST(mb_type, 0)){
4397 s->field_select[0][0]= get_bits1(&s->gb);
4398 s->field_select[0][1]= get_bits1(&s->gb);
4400 if(USES_LIST(mb_type, 1)){
4401 s->field_select[1][0]= get_bits1(&s->gb);
4402 s->field_select[1][1]= get_bits1(&s->gb);
4408 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4409 s->mv_type= MV_TYPE_16X16;
4411 if(USES_LIST(mb_type, 0)){
4412 s->mv_dir = MV_DIR_FORWARD;
4414 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4415 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4416 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4417 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4420 if(USES_LIST(mb_type, 1)){
4421 s->mv_dir |= MV_DIR_BACKWARD;
4423 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4424 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4425 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4426 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4428 }else if(!IS_DIRECT(mb_type)){
4429 s->mv_type= MV_TYPE_FIELD;
4431 if(USES_LIST(mb_type, 0)){
4432 s->mv_dir = MV_DIR_FORWARD;
4435 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4436 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4437 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4438 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4442 if(USES_LIST(mb_type, 1)){
4443 s->mv_dir |= MV_DIR_BACKWARD;
4446 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4447 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4448 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4449 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4455 if(IS_DIRECT(mb_type)){
4456 if(IS_SKIP(mb_type))
4459 mx = h263_decode_motion(s, 0, 1);
4460 my = h263_decode_motion(s, 0, 1);
4463 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4464 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4466 s->current_picture.mb_type[xy]= mb_type;
4467 } else { /* I-Frame */
4469 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4471 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4479 s->ac_pred = get_bits1(&s->gb);
4481 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4483 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4485 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4487 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4490 cbp = (cbpc & 3) | (cbpy << 2);
4492 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4495 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4498 if(!s->progressive_sequence)
4499 s->interlaced_dct= get_bits1(&s->gb);
4501 s->dsp.clear_blocks(s->block[0]);
4502 /* decode each block */
4503 for (i = 0; i < 6; i++) {
4504 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4511 /* decode each block */
4512 for (i = 0; i < 6; i++) {
4513 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4519 /* per-MB end of slice check */
4520 if(s->codec_id==CODEC_ID_MPEG4){
4521 #if 0 //http://standards.iso.org/ittf/PubliclyAvailableStandards/ISO_IEC_14496-4_2004_Conformance_Testing/video_conformance/version_1/simple/ERROR.ZIP/mit025.m4v needs this but its unclear if the mpeg4 standard allows this at all (MN)
4522 if(s->pict_type != B_TYPE){
4523 while(show_bits(&s->gb, 9 + (s->pict_type == P_TYPE)) == 1)
4524 skip_bits(&s->gb, 9 + (s->pict_type == P_TYPE));
4527 if(mpeg4_is_resync(s)){
4528 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4529 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4538 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4540 int code, val, sign, shift, l;
4541 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4548 sign = get_bits1(&s->gb);
4552 val = (val - 1) << shift;
4553 val |= get_bits(&s->gb, shift);
4560 /* modulo decoding */
4561 if (!s->h263_long_vectors) {
4562 l = INT_BIT - 5 - f_code;
4565 /* horrible h263 long vector mode */
4566 if (pred < -31 && val < -63)
4568 if (pred > 32 && val > 63)
4575 /* Decodes RVLC of H.263+ UMV */
4576 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4580 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4583 code = 2 + get_bits1(&s->gb);
4585 while (get_bits1(&s->gb))
4588 code += get_bits1(&s->gb);
4593 code = (sign) ? (pred - code) : (pred + code);
4595 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4601 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4604 int code, level, i, j, last, run;
4605 RLTable *rl = &rl_inter;
4606 const uint8_t *scan_table;
4607 GetBitContext gb= s->gb;
4609 scan_table = s->intra_scantable.permutated;
4610 if (s->h263_aic && s->mb_intra) {
4614 if (s->h263_aic_dir)
4615 scan_table = s->intra_v_scantable.permutated; /* left */
4617 scan_table = s->intra_h_scantable.permutated; /* top */
4619 } else if (s->mb_intra) {
4621 if(s->codec_id == CODEC_ID_RV10){
4622 #ifdef CONFIG_RV10_DECODER
4623 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4624 int component, diff;
4625 component = (n <= 3 ? 0 : n - 4 + 1);
4626 level = s->last_dc[component];
4627 if (s->rv10_first_dc_coded[component]) {
4628 diff = rv_decode_dc(s, n);
4632 level = level & 0xff; /* handle wrap round */
4633 s->last_dc[component] = level;
4635 s->rv10_first_dc_coded[component] = 1;
4638 level = get_bits(&s->gb, 8);
4644 level = get_bits(&s->gb, 8);
4645 if((level&0x7F) == 0){
4646 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4647 if(s->error_resilience >= FF_ER_COMPLIANT)
4659 if (s->mb_intra && s->h263_aic)
4661 s->block_last_index[n] = i - 1;
4666 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4668 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4671 if (code == rl->n) {
4673 if (s->h263_flv > 1) {
4674 int is11 = get_bits1(&s->gb);
4675 last = get_bits1(&s->gb);
4676 run = get_bits(&s->gb, 6);
4678 level = get_sbits(&s->gb, 11);
4680 level = get_sbits(&s->gb, 7);
4683 last = get_bits1(&s->gb);
4684 run = get_bits(&s->gb, 6);
4685 level = (int8_t)get_bits(&s->gb, 8);
4687 if (s->codec_id == CODEC_ID_RV10) {
4688 /* XXX: should patch encoder too */
4689 level = get_sbits(&s->gb, 12);
4691 level = get_bits(&s->gb, 5);
4692 level |= get_sbits(&s->gb, 6)<<5;
4697 run = rl->table_run[code];
4698 level = rl->table_level[code];
4699 last = code >= rl->last;
4700 if (get_bits1(&s->gb))
4705 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4706 //looks like a hack but no, it's the way its supposed to work ...
4710 memset(block, 0, sizeof(DCTELEM)*64);
4713 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4723 if (s->mb_intra && s->h263_aic) {
4724 h263_pred_acdc(s, block, n);
4727 s->block_last_index[n] = i;
4732 * decodes the dc value.
4733 * @param n block index (0-3 are luma, 4-5 are chroma)
4734 * @param dir_ptr the prediction direction will be stored here
4735 * @return the quantized dc
4737 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4742 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4744 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4745 if (code < 0 || code > 9 /* && s->nbit<9 */){
4746 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4754 level= 2*get_bits1(&s->gb)-1;
4756 if(get_bits1(&s->gb))
4757 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4759 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4762 level = get_xbits(&s->gb, code);
4766 if(get_bits1(&s->gb)==0){ /* marker */
4767 if(s->error_resilience>=2){
4768 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4775 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4780 * @return <0 if an error occured
4782 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4783 int n, int coded, int intra, int rvlc)
4785 int level, i, last, run;
4788 RL_VLC_ELEM * rl_vlc;
4789 const uint8_t * scan_table;
4792 //Note intra & rvlc should be optimized away if this is inlined
4795 if(s->use_intra_dc_vlc){
4797 if(s->partitioned_frame){
4798 level = s->dc_val[0][ s->block_index[n] ];
4799 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4800 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4801 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4803 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4811 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4817 rl = &rvlc_rl_intra;
4818 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4821 rl_vlc = rl_intra.rl_vlc[0];
4824 if (dc_pred_dir == 0)
4825 scan_table = s->intra_v_scantable.permutated; /* left */
4827 scan_table = s->intra_h_scantable.permutated; /* top */
4829 scan_table = s->intra_scantable.permutated;
4836 s->block_last_index[n] = i;
4839 if(rvlc) rl = &rvlc_rl_inter;
4840 else rl = &rl_inter;
4842 scan_table = s->intra_scantable.permutated;
4848 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4850 rl_vlc = rl_inter.rl_vlc[0];
4853 qmul = s->qscale << 1;
4854 qadd = (s->qscale - 1) | 1;
4856 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4858 rl_vlc = rl_inter.rl_vlc[s->qscale];
4863 OPEN_READER(re, &s->gb);
4865 UPDATE_CACHE(re, &s->gb);
4866 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4870 if(SHOW_UBITS(re, &s->gb, 1)==0){
4871 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4873 }; SKIP_CACHE(re, &s->gb, 1);
4875 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4876 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4877 SKIP_COUNTER(re, &s->gb, 1+1+6);
4878 UPDATE_CACHE(re, &s->gb);
4880 if(SHOW_UBITS(re, &s->gb, 1)==0){
4881 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4883 }; SKIP_CACHE(re, &s->gb, 1);
4885 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4887 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4888 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4890 }; SKIP_CACHE(re, &s->gb, 5);
4892 level= level * qmul + qadd;
4893 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4894 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4900 cache= GET_CACHE(re, &s->gb);
4903 cache ^= 0xC0000000;
4905 if (cache&0x80000000) {
4906 if (cache&0x40000000) {
4908 SKIP_CACHE(re, &s->gb, 2);
4909 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4910 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4911 SKIP_COUNTER(re, &s->gb, 2+1+6);
4912 UPDATE_CACHE(re, &s->gb);
4915 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4917 if(SHOW_UBITS(re, &s->gb, 1)==0){
4918 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4920 }; SKIP_CACHE(re, &s->gb, 1);
4922 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4924 if(SHOW_UBITS(re, &s->gb, 1)==0){
4925 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4927 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4929 SKIP_COUNTER(re, &s->gb, 1+12+1);
4933 if(s->error_resilience >= FF_ER_COMPLIANT){
4934 const int abs_level= ABS(level);
4935 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4936 const int run1= run - rl->max_run[last][abs_level] - 1;
4937 if(abs_level <= rl->max_level[last][run]){
4938 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4941 if(s->error_resilience > FF_ER_COMPLIANT){
4942 if(abs_level <= rl->max_level[last][run]*2){
4943 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4946 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4947 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4954 if (level>0) level= level * qmul + qadd;
4955 else level= level * qmul - qadd;
4957 if((unsigned)(level + 2048) > 4095){
4958 if(s->error_resilience > FF_ER_COMPLIANT){
4959 if(level > 2560 || level<-2560){
4960 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4964 level= level<0 ? -2048 : 2047;
4971 #if MIN_CACHE_BITS < 20
4972 LAST_SKIP_BITS(re, &s->gb, 2);
4973 UPDATE_CACHE(re, &s->gb);
4975 SKIP_BITS(re, &s->gb, 2);
4977 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4978 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4979 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4980 LAST_SKIP_BITS(re, &s->gb, 1);
4984 #if MIN_CACHE_BITS < 19
4985 LAST_SKIP_BITS(re, &s->gb, 1);
4986 UPDATE_CACHE(re, &s->gb);
4988 SKIP_BITS(re, &s->gb, 1);
4990 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4992 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4993 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4994 LAST_SKIP_BITS(re, &s->gb, 1);
4999 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
5000 LAST_SKIP_BITS(re, &s->gb, 1);
5005 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5009 block[scan_table[i]] = level;
5013 block[scan_table[i]] = level;
5015 CLOSE_READER(re, &s->gb);
5019 if(!s->use_intra_dc_vlc){
5020 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5022 i -= i>>31; //if(i == -1) i=0;
5025 mpeg4_pred_ac(s, block, n, dc_pred_dir);
5027 i = 63; /* XXX: not optimal */
5030 s->block_last_index[n] = i;
5034 /* most is hardcoded. should extend to handle all h263 streams */
5035 int h263_decode_picture_header(MpegEncContext *s)
5037 int format, width, height, i;
5040 align_get_bits(&s->gb);
5042 startcode= get_bits(&s->gb, 22-8);
5044 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
5045 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5047 if(startcode == 0x20)
5051 if (startcode != 0x20) {
5052 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5055 /* temporal reference */
5056 i = get_bits(&s->gb, 8); /* picture timestamp */
5057 if( (s->picture_number&~0xFF)+i < s->picture_number)
5059 s->current_picture_ptr->pts=
5060 s->picture_number= (s->picture_number&~0xFF) + i;
5062 /* PTYPE starts here */
5063 if (get_bits1(&s->gb) != 1) {
5065 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5068 if (get_bits1(&s->gb) != 0) {
5069 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5070 return -1; /* h263 id */
5072 skip_bits1(&s->gb); /* split screen off */
5073 skip_bits1(&s->gb); /* camera off */
5074 skip_bits1(&s->gb); /* freeze picture release off */
5076 format = get_bits(&s->gb, 3);
5081 7 extended PTYPE (PLUSPTYPE)
5084 if (format != 7 && format != 6) {
5087 width = h263_format[format][0];
5088 height = h263_format[format][1];
5092 s->pict_type = I_TYPE + get_bits1(&s->gb);
5094 s->h263_long_vectors = get_bits1(&s->gb);
5096 if (get_bits1(&s->gb) != 0) {
5097 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5098 return -1; /* SAC: off */
5100 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5101 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5103 if (get_bits1(&s->gb) != 0) {
5104 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5105 return -1; /* not PB frame */
5107 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5108 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5112 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5113 s->avctx->time_base= (AVRational){1001, 30000};
5119 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5121 /* ufep other than 0 and 1 are reserved */
5124 format = get_bits(&s->gb, 3);
5125 dprintf("ufep=1, format: %d\n", format);
5126 s->custom_pcf= get_bits1(&s->gb);
5127 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5128 if (get_bits1(&s->gb) != 0) {
5129 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5131 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5132 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5133 s->loop_filter= get_bits1(&s->gb);
5134 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5136 s->h263_slice_structured= get_bits1(&s->gb);
5137 if (get_bits1(&s->gb) != 0) {
5138 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5140 if (get_bits1(&s->gb) != 0) {
5141 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5143 s->alt_inter_vlc= get_bits1(&s->gb);
5144 s->modified_quant= get_bits1(&s->gb);
5145 if(s->modified_quant)
5146 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5148 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5150 skip_bits(&s->gb, 3); /* Reserved */
5151 } else if (ufep != 0) {
5152 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5157 s->pict_type = get_bits(&s->gb, 3);
5158 switch(s->pict_type){
5159 case 0: s->pict_type= I_TYPE;break;
5160 case 1: s->pict_type= P_TYPE;break;
5161 case 3: s->pict_type= B_TYPE;break;
5162 case 7: s->pict_type= I_TYPE;break; //ZYGO
5166 skip_bits(&s->gb, 2);
5167 s->no_rounding = get_bits1(&s->gb);
5168 skip_bits(&s->gb, 4);
5170 /* Get the picture dimensions */
5173 /* Custom Picture Format (CPFMT) */
5174 s->aspect_ratio_info = get_bits(&s->gb, 4);
5175 dprintf("aspect: %d\n", s->aspect_ratio_info);
5180 3 - 10:11 (525-type 4:3)
5181 4 - 16:11 (CIF 16:9)
5182 5 - 40:33 (525-type 16:9)
5185 width = (get_bits(&s->gb, 9) + 1) * 4;
5187 height = get_bits(&s->gb, 9) * 4;
5188 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5189 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5190 /* aspected dimensions */
5191 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5192 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5194 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5197 width = h263_format[format][0];
5198 height = h263_format[format][1];
5199 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5201 if ((width == 0) || (height == 0))
5208 s->avctx->time_base.den= 1800000;
5209 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5210 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5211 if(s->avctx->time_base.num == 0){
5212 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5215 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5216 s->avctx->time_base.den /= gcd;
5217 s->avctx->time_base.num /= gcd;
5218 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5220 s->avctx->time_base= (AVRational){1001, 30000};
5225 skip_bits(&s->gb, 2); //extended Temporal reference
5230 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5233 if(s->h263_slice_structured){
5234 if (get_bits1(&s->gb) != 0) {
5235 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5237 if (get_bits1(&s->gb) != 0) {
5238 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5243 s->qscale = get_bits(&s->gb, 5);
5246 s->mb_width = (s->width + 15) / 16;
5247 s->mb_height = (s->height + 15) / 16;
5248 s->mb_num = s->mb_width * s->mb_height;
5251 while (get_bits1(&s->gb) != 0) {
5252 skip_bits(&s->gb, 8);
5255 if(s->h263_slice_structured){
5256 if (get_bits1(&s->gb) != 1) {
5257 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5261 ff_h263_decode_mba(s);
5263 if (get_bits1(&s->gb) != 1) {
5264 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5271 s->y_dc_scale_table=
5272 s->c_dc_scale_table= ff_aic_dc_scale_table;
5274 s->y_dc_scale_table=
5275 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5278 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5279 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",
5280 s->qscale, av_get_pict_type_char(s->pict_type),
5281 s->gb.size_in_bits, 1-s->no_rounding,
5282 s->obmc ? " AP" : "",
5283 s->umvplus ? " UMV" : "",
5284 s->h263_long_vectors ? " LONG" : "",
5285 s->h263_plus ? " +" : "",
5286 s->h263_aic ? " AIC" : "",
5287 s->alt_inter_vlc ? " AIV" : "",
5288 s->modified_quant ? " MQ" : "",
5289 s->loop_filter ? " LOOP" : "",
5290 s->h263_slice_structured ? " SS" : "",
5291 s->avctx->time_base.den, s->avctx->time_base.num
5295 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5297 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5298 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5299 for(i=0; i<13; i++){
5301 int v= get_bits(&s->gb, 8);
5302 v |= get_sbits(&s->gb, 8)<<8;
5303 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5305 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5307 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5314 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5317 int a= 2<<s->sprite_warping_accuracy;
5318 int rho= 3-s->sprite_warping_accuracy;
5320 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5321 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5322 int sprite_ref[4][2];
5323 int virtual_ref[2][2];
5325 int alpha=0, beta=0;
5330 for(i=0; i<s->num_sprite_warping_points; i++){
5334 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5336 x= get_xbits(gb, length);
5338 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5340 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5342 y=get_xbits(gb, length);
5344 skip_bits1(gb); /* marker bit */
5345 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5350 while((1<<alpha)<w) alpha++;
5351 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5355 // Note, the 4th point isn't used for GMC
5356 if(s->divx_version==500 && s->divx_build==413){
5357 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5358 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5359 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5360 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5361 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5362 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5364 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5365 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5366 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5367 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5368 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5369 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5371 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5372 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5374 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5375 // perhaps it should be reordered to be more readable ...
5376 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5377 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5378 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5379 + 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);
5380 virtual_ref[0][1]= 16*vop_ref[0][1]
5381 + 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);
5382 virtual_ref[1][0]= 16*vop_ref[0][0]
5383 + 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);
5384 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5385 + 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);
5387 switch(s->num_sprite_warping_points)
5390 s->sprite_offset[0][0]= 0;
5391 s->sprite_offset[0][1]= 0;
5392 s->sprite_offset[1][0]= 0;
5393 s->sprite_offset[1][1]= 0;
5394 s->sprite_delta[0][0]= a;
5395 s->sprite_delta[0][1]= 0;
5396 s->sprite_delta[1][0]= 0;
5397 s->sprite_delta[1][1]= a;
5398 s->sprite_shift[0]= 0;
5399 s->sprite_shift[1]= 0;
5402 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5403 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5404 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5405 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5406 s->sprite_delta[0][0]= a;
5407 s->sprite_delta[0][1]= 0;
5408 s->sprite_delta[1][0]= 0;
5409 s->sprite_delta[1][1]= a;
5410 s->sprite_shift[0]= 0;
5411 s->sprite_shift[1]= 0;
5414 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5415 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5416 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5417 + (1<<(alpha+rho-1));
5418 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5419 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5420 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5421 + (1<<(alpha+rho-1));
5422 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5423 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5424 +2*w2*r*sprite_ref[0][0]
5426 + (1<<(alpha+rho+1)));
5427 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5428 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5429 +2*w2*r*sprite_ref[0][1]
5431 + (1<<(alpha+rho+1)));
5432 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5433 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5434 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5435 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5437 s->sprite_shift[0]= alpha+rho;
5438 s->sprite_shift[1]= alpha+rho+2;
5441 min_ab= FFMIN(alpha, beta);
5444 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5445 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5446 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5447 + (1<<(alpha+beta+rho-min_ab-1));
5448 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5449 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5450 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5451 + (1<<(alpha+beta+rho-min_ab-1));
5452 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5453 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5454 + 2*w2*h3*r*sprite_ref[0][0]
5456 + (1<<(alpha+beta+rho-min_ab+1));
5457 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5458 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5459 + 2*w2*h3*r*sprite_ref[0][1]
5461 + (1<<(alpha+beta+rho-min_ab+1));
5462 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5463 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5464 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5465 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5467 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5468 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5471 /* try to simplify the situation */
5472 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5473 && s->sprite_delta[0][1] == 0
5474 && s->sprite_delta[1][0] == 0
5475 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5477 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5478 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5479 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5480 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5481 s->sprite_delta[0][0]= a;
5482 s->sprite_delta[0][1]= 0;
5483 s->sprite_delta[1][0]= 0;
5484 s->sprite_delta[1][1]= a;
5485 s->sprite_shift[0]= 0;
5486 s->sprite_shift[1]= 0;
5487 s->real_sprite_warping_points=1;
5490 int shift_y= 16 - s->sprite_shift[0];
5491 int shift_c= 16 - s->sprite_shift[1];
5492 //printf("shifts %d %d\n", shift_y, shift_c);
5494 s->sprite_offset[0][i]<<= shift_y;
5495 s->sprite_offset[1][i]<<= shift_c;
5496 s->sprite_delta[0][i]<<= shift_y;
5497 s->sprite_delta[1][i]<<= shift_y;
5498 s->sprite_shift[i]= 16;
5500 s->real_sprite_warping_points= s->num_sprite_warping_points;
5503 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5504 vop_ref[0][0], vop_ref[0][1],
5505 vop_ref[1][0], vop_ref[1][1],
5506 vop_ref[2][0], vop_ref[2][1],
5507 sprite_ref[0][0], sprite_ref[0][1],
5508 sprite_ref[1][0], sprite_ref[1][1],
5509 sprite_ref[2][0], sprite_ref[2][1],
5510 virtual_ref[0][0], virtual_ref[0][1],
5511 virtual_ref[1][0], virtual_ref[1][1]
5514 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5515 s->sprite_offset[0][0], s->sprite_offset[0][1],
5516 s->sprite_delta[0][0], s->sprite_delta[0][1],
5517 s->sprite_delta[1][0], s->sprite_delta[1][1],
5523 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5524 int hours, minutes, seconds;
5526 hours= get_bits(gb, 5);
5527 minutes= get_bits(gb, 6);
5529 seconds= get_bits(gb, 6);
5531 s->time_base= seconds + 60*(minutes + 60*hours);
5539 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5540 int width, height, vo_ver_id;
5543 skip_bits(gb, 1); /* random access */
5544 s->vo_type= get_bits(gb, 8);
5545 if (get_bits1(gb) != 0) { /* is_ol_id */
5546 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5547 skip_bits(gb, 3); /* vo_priority */
5551 //printf("vo type:%d\n",s->vo_type);
5552 s->aspect_ratio_info= get_bits(gb, 4);
5553 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5554 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5555 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5557 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5560 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5561 int chroma_format= get_bits(gb, 2);
5562 if(chroma_format!=1){
5563 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5565 s->low_delay= get_bits1(gb);
5566 if(get_bits1(gb)){ /* vbv parameters */
5567 get_bits(gb, 15); /* first_half_bitrate */
5568 skip_bits1(gb); /* marker */
5569 get_bits(gb, 15); /* latter_half_bitrate */
5570 skip_bits1(gb); /* marker */
5571 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5572 skip_bits1(gb); /* marker */
5573 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5574 get_bits(gb, 11); /* first_half_vbv_occupancy */
5575 skip_bits1(gb); /* marker */
5576 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5577 skip_bits1(gb); /* marker */
5580 // set low delay flag only once the smartest? low delay detection won't be overriden
5581 if(s->picture_number==0)
5585 s->shape = get_bits(gb, 2); /* vol shape */
5586 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5587 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5588 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5589 skip_bits(gb, 4); //video_object_layer_shape_extension
5592 check_marker(gb, "before time_increment_resolution");
5594 s->avctx->time_base.den = get_bits(gb, 16);
5595 if(!s->avctx->time_base.den){
5596 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5600 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5601 if (s->time_increment_bits < 1)
5602 s->time_increment_bits = 1;
5604 check_marker(gb, "before fixed_vop_rate");
5606 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5607 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5609 s->avctx->time_base.num = 1;
5613 if (s->shape != BIN_ONLY_SHAPE) {
5614 if (s->shape == RECT_SHAPE) {
5615 skip_bits1(gb); /* marker */
5616 width = get_bits(gb, 13);
5617 skip_bits1(gb); /* marker */
5618 height = get_bits(gb, 13);
5619 skip_bits1(gb); /* marker */
5620 if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5623 // printf("width/height: %d %d\n", width, height);
5627 s->progressive_sequence=
5628 s->progressive_frame= get_bits1(gb)^1;
5629 s->interlaced_dct=0;
5630 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5631 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5632 if (vo_ver_id == 1) {
5633 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5635 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5637 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5638 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5639 if(s->vol_sprite_usage==STATIC_SPRITE){
5640 s->sprite_width = get_bits(gb, 13);
5641 skip_bits1(gb); /* marker */
5642 s->sprite_height= get_bits(gb, 13);
5643 skip_bits1(gb); /* marker */
5644 s->sprite_left = get_bits(gb, 13);
5645 skip_bits1(gb); /* marker */
5646 s->sprite_top = get_bits(gb, 13);
5647 skip_bits1(gb); /* marker */
5649 s->num_sprite_warping_points= get_bits(gb, 6);
5650 s->sprite_warping_accuracy = get_bits(gb, 2);
5651 s->sprite_brightness_change= get_bits1(gb);
5652 if(s->vol_sprite_usage==STATIC_SPRITE)
5653 s->low_latency_sprite= get_bits1(gb);
5655 // FIXME sadct disable bit if verid!=1 && shape not rect
5657 if (get_bits1(gb) == 1) { /* not_8_bit */
5658 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5659 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5660 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5662 s->quant_precision = 5;
5665 // FIXME a bunch of grayscale shape things
5667 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5670 /* load default matrixes */
5671 for(i=0; i<64; i++){
5672 int j= s->dsp.idct_permutation[i];
5673 v= ff_mpeg4_default_intra_matrix[i];
5674 s->intra_matrix[j]= v;
5675 s->chroma_intra_matrix[j]= v;
5677 v= ff_mpeg4_default_non_intra_matrix[i];
5678 s->inter_matrix[j]= v;
5679 s->chroma_inter_matrix[j]= v;
5682 /* load custom intra matrix */
5685 for(i=0; i<64; i++){
5691 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5692 s->intra_matrix[j]= v;
5693 s->chroma_intra_matrix[j]= v;
5696 /* replicate last value */
5698 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5699 s->intra_matrix[j]= last;
5700 s->chroma_intra_matrix[j]= last;
5704 /* load custom non intra matrix */
5707 for(i=0; i<64; i++){
5713 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5714 s->inter_matrix[j]= v;
5715 s->chroma_inter_matrix[j]= v;
5718 /* replicate last value */
5720 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5721 s->inter_matrix[j]= last;
5722 s->chroma_inter_matrix[j]= last;
5726 // FIXME a bunch of grayscale shape things
5730 s->quarter_sample= get_bits1(gb);
5731 else s->quarter_sample=0;
5733 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5735 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5737 s->data_partitioning= get_bits1(gb);
5738 if(s->data_partitioning){
5739 s->rvlc= get_bits1(gb);
5742 if(vo_ver_id != 1) {
5743 s->new_pred= get_bits1(gb);
5745 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5746 skip_bits(gb, 2); /* requested upstream message type */
5747 skip_bits1(gb); /* newpred segment type */
5749 s->reduced_res_vop= get_bits1(gb);
5750 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5754 s->reduced_res_vop= 0;
5757 s->scalability= get_bits1(gb);
5759 if (s->scalability) {
5760 GetBitContext bak= *gb;
5762 int ref_layer_sampling_dir;
5763 int h_sampling_factor_n;
5764 int h_sampling_factor_m;
5765 int v_sampling_factor_n;
5766 int v_sampling_factor_m;
5768 s->hierachy_type= get_bits1(gb);
5769 ref_layer_id= get_bits(gb, 4);
5770 ref_layer_sampling_dir= get_bits1(gb);
5771 h_sampling_factor_n= get_bits(gb, 5);
5772 h_sampling_factor_m= get_bits(gb, 5);
5773 v_sampling_factor_n= get_bits(gb, 5);
5774 v_sampling_factor_m= get_bits(gb, 5);
5775 s->enhancement_type= get_bits1(gb);
5777 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5778 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5780 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5785 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5787 // bin shape stuff FIXME
5794 * decodes the user data stuff in the header.
5795 * allso inits divx/xvid/lavc_version/build
5797 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5801 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5804 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5805 if(show_bits(gb, 23) == 0) break;
5806 buf[i]= get_bits(gb, 8);
5810 /* divx detection */
5811 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5813 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5815 s->divx_version= ver;
5816 s->divx_build= build;
5817 s->divx_packed= e==3 && last=='p';
5820 /* ffmpeg detection */
5821 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5823 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5825 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5827 build= (ver<<16) + (ver2<<8) + ver3;
5830 if(strcmp(buf, "ffmpeg")==0){
5831 s->lavc_build= 4600;
5835 s->lavc_build= build;
5838 /* xvid detection */
5839 e=sscanf(buf, "XviD%d", &build);
5841 s->xvid_build= build;
5844 //printf("User Data: %s\n", buf);
5848 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5849 int time_incr, time_increment;
5851 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5852 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5853 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5857 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5858 if(s->partitioned_frame)
5859 s->decode_mb= mpeg4_decode_partitioned_mb;
5861 s->decode_mb= ff_mpeg4_decode_mb;
5864 while (get_bits1(gb) != 0)
5867 check_marker(gb, "before time_increment");
5869 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5870 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5872 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5873 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5876 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5879 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5880 else time_increment= get_bits(gb, s->time_increment_bits);
5882 // printf("%d %X\n", s->time_increment_bits, time_increment);
5883 //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);
5884 if(s->pict_type!=B_TYPE){
5885 s->last_time_base= s->time_base;
5886 s->time_base+= time_incr;
5887 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5888 if(s->workaround_bugs&FF_BUG_UMP4){
5889 if(s->time < s->last_non_b_time){
5890 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5892 s->time+= s->avctx->time_base.den;
5895 s->pp_time= s->time - s->last_non_b_time;
5896 s->last_non_b_time= s->time;
5898 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5899 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5900 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5901 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5902 return FRAME_SKIPPED;
5904 ff_mpeg4_init_direct_mv(s);
5906 if(s->t_frame==0) s->t_frame= s->pb_time;
5907 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5908 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5909 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5910 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5911 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5913 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %Ld last_base %d time %Ld pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time);
5915 if(s->avctx->time_base.num)
5916 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5918 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5919 if(s->avctx->debug&FF_DEBUG_PTS)
5920 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5922 check_marker(gb, "before vop_coded");
5925 if (get_bits1(gb) != 1){
5926 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5927 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5928 return FRAME_SKIPPED;
5930 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5931 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5932 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5933 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5934 /* rounding type for motion estimation */
5935 s->no_rounding = get_bits1(gb);
5939 //FIXME reduced res stuff
5941 if (s->shape != RECT_SHAPE) {
5942 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5943 int width, height, hor_spat_ref, ver_spat_ref;
5945 width = get_bits(gb, 13);
5946 skip_bits1(gb); /* marker */
5947 height = get_bits(gb, 13);
5948 skip_bits1(gb); /* marker */
5949 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5950 skip_bits1(gb); /* marker */
5951 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5953 skip_bits1(gb); /* change_CR_disable */
5955 if (get_bits1(gb) != 0) {
5956 skip_bits(gb, 8); /* constant_alpha_value */
5959 //FIXME complexity estimation stuff
5961 if (s->shape != BIN_ONLY_SHAPE) {
5962 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5963 if(!s->progressive_sequence){
5964 s->top_field_first= get_bits1(gb);
5965 s->alternate_scan= get_bits1(gb);
5967 s->alternate_scan= 0;
5970 if(s->alternate_scan){
5971 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5972 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5973 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5974 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5976 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5977 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5978 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5979 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5982 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5983 mpeg4_decode_sprite_trajectory(s, gb);
5984 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5985 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5988 if (s->shape != BIN_ONLY_SHAPE) {
5989 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5991 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5992 return -1; // makes no sense to continue, as there is nothing left from the image then
5995 if (s->pict_type != I_TYPE) {
5996 s->f_code = get_bits(gb, 3); /* fcode_for */
5998 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5999 return -1; // makes no sense to continue, as the MV decoding will break very quickly
6004 if (s->pict_type == B_TYPE) {
6005 s->b_code = get_bits(gb, 3);
6009 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
6010 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",
6011 s->qscale, s->f_code, s->b_code,
6012 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6013 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6014 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
6015 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
6018 if(!s->scalability){
6019 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
6020 skip_bits1(gb); // vop shape coding type
6023 if(s->enhancement_type){
6024 int load_backward_shape= get_bits1(gb);
6025 if(load_backward_shape){
6026 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
6029 skip_bits(gb, 2); //ref_select_code
6032 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6033 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
6034 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
6035 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6039 s->picture_number++; // better than pic number==0 always ;)
6041 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6042 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
6044 if(s->workaround_bugs&FF_BUG_EDGE){
6045 s->h_edge_pos= s->width;
6046 s->v_edge_pos= s->height;
6052 * decode mpeg4 headers
6053 * @return <0 if no VOP found (or a damaged one)
6054 * FRAME_SKIPPED if a not coded VOP is found
6055 * 0 if a VOP is found
6057 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6061 /* search next start code */
6064 if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6066 if(get_bits(gb, 8) == 0xF0)
6067 return decode_vop_header(s, gb);
6072 if(get_bits_count(gb) >= gb->size_in_bits){
6073 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6074 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6075 return FRAME_SKIPPED; //divx bug
6077 return -1; //end of stream
6080 /* use the bits after the test */
6081 v = get_bits(gb, 8);
6082 startcode = ((startcode << 8) | v) & 0xffffffff;
6084 if((startcode&0xFFFFFF00) != 0x100)
6085 continue; //no startcode
6087 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6088 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6089 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6090 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6091 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6092 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6093 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6094 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6095 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6096 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6097 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6098 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6099 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6100 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6101 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6102 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6103 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6104 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6105 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6106 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6107 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6108 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6109 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6110 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6111 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6112 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6113 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6114 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6115 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6116 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6119 if(startcode >= 0x120 && startcode <= 0x12F){
6120 if(decode_vol_header(s, gb) < 0)
6123 else if(startcode == USER_DATA_STARTCODE){
6124 decode_user_data(s, gb);
6126 else if(startcode == GOP_STARTCODE){
6127 mpeg4_decode_gop_header(s, gb);
6129 else if(startcode == VOP_STARTCODE){
6130 return decode_vop_header(s, gb);
6138 /* don't understand why they choose a different header ! */
6139 int intel_h263_decode_picture_header(MpegEncContext *s)
6143 /* picture header */
6144 if (get_bits_long(&s->gb, 22) != 0x20) {
6145 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6148 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6150 if (get_bits1(&s->gb) != 1) {
6151 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6152 return -1; /* marker */
6154 if (get_bits1(&s->gb) != 0) {
6155 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6156 return -1; /* h263 id */
6158 skip_bits1(&s->gb); /* split screen off */
6159 skip_bits1(&s->gb); /* camera off */
6160 skip_bits1(&s->gb); /* freeze picture release off */
6162 format = get_bits(&s->gb, 3);
6164 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6169 s->pict_type = I_TYPE + get_bits1(&s->gb);
6171 s->unrestricted_mv = get_bits1(&s->gb);
6172 s->h263_long_vectors = s->unrestricted_mv;
6174 if (get_bits1(&s->gb) != 0) {
6175 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6176 return -1; /* SAC: off */
6178 if (get_bits1(&s->gb) != 0) {
6180 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6181 // return -1; /* advanced prediction mode: off */
6183 if (get_bits1(&s->gb) != 0) {
6184 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6185 return -1; /* PB frame mode */
6188 /* skip unknown header garbage */
6189 skip_bits(&s->gb, 41);
6191 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6192 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6195 while (get_bits1(&s->gb) != 0) {
6196 skip_bits(&s->gb, 8);
6200 s->y_dc_scale_table=
6201 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6206 int flv_h263_decode_picture_header(MpegEncContext *s)
6208 int format, width, height;
6210 /* picture header */
6211 if (get_bits_long(&s->gb, 17) != 1) {
6212 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6215 format = get_bits(&s->gb, 5);
6216 if (format != 0 && format != 1) {
6217 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6220 s->h263_flv = format+1;
6221 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6222 format = get_bits(&s->gb, 3);
6225 width = get_bits(&s->gb, 8);
6226 height = get_bits(&s->gb, 8);
6229 width = get_bits(&s->gb, 16);
6230 height = get_bits(&s->gb, 16);
6256 if(avcodec_check_dimensions(s->avctx, width, height))
6261 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6262 s->dropable= s->pict_type > P_TYPE;
6264 s->pict_type = P_TYPE;
6266 skip_bits1(&s->gb); /* deblocking flag */
6267 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6271 s->unrestricted_mv = 1;
6272 s->h263_long_vectors = 0;
6275 while (get_bits1(&s->gb) != 0) {
6276 skip_bits(&s->gb, 8);
6280 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6281 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6282 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6285 s->y_dc_scale_table=
6286 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;