2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
5 * Copyright (c) 2001 Juan J. Sierralta P.
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * ac prediction encoding, b-frame support, error resilience, optimizations,
23 * qpel decoding, gmc decoding, interlaced decoding,
24 * by Michael Niedermayer <michaelni@gmx.at>
38 #include "mpegvideo.h"
40 #include "mpeg4data.h"
45 #define INTRA_MCBPC_VLC_BITS 6
46 #define INTER_MCBPC_VLC_BITS 7
47 #define CBPY_VLC_BITS 6
50 #define SPRITE_TRAJ_VLC_BITS 6
51 #define MB_TYPE_B_VLC_BITS 4
52 #define TEX_VLC_BITS 9
53 #define H263_MBTYPE_B_VLC_BITS 6
54 #define CBPC_B_VLC_BITS 3
56 #ifdef CONFIG_ENCODERS
57 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59 static void h263p_encode_umotion(MpegEncContext * s, int val);
60 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61 int n, int dc, uint8_t *scan_table,
62 PutBitContext *dc_pb, PutBitContext *ac_pb);
65 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
66 static int h263p_decode_umotion(MpegEncContext * s, int pred);
67 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
69 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
70 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
71 int n, int coded, int intra, int rvlc);
72 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
74 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
75 #ifdef CONFIG_ENCODERS
76 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
77 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
78 #endif //CONFIG_ENCODERS
79 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
80 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82 #ifdef CONFIG_ENCODERS
83 static uint8_t uni_DCtab_lum_len[512];
84 static uint8_t uni_DCtab_chrom_len[512];
85 static uint16_t uni_DCtab_lum_bits[512];
86 static uint16_t uni_DCtab_chrom_bits[512];
88 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
89 static uint8_t fcode_tab[MAX_MV*2+1];
90 static uint8_t umv_fcode_tab[MAX_MV*2+1];
92 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
93 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
94 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
95 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
96 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
97 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
98 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
100 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
113 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
114 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
119 int h263_get_picture_format(int width, int height)
123 if (width == 128 && height == 96)
125 else if (width == 176 && height == 144)
127 else if (width == 352 && height == 288)
129 else if (width == 704 && height == 576)
131 else if (width == 1408 && height == 1152)
138 #ifdef CONFIG_ENCODERS
140 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
143 if(aspect.num==0) aspect= (AVRational){1,1};
146 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
147 s->aspect_ratio_info=i;
152 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
155 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
159 align_put_bits(&s->pb);
161 put_bits(&s->pb, 17, 1);
162 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
163 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
164 s->avctx->time_base.den) & 0xff); /* TemporalReference */
165 if (s->width == 352 && s->height == 288)
167 else if (s->width == 176 && s->height == 144)
169 else if (s->width == 128 && s->height == 96)
171 else if (s->width == 320 && s->height == 240)
173 else if (s->width == 160 && s->height == 120)
175 else if (s->width <= 255 && s->height <= 255)
176 format = 0; /* use 1 byte width & height */
178 format = 1; /* use 2 bytes width & height */
179 put_bits(&s->pb, 3, format); /* PictureSize */
181 put_bits(&s->pb, 8, s->width);
182 put_bits(&s->pb, 8, s->height);
183 } else if (format == 1) {
184 put_bits(&s->pb, 16, s->width);
185 put_bits(&s->pb, 16, s->height);
187 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
188 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
189 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
190 put_bits(&s->pb, 1, 0); /* ExtraInformation */
194 s->c_dc_scale_table= ff_aic_dc_scale_table;
197 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
201 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
203 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
204 int best_clock_code=1;
206 int best_error= INT_MAX;
211 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
212 div= clip(1, div, 127);
213 error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
214 if(error < best_error){
221 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
222 coded_frame_rate= 1800000;
223 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
225 align_put_bits(&s->pb);
227 /* Update the pointer to last GOB */
228 s->ptr_lastgob = pbBufPtr(&s->pb);
229 put_bits(&s->pb, 22, 0x20); /* PSC */
230 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
231 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
232 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
234 put_bits(&s->pb, 1, 1); /* marker */
235 put_bits(&s->pb, 1, 0); /* h263 id */
236 put_bits(&s->pb, 1, 0); /* split screen off */
237 put_bits(&s->pb, 1, 0); /* camera off */
238 put_bits(&s->pb, 1, 0); /* freeze picture release off */
240 format = h263_get_picture_format(s->width, s->height);
243 put_bits(&s->pb, 3, format);
244 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
245 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
246 of H.263v1 UMV implies to check the predicted MV after
247 calculation of the current MB to see if we're on the limits */
248 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
249 put_bits(&s->pb, 1, 0); /* SAC: off */
250 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
251 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
252 put_bits(&s->pb, 5, s->qscale);
253 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
257 /* H.263 Plus PTYPE */
259 put_bits(&s->pb, 3, 7);
260 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
262 put_bits(&s->pb,3,6); /* Custom Source Format */
264 put_bits(&s->pb, 3, format);
266 put_bits(&s->pb,1, s->custom_pcf);
267 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
268 put_bits(&s->pb,1,0); /* SAC: off */
269 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
270 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
271 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
272 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
273 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
274 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
275 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
276 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
277 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278 put_bits(&s->pb,3,0); /* Reserved */
280 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
282 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
283 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
284 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
285 put_bits(&s->pb,2,0); /* Reserved */
286 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
288 /* This should be here if PLUSPTYPE */
289 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
292 /* Custom Picture Format (CPFMT) */
293 aspect_to_info(s, s->avctx->sample_aspect_ratio);
295 put_bits(&s->pb,4,s->aspect_ratio_info);
296 put_bits(&s->pb,9,(s->width >> 2) - 1);
297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298 put_bits(&s->pb,9,(s->height >> 2));
299 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
300 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
301 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
306 put_bits(&s->pb, 1, best_clock_code);
307 put_bits(&s->pb, 7, best_divisor);
309 put_bits(&s->pb, 2, (temp_ref>>8)&3);
312 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
314 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
315 //FIXME check actual requested range
316 put_bits(&s->pb,2,1); /* unlimited */
317 if(s->h263_slice_structured)
318 put_bits(&s->pb,2,0); /* no weird submodes */
320 put_bits(&s->pb, 5, s->qscale);
323 put_bits(&s->pb, 1, 0); /* no PEI */
325 if(s->h263_slice_structured){
326 put_bits(&s->pb, 1, 1);
328 assert(s->mb_x == 0 && s->mb_y == 0);
329 ff_h263_encode_mba(s);
331 put_bits(&s->pb, 1, 1);
336 s->c_dc_scale_table= ff_aic_dc_scale_table;
339 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344 * Encodes a group of blocks header.
346 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
348 put_bits(&s->pb, 17, 1); /* GBSC */
350 if(s->h263_slice_structured){
351 put_bits(&s->pb, 1, 1);
353 ff_h263_encode_mba(s);
356 put_bits(&s->pb, 1, 1);
357 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
358 put_bits(&s->pb, 1, 1);
359 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
361 int gob_number= mb_line / s->gob_index;
363 put_bits(&s->pb, 5, gob_number); /* GN */
364 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
365 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
369 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
374 for(j=1; j<=block_last_index; j++){
375 const int index= scantable[j];
376 int level= block[index];
379 if((level&(~127)) == 0){
380 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
381 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
383 rate += s->ac_esc_length;
393 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
397 int8_t * const qscale_table= s->current_picture.qscale_table;
399 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
402 int16_t *ac_val, *ac_val1;
404 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
406 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
409 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
411 ac_val-= s->block_wrap[n]*16;
412 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
415 const int level= block[n][s->dsp.idct_permutation[i ]];
416 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
417 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
421 /* different qscale, we must rescale */
423 const int level= block[n][s->dsp.idct_permutation[i ]];
424 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
425 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
429 st[n]= s->intra_h_scantable.permutated;
431 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
432 /* left prediction */
434 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
437 const int level= block[n][s->dsp.idct_permutation[i<<3]];
438 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
440 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
443 /* different qscale, we must rescale */
445 const int level= block[n][s->dsp.idct_permutation[i<<3]];
446 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
448 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
451 st[n]= s->intra_v_scantable.permutated;
454 for(i=63; i>0; i--) //FIXME optimize
455 if(block[n][ st[n][i] ]) break;
456 s->block_last_index[n]= i;
458 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
464 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
467 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
470 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
472 st[n]= s->intra_scantable.permutated;
476 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
479 /* left prediction */
481 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
488 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
490 void ff_clean_h263_qscales(MpegEncContext *s){
492 int8_t * const qscale_table= s->current_picture.qscale_table;
494 for(i=1; i<s->mb_num; i++){
495 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
496 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
498 for(i=s->mb_num-2; i>=0; i--){
499 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
500 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
503 if(s->codec_id != CODEC_ID_H263P){
504 for(i=1; i<s->mb_num; i++){
505 int mb_xy= s->mb_index2xy[i];
507 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
508 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
509 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
516 * modify mb_type & qscale so that encoding is acually possible in mpeg4
518 void ff_clean_mpeg4_qscales(MpegEncContext *s){
520 int8_t * const qscale_table= s->current_picture.qscale_table;
522 ff_clean_h263_qscales(s);
524 if(s->pict_type== B_TYPE){
526 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
528 for(i=0; i<s->mb_num; i++){
529 int mb_xy= s->mb_index2xy[i];
530 odd += qscale_table[mb_xy]&1;
533 if(2*odd > s->mb_num) odd=1;
536 for(i=0; i<s->mb_num; i++){
537 int mb_xy= s->mb_index2xy[i];
538 if((qscale_table[mb_xy]&1) != odd)
539 qscale_table[mb_xy]++;
540 if(qscale_table[mb_xy] > 31)
541 qscale_table[mb_xy]= 31;
544 for(i=1; i<s->mb_num; i++){
545 int mb_xy= s->mb_index2xy[i];
546 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
547 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
548 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
554 #endif //CONFIG_ENCODERS
557 * @return the mb_type
559 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
560 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
561 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
562 int xy= s->block_index[0];
563 uint16_t time_pp= s->pp_time;
564 uint16_t time_pb= s->pb_time;
567 //FIXME avoid divides
569 if(IS_8X8(colocated_mb_type)){
570 s->mv_type = MV_TYPE_8X8;
572 xy= s->block_index[i];
573 s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
574 s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
575 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
576 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
577 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1]
578 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
580 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
581 } else if(IS_INTERLACED(colocated_mb_type)){
582 s->mv_type = MV_TYPE_FIELD;
584 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
585 if(s->top_field_first){
586 time_pp= s->pp_field_time - field_select + i;
587 time_pb= s->pb_field_time - field_select + i;
589 time_pp= s->pp_field_time + field_select - i;
590 time_pb= s->pb_field_time + field_select - i;
592 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
593 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
594 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
595 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
596 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
597 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
599 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
601 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
602 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
603 s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->next_picture.motion_val[0][xy][0]
604 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
605 s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->next_picture.motion_val[0][xy][1]
606 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
607 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
608 s->mv_type= MV_TYPE_16X16;
610 s->mv_type= MV_TYPE_8X8;
611 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
615 void ff_h263_update_motion_val(MpegEncContext * s){
616 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
617 //FIXME a lot of that is only needed for !low_delay
618 const int wrap = s->b8_stride;
619 const int xy = s->block_index[0];
621 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
623 if(s->mv_type != MV_TYPE_8X8){
624 int motion_x, motion_y;
628 } else if (s->mv_type == MV_TYPE_16X16) {
629 motion_x = s->mv[0][0][0];
630 motion_y = s->mv[0][0][1];
631 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
633 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
634 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
635 motion_x = (motion_x>>1) | (motion_x&1);
637 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
638 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
640 s->current_picture.ref_index[0][xy ]=
641 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
642 s->current_picture.ref_index[0][xy + wrap ]=
643 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
646 /* no update if 8X8 because it has been done during parsing */
647 s->current_picture.motion_val[0][xy][0] = motion_x;
648 s->current_picture.motion_val[0][xy][1] = motion_y;
649 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
650 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
651 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
652 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
653 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
654 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
657 if(s->encoding){ //FIXME encoding MUST be cleaned up
658 if (s->mv_type == MV_TYPE_8X8)
659 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
661 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
663 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
667 #ifdef CONFIG_ENCODERS
669 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
670 int l, bit_size, code;
675 bit_size = f_code - 1;
676 /* modulo encoding */
677 l= INT_BIT - 6 - bit_size;
680 code = (val >> bit_size) + 1;
682 return mvtab[code][1] + 1 + bit_size;
686 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
687 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
688 skip_put_bits(&s->pb,
689 h263_get_motion_length(s, x, f_code)
690 +h263_get_motion_length(s, y, f_code));
692 ff_h263_encode_motion(s, x, f_code);
693 ff_h263_encode_motion(s, y, f_code);
697 static inline int get_p_cbp(MpegEncContext * s,
698 DCTELEM block[6][64],
699 int motion_x, int motion_y){
702 if(s->flags & CODEC_FLAG_CBP_RD){
703 int best_cbpy_score= INT_MAX;
704 int best_cbpc_score= INT_MAX;
705 int cbpc = (-1), cbpy= (-1);
706 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
707 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
710 int score= inter_MCBPC_bits[i + offset] * lambda;
711 if(i&1) score += s->coded_score[5];
712 if(i&2) score += s->coded_score[4];
714 if(score < best_cbpc_score){
715 best_cbpc_score= score;
721 int score= cbpy_tab[i ^ 0xF][1] * lambda;
722 if(i&1) score += s->coded_score[3];
723 if(i&2) score += s->coded_score[2];
724 if(i&4) score += s->coded_score[1];
725 if(i&8) score += s->coded_score[0];
727 if(score < best_cbpy_score){
728 best_cbpy_score= score;
733 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
734 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
738 for (i = 0; i < 6; i++) {
739 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
740 s->block_last_index[i]= -1;
741 memset(s->block[i], 0, sizeof(DCTELEM)*64);
746 for (i = 0; i < 6; i++) {
747 if (s->block_last_index[i] >= 0)
754 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
755 int motion_x, int motion_y, int mb_type){
758 if(s->flags & CODEC_FLAG_CBP_RD){
760 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
763 if(s->coded_score[i] < 0){
764 score += s->coded_score[i];
771 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
772 zero_score-= 4; //2*MV + mb_type + cbp bit
776 if(zero_score <= score){
781 for (i = 0; i < 6; i++) {
782 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
783 s->block_last_index[i]= -1;
784 memset(s->block[i], 0, sizeof(DCTELEM)*64);
788 for (i = 0; i < 6; i++) {
789 if (s->block_last_index[i] >= 0)
796 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
797 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
801 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
802 for (i = 0; i < 6; i++) {
803 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
806 /* encode each block */
807 for (i = 0; i < 6; i++) {
808 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
812 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
813 for (i = 0; i < 6; i++) {
814 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
817 /* encode each block */
818 for (i = 0; i < 6; i++) {
819 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
825 void mpeg4_encode_mb(MpegEncContext * s,
826 DCTELEM block[6][64],
827 int motion_x, int motion_y)
829 int cbpc, cbpy, pred_x, pred_y;
830 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
831 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
832 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
833 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
834 const int dquant_code[5]= {1,0,9,2,3};
836 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
840 if(s->pict_type==B_TYPE){
841 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
842 int mb_type= mb_type_table[s->mv_dir];
849 s->last_mv[i][1][1]= 0;
853 assert(s->dquant>=-2 && s->dquant<=2);
854 assert((s->dquant&1)==0);
857 /* nothing to do if this MB was skipped in the next P Frame */
858 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
864 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
865 s->qscale -= s->dquant;
871 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
873 if ((cbp | motion_x | motion_y | mb_type) ==0) {
874 /* direct MB with MV={0,0} */
875 assert(s->dquant==0);
877 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
879 if(interleaved_stats){
887 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
888 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
889 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
890 if(cbp) put_bits(&s->pb, 6, cbp);
894 put_bits(&s->pb, 2, (s->dquant>>2)+3);
896 put_bits(&s->pb, 1, 0);
898 s->qscale -= s->dquant;
900 if(!s->progressive_sequence){
902 put_bits(&s->pb, 1, s->interlaced_dct);
903 if(mb_type) // not direct mode
904 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
907 if(interleaved_stats){
908 s->misc_bits+= get_bits_diff(s);
912 assert(s->mv_dir & MV_DIRECT);
913 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
917 assert(mb_type > 0 && mb_type < 4);
918 if(s->mv_type != MV_TYPE_FIELD){
919 if(s->mv_dir & MV_DIR_FORWARD){
920 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
921 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
922 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
923 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
926 if(s->mv_dir & MV_DIR_BACKWARD){
927 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
928 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
929 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
930 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
934 if(s->mv_dir & MV_DIR_FORWARD){
935 put_bits(&s->pb, 1, s->field_select[0][0]);
936 put_bits(&s->pb, 1, s->field_select[0][1]);
938 if(s->mv_dir & MV_DIR_BACKWARD){
939 put_bits(&s->pb, 1, s->field_select[1][0]);
940 put_bits(&s->pb, 1, s->field_select[1][1]);
942 if(s->mv_dir & MV_DIR_FORWARD){
944 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
945 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
946 s->last_mv[0][i][0]= s->mv[0][i][0];
947 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
951 if(s->mv_dir & MV_DIR_BACKWARD){
953 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
954 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
955 s->last_mv[1][i][0]= s->mv[1][i][0];
956 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
963 if(interleaved_stats){
964 s->mv_bits+= get_bits_diff(s);
967 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
969 if(interleaved_stats){
970 s->p_tex_bits+= get_bits_diff(s);
973 }else{ /* s->pict_type==B_TYPE */
974 cbp= get_p_cbp(s, block, motion_x, motion_y);
976 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
977 /* check if the B frames can skip it too, as we must skip it if we skip here
978 why didn't they just compress the skip-mb bits instead of reusing them ?! */
979 if(s->max_b_frames>0){
986 if(x+16 > s->width) x= s->width-16;
987 if(y+16 > s->height) y= s->height-16;
989 offset= x + y*s->linesize;
990 p_pic= s->new_picture.data[0] + offset;
993 for(i=0; i<s->max_b_frames; i++){
996 Picture *pic= s->reordered_input_picture[i+1];
998 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1000 b_pic= pic->data[0] + offset;
1001 if(pic->type != FF_BUFFER_TYPE_SHARED)
1002 b_pic+= INPLACE_OFFSET;
1003 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1004 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1012 if(s->mb_skipped==1){
1013 /* skip macroblock */
1014 put_bits(&s->pb, 1, 1);
1016 if(interleaved_stats){
1026 put_bits(&s->pb, 1, 0); /* mb coded */
1030 if(s->mv_type==MV_TYPE_16X16){
1031 if(s->dquant) cbpc+= 8;
1033 inter_MCBPC_bits[cbpc],
1034 inter_MCBPC_code[cbpc]);
1036 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1038 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1040 if(!s->progressive_sequence){
1042 put_bits(pb2, 1, s->interlaced_dct);
1043 put_bits(pb2, 1, 0);
1046 if(interleaved_stats){
1047 s->misc_bits+= get_bits_diff(s);
1050 /* motion vectors: 16x16 mode */
1051 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1053 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1054 motion_y - pred_y, s->f_code);
1055 }else if(s->mv_type==MV_TYPE_FIELD){
1056 if(s->dquant) cbpc+= 8;
1058 inter_MCBPC_bits[cbpc],
1059 inter_MCBPC_code[cbpc]);
1061 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1063 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1065 assert(!s->progressive_sequence);
1067 put_bits(pb2, 1, s->interlaced_dct);
1068 put_bits(pb2, 1, 1);
1070 if(interleaved_stats){
1071 s->misc_bits+= get_bits_diff(s);
1074 /* motion vectors: 16x8 interlaced mode */
1075 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1078 put_bits(&s->pb, 1, s->field_select[0][0]);
1079 put_bits(&s->pb, 1, s->field_select[0][1]);
1081 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1082 s->mv[0][0][1] - pred_y, s->f_code);
1083 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1084 s->mv[0][1][1] - pred_y, s->f_code);
1086 assert(s->mv_type==MV_TYPE_8X8);
1088 inter_MCBPC_bits[cbpc+16],
1089 inter_MCBPC_code[cbpc+16]);
1090 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1092 if(!s->progressive_sequence){
1094 put_bits(pb2, 1, s->interlaced_dct);
1097 if(interleaved_stats){
1098 s->misc_bits+= get_bits_diff(s);
1102 /* motion vectors: 8x8 mode*/
1103 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1105 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1106 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1110 if(interleaved_stats){
1111 s->mv_bits+= get_bits_diff(s);
1114 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1116 if(interleaved_stats){
1117 s->p_tex_bits+= get_bits_diff(s);
1123 int dc_diff[6]; //dc values with the dc prediction subtracted
1124 int dir[6]; //prediction direction
1125 int zigzag_last_index[6];
1126 uint8_t *scan_table[6];
1130 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1133 if(s->flags & CODEC_FLAG_AC_PRED){
1134 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1136 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1139 scan_table[i]= s->intra_scantable.permutated;
1144 for (i = 0; i < 6; i++) {
1145 if (s->block_last_index[i] >= 1)
1146 cbp |= 1 << (5 - i);
1150 if (s->pict_type == I_TYPE) {
1151 if(s->dquant) cbpc+=4;
1153 intra_MCBPC_bits[cbpc],
1154 intra_MCBPC_code[cbpc]);
1156 if(s->dquant) cbpc+=8;
1157 put_bits(&s->pb, 1, 0); /* mb coded */
1159 inter_MCBPC_bits[cbpc + 4],
1160 inter_MCBPC_code[cbpc + 4]);
1162 put_bits(pb2, 1, s->ac_pred);
1164 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1166 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1168 if(!s->progressive_sequence){
1169 put_bits(dc_pb, 1, s->interlaced_dct);
1172 if(interleaved_stats){
1173 s->misc_bits+= get_bits_diff(s);
1176 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1178 if(interleaved_stats){
1179 s->i_tex_bits+= get_bits_diff(s);
1183 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1185 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1189 void h263_encode_mb(MpegEncContext * s,
1190 DCTELEM block[6][64],
1191 int motion_x, int motion_y)
1193 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1195 int16_t rec_intradc[6];
1196 uint16_t *dc_ptr[6];
1197 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1198 const int dquant_code[5]= {1,0,9,2,3};
1200 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1203 cbp= get_p_cbp(s, block, motion_x, motion_y);
1205 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1206 /* skip macroblock */
1207 put_bits(&s->pb, 1, 1);
1208 if(interleaved_stats){
1216 put_bits(&s->pb, 1, 0); /* mb coded */
1220 if(s->alt_inter_vlc==0 || cbpc!=3)
1222 if(s->dquant) cbpc+= 8;
1223 if(s->mv_type==MV_TYPE_16X16){
1225 inter_MCBPC_bits[cbpc],
1226 inter_MCBPC_code[cbpc]);
1228 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1230 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1232 if(interleaved_stats){
1233 s->misc_bits+= get_bits_diff(s);
1236 /* motion vectors: 16x16 mode */
1237 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1240 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1241 motion_y - pred_y, 1);
1244 h263p_encode_umotion(s, motion_x - pred_x);
1245 h263p_encode_umotion(s, motion_y - pred_y);
1246 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1247 /* To prevent Start Code emulation */
1248 put_bits(&s->pb,1,1);
1252 inter_MCBPC_bits[cbpc+16],
1253 inter_MCBPC_code[cbpc+16]);
1254 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1256 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1258 if(interleaved_stats){
1259 s->misc_bits+= get_bits_diff(s);
1263 /* motion vectors: 8x8 mode*/
1264 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1266 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1267 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1269 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1270 motion_y - pred_y, 1);
1273 h263p_encode_umotion(s, motion_x - pred_x);
1274 h263p_encode_umotion(s, motion_y - pred_y);
1275 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1276 /* To prevent Start Code emulation */
1277 put_bits(&s->pb,1,1);
1282 if(interleaved_stats){
1283 s->mv_bits+= get_bits_diff(s);
1286 assert(s->mb_intra);
1291 for(i=0; i<6; i++) {
1292 int16_t level = block[i][0];
1295 if(i<4) scale= s->y_dc_scale;
1296 else scale= s->c_dc_scale;
1298 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1302 level = (level + (scale>>1))/scale;
1304 level = (level - (scale>>1))/scale;
1306 /* AIC can change CBP */
1307 if (level == 0 && s->block_last_index[i] == 0)
1308 s->block_last_index[i] = -1;
1310 if(!s->modified_quant){
1313 else if (level > 127)
1317 block[i][0] = level;
1318 /* Reconstruction */
1319 rec_intradc[i] = scale*level + pred_dc;
1321 rec_intradc[i] |= 1;
1322 //if ((rec_intradc[i] % 2) == 0)
1323 // rec_intradc[i]++;
1325 if (rec_intradc[i] < 0)
1327 else if (rec_intradc[i] > 2047)
1328 rec_intradc[i] = 2047;
1330 /* Update AC/DC tables */
1331 *dc_ptr[i] = rec_intradc[i];
1332 if (s->block_last_index[i] >= 0)
1333 cbp |= 1 << (5 - i);
1336 for(i=0; i<6; i++) {
1338 if (s->block_last_index[i] >= 1)
1339 cbp |= 1 << (5 - i);
1344 if (s->pict_type == I_TYPE) {
1345 if(s->dquant) cbpc+=4;
1347 intra_MCBPC_bits[cbpc],
1348 intra_MCBPC_code[cbpc]);
1350 if(s->dquant) cbpc+=8;
1351 put_bits(&s->pb, 1, 0); /* mb coded */
1353 inter_MCBPC_bits[cbpc + 4],
1354 inter_MCBPC_code[cbpc + 4]);
1357 /* XXX: currently, we do not try to use ac prediction */
1358 put_bits(&s->pb, 1, 0); /* no AC prediction */
1361 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1363 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1365 if(interleaved_stats){
1366 s->misc_bits+= get_bits_diff(s);
1370 for(i=0; i<6; i++) {
1371 /* encode each block */
1372 h263_encode_block(s, block[i], i);
1374 /* Update INTRADC for decoding */
1375 if (s->h263_aic && s->mb_intra) {
1376 block[i][0] = rec_intradc[i];
1381 if(interleaved_stats){
1383 s->p_tex_bits+= get_bits_diff(s);
1386 s->i_tex_bits+= get_bits_diff(s);
1393 void ff_h263_loop_filter(MpegEncContext * s){
1395 const int linesize = s->linesize;
1396 const int uvlinesize= s->uvlinesize;
1397 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1398 uint8_t *dest_y = s->dest[0];
1399 uint8_t *dest_cb= s->dest[1];
1400 uint8_t *dest_cr= s->dest[2];
1402 // if(s->pict_type==B_TYPE && !s->readable) return;
1408 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1410 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1411 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1416 int qp_dt, qp_t, qp_tc;
1418 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1421 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1429 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1430 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1431 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1433 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1434 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1438 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1441 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1444 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1447 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1448 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1449 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1450 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1456 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1457 if(s->mb_y + 1 == s->mb_height)
1458 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1463 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1466 qp_lc= s->current_picture.qscale_table[xy-1];
1469 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1470 if(s->mb_y + 1 == s->mb_height){
1471 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1472 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1473 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1474 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1480 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1482 int x, y, wrap, a, c, pred_dc, scale;
1485 /* find prediction */
1487 x = 2 * s->mb_x + (n & 1);
1488 y = 2 * s->mb_y + ((n & 2) >> 1);
1489 wrap = s->b8_stride;
1490 dc_val = s->dc_val[0];
1491 scale = s->y_dc_scale;
1495 wrap = s->mb_stride;
1496 dc_val = s->dc_val[n - 4 + 1];
1497 scale = s->c_dc_scale;
1502 a = dc_val[(x - 1) + (y) * wrap];
1503 c = dc_val[(x) + (y - 1) * wrap];
1505 /* No prediction outside GOB boundary */
1506 if(s->first_slice_line && n!=3){
1508 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1511 /* just DC prediction */
1512 if (a != 1024 && c != 1024)
1513 pred_dc = (a + c) >> 1;
1519 /* we assume pred is positive */
1520 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1521 *dc_val_ptr = &dc_val[x + y * wrap];
1525 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1527 int x, y, wrap, a, c, pred_dc, scale, i;
1528 int16_t *dc_val, *ac_val, *ac_val1;
1530 /* find prediction */
1532 x = 2 * s->mb_x + (n & 1);
1533 y = 2 * s->mb_y + (n>> 1);
1534 wrap = s->b8_stride;
1535 dc_val = s->dc_val[0];
1536 ac_val = s->ac_val[0][0];
1537 scale = s->y_dc_scale;
1541 wrap = s->mb_stride;
1542 dc_val = s->dc_val[n - 4 + 1];
1543 ac_val = s->ac_val[n - 4 + 1][0];
1544 scale = s->c_dc_scale;
1547 ac_val += ((y) * wrap + (x)) * 16;
1553 a = dc_val[(x - 1) + (y) * wrap];
1554 c = dc_val[(x) + (y - 1) * wrap];
1556 /* No prediction outside GOB boundary */
1557 if(s->first_slice_line && n!=3){
1559 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1564 if (s->h263_aic_dir) {
1565 /* left prediction */
1569 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1574 /* top prediction */
1576 ac_val -= 16 * wrap;
1578 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1584 /* just DC prediction */
1585 if (a != 1024 && c != 1024)
1586 pred_dc = (a + c) >> 1;
1593 /* we assume pred is positive */
1594 block[0]=block[0]*scale + pred_dc;
1601 /* Update AC/DC tables */
1602 dc_val[(x) + (y) * wrap] = block[0];
1606 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1609 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1612 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1616 int16_t *A, *B, *C, (*mot_val)[2];
1617 static const int off[4]= {2, 1, 1, -1};
1619 wrap = s->b8_stride;
1620 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1623 /* special case for first (slice) line */
1624 if (s->first_slice_line && block<3) {
1625 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1626 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1627 if(block==0){ //most common case
1628 if(s->mb_x == s->resync_mb_x){ //rare
1630 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1631 C = mot_val[off[block] - wrap];
1636 *px = mid_pred(A[0], 0, C[0]);
1637 *py = mid_pred(A[1], 0, C[1]);
1644 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1645 C = mot_val[off[block] - wrap];
1646 *px = mid_pred(A[0], 0, C[0]);
1647 *py = mid_pred(A[1], 0, C[1]);
1652 }else{ /* block==2*/
1653 B = mot_val[ - wrap];
1654 C = mot_val[off[block] - wrap];
1655 if(s->mb_x == s->resync_mb_x) //rare
1658 *px = mid_pred(A[0], B[0], C[0]);
1659 *py = mid_pred(A[1], B[1], C[1]);
1662 B = mot_val[ - wrap];
1663 C = mot_val[off[block] - wrap];
1664 *px = mid_pred(A[0], B[0], C[0]);
1665 *py = mid_pred(A[1], B[1], C[1]);
1670 #ifdef CONFIG_ENCODERS
1671 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1673 int range, l, bit_size, sign, code, bits;
1678 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1680 bit_size = f_code - 1;
1681 range = 1 << bit_size;
1682 /* modulo encoding */
1683 l= INT_BIT - 6 - bit_size;
1686 val= (val^sign)-sign;
1690 code = (val >> bit_size) + 1;
1691 bits = val & (range - 1);
1693 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1695 put_bits(&s->pb, bit_size, bits);
1700 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1701 static void h263p_encode_umotion(MpegEncContext * s, int val)
1711 put_bits(&s->pb, 1, 1);
1713 put_bits(&s->pb, 3, 0);
1715 put_bits(&s->pb, 3, 2);
1718 sval = ((val < 0) ? (short)(-val):(short)val);
1721 while (temp_val != 0) {
1722 temp_val = temp_val >> 1;
1728 tcode = (sval & (1 << (i-1))) >> (i-1);
1729 tcode = (tcode << 1) | 1;
1730 code = (code << 2) | tcode;
1733 code = ((code << 1) | (val < 0)) << 1;
1734 put_bits(&s->pb, (2*n_bits)+1, code);
1735 //printf("\nVal = %d\tCode = %d", sval, code);
1739 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1744 if(mv_penalty==NULL)
1745 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1747 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1748 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1751 if(mv==0) len= mvtab[0][1];
1753 int val, bit_size, range, code;
1755 bit_size = f_code - 1;
1756 range = 1 << bit_size;
1762 code = (val >> bit_size) + 1;
1764 len= mvtab[code][1] + 1 + bit_size;
1766 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1770 mv_penalty[f_code][mv+MAX_MV]= len;
1774 for(f_code=MAX_FCODE; f_code>0; f_code--){
1775 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1776 fcode_tab[mv+MAX_MV]= f_code;
1780 for(mv=0; mv<MAX_MV*2+1; mv++){
1781 umv_fcode_tab[mv]= 1;
1786 #ifdef CONFIG_ENCODERS
1788 static void init_uni_dc_tab(void)
1790 int level, uni_code, uni_len;
1792 for(level=-256; level<256; level++){
1794 /* find number of bits */
1803 l= (-level) ^ ((1 << size) - 1);
1808 uni_code= DCtab_lum[size][0];
1809 uni_len = DCtab_lum[size][1];
1812 uni_code<<=size; uni_code|=l;
1815 uni_code<<=1; uni_code|=1;
1819 uni_DCtab_lum_bits[level+256]= uni_code;
1820 uni_DCtab_lum_len [level+256]= uni_len;
1823 uni_code= DCtab_chrom[size][0];
1824 uni_len = DCtab_chrom[size][1];
1827 uni_code<<=size; uni_code|=l;
1830 uni_code<<=1; uni_code|=1;
1834 uni_DCtab_chrom_bits[level+256]= uni_code;
1835 uni_DCtab_chrom_len [level+256]= uni_len;
1840 #endif //CONFIG_ENCODERS
1842 #ifdef CONFIG_ENCODERS
1843 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1844 int slevel, run, last;
1846 assert(MAX_LEVEL >= 64);
1847 assert(MAX_RUN >= 63);
1849 for(slevel=-64; slevel<64; slevel++){
1850 if(slevel==0) continue;
1851 for(run=0; run<64; run++){
1852 for(last=0; last<=1; last++){
1853 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1854 int level= slevel < 0 ? -slevel : slevel;
1855 int sign= slevel < 0 ? 1 : 0;
1856 int bits, len, code;
1859 len_tab[index]= 100;
1862 code= get_rl_index(rl, last, run, level);
1863 bits= rl->table_vlc[code][0];
1864 len= rl->table_vlc[code][1];
1865 bits=bits*2+sign; len++;
1867 if(code!=rl->n && len < len_tab[index]){
1868 bits_tab[index]= bits;
1869 len_tab [index]= len;
1873 bits= rl->table_vlc[rl->n][0];
1874 len= rl->table_vlc[rl->n][1];
1875 bits=bits*2; len++; //esc1
1876 level1= level - rl->max_level[last][run];
1878 code= get_rl_index(rl, last, run, level1);
1879 bits<<= rl->table_vlc[code][1];
1880 len += rl->table_vlc[code][1];
1881 bits += rl->table_vlc[code][0];
1882 bits=bits*2+sign; len++;
1884 if(code!=rl->n && len < len_tab[index]){
1885 bits_tab[index]= bits;
1886 len_tab [index]= len;
1892 bits= rl->table_vlc[rl->n][0];
1893 len= rl->table_vlc[rl->n][1];
1894 bits=bits*4+2; len+=2; //esc2
1895 run1 = run - rl->max_run[last][level] - 1;
1897 code= get_rl_index(rl, last, run1, level);
1898 bits<<= rl->table_vlc[code][1];
1899 len += rl->table_vlc[code][1];
1900 bits += rl->table_vlc[code][0];
1901 bits=bits*2+sign; len++;
1903 if(code!=rl->n && len < len_tab[index]){
1904 bits_tab[index]= bits;
1905 len_tab [index]= len;
1910 bits= rl->table_vlc[rl->n][0];
1911 len = rl->table_vlc[rl->n][1];
1912 bits=bits*4+3; len+=2; //esc3
1913 bits=bits*2+last; len++;
1914 bits=bits*64+run; len+=6;
1915 bits=bits*2+1; len++; //marker
1916 bits=bits*4096+(slevel&0xfff); len+=12;
1917 bits=bits*2+1; len++; //marker
1919 if(len < len_tab[index]){
1920 bits_tab[index]= bits;
1921 len_tab [index]= len;
1928 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1929 int slevel, run, last;
1931 assert(MAX_LEVEL >= 64);
1932 assert(MAX_RUN >= 63);
1934 for(slevel=-64; slevel<64; slevel++){
1935 if(slevel==0) continue;
1936 for(run=0; run<64; run++){
1937 for(last=0; last<=1; last++){
1938 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1939 int level= slevel < 0 ? -slevel : slevel;
1940 int sign= slevel < 0 ? 1 : 0;
1941 int bits, len, code;
1943 len_tab[index]= 100;
1946 code= get_rl_index(rl, last, run, level);
1947 bits= rl->table_vlc[code][0];
1948 len= rl->table_vlc[code][1];
1949 bits=bits*2+sign; len++;
1951 if(code!=rl->n && len < len_tab[index]){
1952 if(bits_tab) bits_tab[index]= bits;
1953 len_tab [index]= len;
1956 bits= rl->table_vlc[rl->n][0];
1957 len = rl->table_vlc[rl->n][1];
1958 bits=bits*2+last; len++;
1959 bits=bits*64+run; len+=6;
1960 bits=bits*256+(level&0xff); len+=8;
1962 if(len < len_tab[index]){
1963 if(bits_tab) bits_tab[index]= bits;
1964 len_tab [index]= len;
1971 void h263_encode_init(MpegEncContext *s)
1973 static int done = 0;
1980 init_rl(&rl_inter, 1);
1981 init_rl(&rl_intra, 1);
1982 init_rl(&rl_intra_aic, 1);
1984 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1985 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1987 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1988 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
1990 init_mv_penalty_and_fcode(s);
1992 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1994 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
1995 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1997 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
1998 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2000 s->ac_esc_length= 7+1+6+8;
2002 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2003 switch(s->codec_id){
2004 case CODEC_ID_MPEG4:
2005 s->fcode_tab= fcode_tab;
2006 s->min_qcoeff= -2048;
2007 s->max_qcoeff= 2047;
2008 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2009 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2010 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2011 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2012 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2013 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2014 s->ac_esc_length= 7+2+1+6+1+12+1;
2015 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2016 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2018 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2020 s->avctx->extradata= av_malloc(1024);
2021 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2023 if(!(s->workaround_bugs & FF_BUG_MS))
2024 mpeg4_encode_visual_object_header(s);
2025 mpeg4_encode_vol_header(s, 0, 0);
2027 // ff_mpeg4_stuffing(&s->pb); ?
2028 flush_put_bits(&s->pb);
2029 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2033 case CODEC_ID_H263P:
2035 s->fcode_tab= umv_fcode_tab;
2036 if(s->modified_quant){
2037 s->min_qcoeff= -2047;
2038 s->max_qcoeff= 2047;
2040 s->min_qcoeff= -127;
2044 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2046 if (s->h263_flv > 1) {
2047 s->min_qcoeff= -1023;
2048 s->max_qcoeff= 1023;
2050 s->min_qcoeff= -127;
2053 s->y_dc_scale_table=
2054 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2056 default: //nothing needed - default table already set in mpegvideo.c
2057 s->min_qcoeff= -127;
2059 s->y_dc_scale_table=
2060 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2065 * encodes a 8x8 block.
2066 * @param block the 8x8 block
2067 * @param n block index (0-3 are luma, 4-5 are chroma)
2069 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2071 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2075 if (s->mb_intra && !s->h263_aic) {
2078 /* 255 cannot be represented, so we clamp */
2083 /* 0 cannot be represented also */
2084 else if (level < 1) {
2088 if (level == 128) //FIXME check rv10
2089 put_bits(&s->pb, 8, 0xff);
2091 put_bits(&s->pb, 8, level);
2095 if (s->h263_aic && s->mb_intra)
2098 if(s->alt_inter_vlc && !s->mb_intra){
2100 int inter_vlc_bits=0;
2104 last_index = s->block_last_index[n];
2105 last_non_zero = i - 1;
2106 for (; i <= last_index; i++) {
2107 j = s->intra_scantable.permutated[i];
2110 run = i - last_non_zero - 1;
2111 last = (i == last_index);
2113 if(level<0) level= -level;
2115 code = get_rl_index(rl, last, run, level);
2116 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2117 inter_vlc_bits += rl->table_vlc[code][1]+1;
2118 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2120 if (code == rl->n) {
2121 inter_vlc_bits += 1+6+8-1;
2123 if (aic_code == rl_intra_aic.n) {
2124 aic_vlc_bits += 1+6+8-1;
2125 wrong_pos += run + 1;
2127 wrong_pos += wrong_run[aic_code];
2132 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2138 last_index = s->block_last_index[n];
2139 last_non_zero = i - 1;
2140 for (; i <= last_index; i++) {
2141 j = s->intra_scantable.permutated[i];
2144 run = i - last_non_zero - 1;
2145 last = (i == last_index);
2152 code = get_rl_index(rl, last, run, level);
2153 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2154 if (code == rl->n) {
2155 if(s->h263_flv <= 1){
2156 put_bits(&s->pb, 1, last);
2157 put_bits(&s->pb, 6, run);
2159 assert(slevel != 0);
2162 put_bits(&s->pb, 8, slevel & 0xff);
2164 put_bits(&s->pb, 8, 128);
2165 put_bits(&s->pb, 5, slevel & 0x1f);
2166 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2169 if(level < 64) { // 7-bit level
2170 put_bits(&s->pb, 1, 0);
2171 put_bits(&s->pb, 1, last);
2172 put_bits(&s->pb, 6, run);
2174 put_bits(&s->pb, 7, slevel & 0x7f);
2177 put_bits(&s->pb, 1, 1);
2178 put_bits(&s->pb, 1, last);
2179 put_bits(&s->pb, 6, run);
2181 put_bits(&s->pb, 11, slevel & 0x7ff);
2185 put_bits(&s->pb, 1, sign);
2193 #ifdef CONFIG_ENCODERS
2195 /***************************************************/
2197 * add mpeg4 stuffing bits (01...1)
2199 void ff_mpeg4_stuffing(PutBitContext * pbc)
2202 put_bits(pbc, 1, 0);
2203 length= (-put_bits_count(pbc))&7;
2204 if(length) put_bits(pbc, length, (1<<length)-1);
2207 /* must be called before writing the header */
2208 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2209 int time_div, time_mod;
2211 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2212 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2214 time_div= s->time/s->avctx->time_base.den;
2215 time_mod= s->time%s->avctx->time_base.den;
2217 if(s->pict_type==B_TYPE){
2218 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2219 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2221 s->last_time_base= s->time_base;
2222 s->time_base= time_div;
2223 s->pp_time= s->time - s->last_non_b_time;
2224 s->last_non_b_time= s->time;
2225 assert(picture_number==0 || s->pp_time > 0);
2229 static void mpeg4_encode_gop_header(MpegEncContext * s){
2230 int hours, minutes, seconds;
2233 put_bits(&s->pb, 16, 0);
2234 put_bits(&s->pb, 16, GOP_STARTCODE);
2236 time= s->current_picture_ptr->pts;
2237 if(s->reordered_input_picture[1])
2238 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2239 time= time*s->avctx->time_base.num;
2241 seconds= time/s->avctx->time_base.den;
2242 minutes= seconds/60; seconds %= 60;
2243 hours= minutes/60; minutes %= 60;
2246 put_bits(&s->pb, 5, hours);
2247 put_bits(&s->pb, 6, minutes);
2248 put_bits(&s->pb, 1, 1);
2249 put_bits(&s->pb, 6, seconds);
2251 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2252 put_bits(&s->pb, 1, 0); //broken link == NO
2254 s->last_time_base= time / s->avctx->time_base.den;
2256 ff_mpeg4_stuffing(&s->pb);
2259 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2260 int profile_and_level_indication;
2263 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2264 profile_and_level_indication = s->avctx->profile << 4;
2265 }else if(s->max_b_frames || s->quarter_sample){
2266 profile_and_level_indication= 0xF0; // adv simple
2268 profile_and_level_indication= 0x00; // simple
2271 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2272 profile_and_level_indication |= s->avctx->level;
2274 profile_and_level_indication |= 1; //level 1
2277 if(profile_and_level_indication>>4 == 0xF){
2285 put_bits(&s->pb, 16, 0);
2286 put_bits(&s->pb, 16, VOS_STARTCODE);
2288 put_bits(&s->pb, 8, profile_and_level_indication);
2290 put_bits(&s->pb, 16, 0);
2291 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2293 put_bits(&s->pb, 1, 1);
2294 put_bits(&s->pb, 4, vo_ver_id);
2295 put_bits(&s->pb, 3, 1); //priority
2297 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2299 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2301 ff_mpeg4_stuffing(&s->pb);
2304 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2308 if(s->max_b_frames || s->quarter_sample){
2310 s->vo_type= ADV_SIMPLE_VO_TYPE;
2313 s->vo_type= SIMPLE_VO_TYPE;
2316 put_bits(&s->pb, 16, 0);
2317 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2318 put_bits(&s->pb, 16, 0);
2319 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2321 put_bits(&s->pb, 1, 0); /* random access vol */
2322 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2323 if(s->workaround_bugs & FF_BUG_MS) {
2324 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2326 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2327 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2328 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2331 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2333 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2334 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2335 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2336 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2339 if(s->workaround_bugs & FF_BUG_MS) { //
2340 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2342 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2343 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2344 put_bits(&s->pb, 1, s->low_delay);
2345 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2348 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2349 put_bits(&s->pb, 1, 1); /* marker bit */
2351 put_bits(&s->pb, 16, s->avctx->time_base.den);
2352 if (s->time_increment_bits < 1)
2353 s->time_increment_bits = 1;
2354 put_bits(&s->pb, 1, 1); /* marker bit */
2355 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2356 put_bits(&s->pb, 1, 1); /* marker bit */
2357 put_bits(&s->pb, 13, s->width); /* vol width */
2358 put_bits(&s->pb, 1, 1); /* marker bit */
2359 put_bits(&s->pb, 13, s->height); /* vol height */
2360 put_bits(&s->pb, 1, 1); /* marker bit */
2361 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2362 put_bits(&s->pb, 1, 1); /* obmc disable */
2363 if (vo_ver_id == 1) {
2364 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2366 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2369 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2370 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2373 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2374 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2378 put_bits(&s->pb, 1, s->quarter_sample);
2379 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2380 s->resync_marker= s->rtp_mode;
2381 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2382 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2383 if(s->data_partitioning){
2384 put_bits(&s->pb, 1, 0); /* no rvlc */
2387 if (vo_ver_id != 1){
2388 put_bits(&s->pb, 1, 0); /* newpred */
2389 put_bits(&s->pb, 1, 0); /* reduced res vop */
2391 put_bits(&s->pb, 1, 0); /* scalability */
2393 ff_mpeg4_stuffing(&s->pb);
2396 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2397 put_bits(&s->pb, 16, 0);
2398 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2399 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2403 /* write mpeg4 VOP header */
2404 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2407 int time_div, time_mod;
2409 if(s->pict_type==I_TYPE){
2410 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2411 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2412 mpeg4_encode_visual_object_header(s);
2413 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2414 mpeg4_encode_vol_header(s, 0, 0);
2416 if(!(s->workaround_bugs & FF_BUG_MS))
2417 mpeg4_encode_gop_header(s);
2420 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2422 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2424 put_bits(&s->pb, 16, 0); /* vop header */
2425 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2426 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2429 time_div= s->time/s->avctx->time_base.den;
2430 time_mod= s->time%s->avctx->time_base.den;
2431 time_incr= time_div - s->last_time_base;
2432 assert(time_incr >= 0);
2434 put_bits(&s->pb, 1, 1);
2436 put_bits(&s->pb, 1, 0);
2438 put_bits(&s->pb, 1, 1); /* marker */
2439 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2440 put_bits(&s->pb, 1, 1); /* marker */
2441 put_bits(&s->pb, 1, 1); /* vop coded */
2442 if ( s->pict_type == P_TYPE
2443 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2444 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2446 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2447 if(!s->progressive_sequence){
2448 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2449 put_bits(&s->pb, 1, s->alternate_scan);
2451 //FIXME sprite stuff
2453 put_bits(&s->pb, 5, s->qscale);
2455 if (s->pict_type != I_TYPE)
2456 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2457 if (s->pict_type == B_TYPE)
2458 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2459 // printf("****frame %d\n", picture_number);
2462 #endif //CONFIG_ENCODERS
2465 * set qscale and update qscale dependant variables.
2467 void ff_set_qscale(MpegEncContext * s, int qscale)
2471 else if (qscale > 31)
2475 s->chroma_qscale= s->chroma_qscale_table[qscale];
2477 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2478 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2483 * encoding quantized level -> quantized diff
2484 * decoding quantized diff -> quantized level
2485 * @param n block index (0-3 are luma, 4-5 are chroma)
2486 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2488 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2490 int a, b, c, wrap, pred, scale, ret;
2493 /* find prediction */
2495 scale = s->y_dc_scale;
2497 scale = s->c_dc_scale;
2502 wrap= s->block_wrap[n];
2503 dc_val = s->dc_val[0] + s->block_index[n];
2509 b = dc_val[ - 1 - wrap];
2510 c = dc_val[ - wrap];
2512 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2513 if(s->first_slice_line && n!=3){
2515 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2517 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2518 if(n==0 || n==4 || n==5)
2522 if (abs(a - b) < abs(b - c)) {
2524 *dir_ptr = 1; /* top */
2527 *dir_ptr = 0; /* left */
2529 /* we assume pred is positive */
2530 pred = FASTDIV((pred + (scale >> 1)), scale);
2537 if(s->error_resilience>=3){
2539 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2542 if(level*scale > 2048 + scale){
2543 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2552 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2562 * @param n block index (0-3 are luma, 4-5 are chroma)
2563 * @param dir the ac prediction direction
2565 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2569 int16_t *ac_val, *ac_val1;
2570 int8_t * const qscale_table= s->current_picture.qscale_table;
2572 /* find prediction */
2573 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2577 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2578 /* left prediction */
2581 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2584 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2587 /* different qscale, we must rescale */
2589 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2593 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2594 /* top prediction */
2595 ac_val -= 16 * s->block_wrap[n];
2597 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2600 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2603 /* different qscale, we must rescale */
2605 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2612 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2616 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2620 #ifdef CONFIG_ENCODERS
2623 * encodes the dc value.
2624 * @param n block index (0-3 are luma, 4-5 are chroma)
2626 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2629 // if(level<-255 || level>255) printf("dc overflow\n");
2633 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2636 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2640 /* find number of bits */
2650 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2653 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2656 /* encode remaining bits */
2659 level = (-level) ^ ((1 << size) - 1);
2660 put_bits(&s->pb, size, level);
2662 put_bits(&s->pb, 1, 1);
2667 static inline int mpeg4_get_dc_length(int level, int n){
2669 return uni_DCtab_lum_len[level + 256];
2671 return uni_DCtab_chrom_len[level + 256];
2676 * encodes a 8x8 block
2677 * @param n block index (0-3 are luma, 4-5 are chroma)
2679 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2680 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2682 int i, last_non_zero;
2683 #if 0 //variables for the outcommented version
2684 int code, sign, last;
2689 const int last_index = s->block_last_index[n];
2691 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2692 /* mpeg4 based DC predictor */
2693 mpeg4_encode_dc(dc_pb, intra_dc, n);
2694 if(last_index<1) return;
2697 bits_tab= uni_mpeg4_intra_rl_bits;
2698 len_tab = uni_mpeg4_intra_rl_len;
2700 if(last_index<0) return;
2703 bits_tab= uni_mpeg4_inter_rl_bits;
2704 len_tab = uni_mpeg4_inter_rl_len;
2708 last_non_zero = i - 1;
2710 for (; i < last_index; i++) {
2711 int level = block[ scan_table[i] ];
2713 int run = i - last_non_zero - 1;
2715 if((level&(~127)) == 0){
2716 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2717 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2719 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);
2724 /*if(i<=last_index)*/{
2725 int level = block[ scan_table[i] ];
2726 int run = i - last_non_zero - 1;
2728 if((level&(~127)) == 0){
2729 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2730 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2732 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);
2736 for (; i <= last_index; i++) {
2737 const int slevel = block[ scan_table[i] ];
2740 int run = i - last_non_zero - 1;
2741 last = (i == last_index);
2748 code = get_rl_index(rl, last, run, level);
2749 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2750 if (code == rl->n) {
2752 level1 = level - rl->max_level[last][run];
2755 code = get_rl_index(rl, last, run, level1);
2756 if (code == rl->n) {
2758 put_bits(ac_pb, 1, 1);
2759 if (level > MAX_LEVEL)
2761 run1 = run - rl->max_run[last][level] - 1;
2764 code = get_rl_index(rl, last, run1, level);
2765 if (code == rl->n) {
2768 put_bits(ac_pb, 1, 1);
2769 put_bits(ac_pb, 1, last);
2770 put_bits(ac_pb, 6, run);
2771 put_bits(ac_pb, 1, 1);
2772 put_bits(ac_pb, 12, slevel & 0xfff);
2773 put_bits(ac_pb, 1, 1);
2776 put_bits(ac_pb, 1, 0);
2777 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2778 put_bits(ac_pb, 1, sign);
2782 put_bits(ac_pb, 1, 0);
2783 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2784 put_bits(ac_pb, 1, sign);
2787 put_bits(ac_pb, 1, sign);
2795 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2796 uint8_t *scan_table)
2798 int i, last_non_zero;
2801 const int last_index = s->block_last_index[n];
2804 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2805 /* mpeg4 based DC predictor */
2806 len += mpeg4_get_dc_length(intra_dc, n);
2807 if(last_index<1) return len;
2810 len_tab = uni_mpeg4_intra_rl_len;
2812 if(last_index<0) return 0;
2815 len_tab = uni_mpeg4_inter_rl_len;
2819 last_non_zero = i - 1;
2820 for (; i < last_index; i++) {
2821 int level = block[ scan_table[i] ];
2823 int run = i - last_non_zero - 1;
2825 if((level&(~127)) == 0){
2826 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2827 len += len_tab[index];
2829 len += 7+2+1+6+1+12+1;
2834 /*if(i<=last_index)*/{
2835 int level = block[ scan_table[i] ];
2836 int run = i - last_non_zero - 1;
2838 if((level&(~127)) == 0){
2839 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2840 len += len_tab[index];
2842 len += 7+2+1+6+1+12+1;
2852 /***********************************************/
2855 static VLC intra_MCBPC_vlc;
2856 static VLC inter_MCBPC_vlc;
2857 static VLC cbpy_vlc;
2859 static VLC dc_lum, dc_chrom;
2860 static VLC sprite_trajectory;
2861 static VLC mb_type_b_vlc;
2862 static VLC h263_mbtype_b_vlc;
2863 static VLC cbpc_b_vlc;
2865 void init_vlc_rl(RLTable *rl, int use_static)
2869 /* Return if static table is already initialized */
2870 if(use_static && rl->rl_vlc[0])
2873 init_vlc(&rl->vlc, 9, rl->n + 1,
2874 &rl->table_vlc[0][1], 4, 2,
2875 &rl->table_vlc[0][0], 4, 2, use_static);
2878 for(q=0; q<32; q++){
2887 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2889 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2890 for(i=0; i<rl->vlc.table_size; i++){
2891 int code= rl->vlc.table[i][0];
2892 int len = rl->vlc.table[i][1];
2895 if(len==0){ // illegal code
2898 }else if(len<0){ //more bits needed
2902 if(code==rl->n){ //esc
2906 run= rl->table_run [code] + 1;
2907 level= rl->table_level[code] * qmul + qadd;
2908 if(code >= rl->last) run+=192;
2911 rl->rl_vlc[q][i].len= len;
2912 rl->rl_vlc[q][i].level= level;
2913 rl->rl_vlc[q][i].run= run;
2920 /* XXX: find a better solution to handle static init */
2921 void h263_decode_init_vlc(MpegEncContext *s)
2923 static int done = 0;
2928 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2929 intra_MCBPC_bits, 1, 1,
2930 intra_MCBPC_code, 1, 1, 1);
2931 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2932 inter_MCBPC_bits, 1, 1,
2933 inter_MCBPC_code, 1, 1, 1);
2934 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2935 &cbpy_tab[0][1], 2, 1,
2936 &cbpy_tab[0][0], 2, 1, 1);
2937 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2939 &mvtab[0][0], 2, 1, 1);
2940 init_rl(&rl_inter, 1);
2941 init_rl(&rl_intra, 1);
2942 init_rl(&rvlc_rl_inter, 1);
2943 init_rl(&rvlc_rl_intra, 1);
2944 init_rl(&rl_intra_aic, 1);
2945 init_vlc_rl(&rl_inter, 1);
2946 init_vlc_rl(&rl_intra, 1);
2947 init_vlc_rl(&rvlc_rl_inter, 1);
2948 init_vlc_rl(&rvlc_rl_intra, 1);
2949 init_vlc_rl(&rl_intra_aic, 1);
2950 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2951 &DCtab_lum[0][1], 2, 1,
2952 &DCtab_lum[0][0], 2, 1, 1);
2953 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2954 &DCtab_chrom[0][1], 2, 1,
2955 &DCtab_chrom[0][0], 2, 1, 1);
2956 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2957 &sprite_trajectory_tab[0][1], 4, 2,
2958 &sprite_trajectory_tab[0][0], 4, 2, 1);
2959 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2960 &mb_type_b_tab[0][1], 2, 1,
2961 &mb_type_b_tab[0][0], 2, 1, 1);
2962 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2963 &h263_mbtype_b_tab[0][1], 2, 1,
2964 &h263_mbtype_b_tab[0][0], 2, 1, 1);
2965 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2966 &cbpc_b_tab[0][1], 2, 1,
2967 &cbpc_b_tab[0][0], 2, 1, 1);
2972 * Get the GOB height based on picture height.
2974 int ff_h263_get_gob_height(MpegEncContext *s){
2975 if (s->height <= 400)
2977 else if (s->height <= 800)
2983 int ff_h263_decode_mba(MpegEncContext *s)
2988 if(s->mb_num-1 <= ff_mba_max[i]) break;
2990 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2991 s->mb_x= mb_pos % s->mb_width;
2992 s->mb_y= mb_pos / s->mb_width;
2997 void ff_h263_encode_mba(MpegEncContext *s)
3002 if(s->mb_num-1 <= ff_mba_max[i]) break;
3004 mb_pos= s->mb_x + s->mb_width*s->mb_y;
3005 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3009 * decodes the group of blocks header or slice header.
3010 * @return <0 if an error occured
3012 static int h263_decode_gob_header(MpegEncContext *s)
3014 unsigned int val, gfid, gob_number;
3017 /* Check for GOB Start Code */
3018 val = show_bits(&s->gb, 16);
3022 /* We have a GBSC probably with GSTUFF */
3023 skip_bits(&s->gb, 16); /* Drop the zeros */
3024 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3025 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3026 for(;left>13; left--){
3027 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3032 if(s->h263_slice_structured){
3033 if(get_bits1(&s->gb)==0)
3036 ff_h263_decode_mba(s);
3038 if(s->mb_num > 1583)
3039 if(get_bits1(&s->gb)==0)
3042 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3043 if(get_bits1(&s->gb)==0)
3045 gfid = get_bits(&s->gb, 2); /* GFID */
3047 gob_number = get_bits(&s->gb, 5); /* GN */
3049 s->mb_y= s->gob_index* gob_number;
3050 gfid = get_bits(&s->gb, 2); /* GFID */
3051 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3054 if(s->mb_y >= s->mb_height)
3063 static inline void memsetw(short *tab, int val, int n)
3070 #ifdef CONFIG_ENCODERS
3072 void ff_mpeg4_init_partitions(MpegEncContext *s)
3074 uint8_t *start= pbBufPtr(&s->pb);
3075 uint8_t *end= s->pb.buf_end;
3076 int size= end - start;
3077 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3078 int tex_size= (size - 2*pb_size)&(~3);
3080 set_put_bits_buffer_size(&s->pb, pb_size);
3081 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3082 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3085 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3087 const int pb2_len = put_bits_count(&s->pb2 );
3088 const int tex_pb_len= put_bits_count(&s->tex_pb);
3089 const int bits= put_bits_count(&s->pb);
3091 if(s->pict_type==I_TYPE){
3092 put_bits(&s->pb, 19, DC_MARKER);
3093 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3094 s->i_tex_bits+= tex_pb_len;
3096 put_bits(&s->pb, 17, MOTION_MARKER);
3097 s->misc_bits+=17 + pb2_len;
3098 s->mv_bits+= bits - s->last_bits;
3099 s->p_tex_bits+= tex_pb_len;
3102 flush_put_bits(&s->pb2);
3103 flush_put_bits(&s->tex_pb);
3105 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3106 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3107 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3108 s->last_bits= put_bits_count(&s->pb);
3111 #endif //CONFIG_ENCODERS
3113 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3114 switch(s->pict_type){
3119 return s->f_code+15;
3121 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3127 #ifdef CONFIG_ENCODERS
3129 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3131 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3133 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3134 put_bits(&s->pb, 1, 1);
3136 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3137 put_bits(&s->pb, s->quant_precision, s->qscale);
3138 put_bits(&s->pb, 1, 0); /* no HEC */
3141 #endif //CONFIG_ENCODERS
3144 * check if the next stuff is a resync marker or the end.
3147 static inline int mpeg4_is_resync(MpegEncContext *s){
3148 const int bits_count= get_bits_count(&s->gb);
3150 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3154 if(bits_count + 8 >= s->gb.size_in_bits){
3155 int v= show_bits(&s->gb, 8);
3156 v|= 0x7F >> (7-(bits_count&7));
3161 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3163 GetBitContext gb= s->gb;
3165 skip_bits(&s->gb, 1);
3166 align_get_bits(&s->gb);
3168 for(len=0; len<32; len++){
3169 if(get_bits1(&s->gb)) break;
3174 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3182 * decodes the next video packet.
3183 * @return <0 if something went wrong
3185 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3187 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3188 int header_extension=0, mb_num, len;
3190 /* is there enough space left for a video packet + header */
3191 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3193 for(len=0; len<32; len++){
3194 if(get_bits1(&s->gb)) break;
3197 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3198 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3202 if(s->shape != RECT_SHAPE){
3203 header_extension= get_bits1(&s->gb);
3204 //FIXME more stuff here
3207 mb_num= get_bits(&s->gb, mb_num_bits);
3208 if(mb_num>=s->mb_num){
3209 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3212 if(s->pict_type == B_TYPE){
3213 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3214 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3217 s->mb_x= mb_num % s->mb_width;
3218 s->mb_y= mb_num / s->mb_width;
3220 if(s->shape != BIN_ONLY_SHAPE){
3221 int qscale= get_bits(&s->gb, s->quant_precision);
3223 s->chroma_qscale=s->qscale= qscale;
3226 if(s->shape == RECT_SHAPE){
3227 header_extension= get_bits1(&s->gb);
3229 if(header_extension){
3233 while (get_bits1(&s->gb) != 0)
3236 check_marker(&s->gb, "before time_increment in video packed header");
3237 time_increment= get_bits(&s->gb, s->time_increment_bits);
3238 check_marker(&s->gb, "before vop_coding_type in video packed header");
3240 skip_bits(&s->gb, 2); /* vop coding type */
3241 //FIXME not rect stuff here
3243 if(s->shape != BIN_ONLY_SHAPE){
3244 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3245 //FIXME don't just ignore everything
3246 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3247 mpeg4_decode_sprite_trajectory(s, &s->gb);
3248 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3251 //FIXME reduced res stuff here
3253 if (s->pict_type != I_TYPE) {
3254 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3256 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3259 if (s->pict_type == B_TYPE) {
3260 int b_code = get_bits(&s->gb, 3);
3262 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3267 //FIXME new-pred stuff
3269 //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));
3274 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3276 int c_wrap, c_xy, l_wrap, l_xy;
3278 l_wrap= s->b8_stride;
3279 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3280 c_wrap= s->mb_stride;
3281 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3285 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3286 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3287 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3291 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3292 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3293 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3296 // we can't clear the MVs as they might be needed by a b frame
3297 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3298 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3299 s->last_mv[0][0][0]=
3300 s->last_mv[0][0][1]=
3301 s->last_mv[1][0][0]=
3302 s->last_mv[1][0][1]= 0;
3306 * decodes the group of blocks / video packet header.
3307 * @return <0 if no resync found
3309 int ff_h263_resync(MpegEncContext *s){
3312 if(s->codec_id==CODEC_ID_MPEG4){
3314 align_get_bits(&s->gb);
3317 if(show_bits(&s->gb, 16)==0){
3318 if(s->codec_id==CODEC_ID_MPEG4)
3319 ret= mpeg4_decode_video_packet_header(s);
3321 ret= h263_decode_gob_header(s);
3325 //ok, it's not where its supposed to be ...
3326 s->gb= s->last_resync_gb;
3327 align_get_bits(&s->gb);
3328 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3330 for(;left>16+1+5+5; left-=8){
3331 if(show_bits(&s->gb, 16)==0){
3332 GetBitContext bak= s->gb;
3334 if(s->codec_id==CODEC_ID_MPEG4)
3335 ret= mpeg4_decode_video_packet_header(s);
3337 ret= h263_decode_gob_header(s);
3343 skip_bits(&s->gb, 8);
3350 * gets the average motion vector for a GMC MB.
3351 * @param n either 0 for the x component or 1 for y
3352 * @returns the average MV for a GMC MB
3354 static inline int get_amv(MpegEncContext *s, int n){
3355 int x, y, mb_v, sum, dx, dy, shift;
3356 int len = 1 << (s->f_code + 4);
3357 const int a= s->sprite_warping_accuracy;
3359 if(s->workaround_bugs & FF_BUG_AMV)
3360 len >>= s->quarter_sample;
3362 if(s->real_sprite_warping_points==1){
3363 if(s->divx_version==500 && s->divx_build==413)
3364 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3366 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3368 dx= s->sprite_delta[n][0];
3369 dy= s->sprite_delta[n][1];
3370 shift= s->sprite_shift[0];
3371 if(n) dy -= 1<<(shift + a + 1);
3372 else dx -= 1<<(shift + a + 1);
3373 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3376 for(y=0; y<16; y++){
3380 //XXX FIXME optimize
3381 for(x=0; x<16; x++){
3386 sum= RSHIFT(sum, a+8-s->quarter_sample);
3389 if (sum < -len) sum= -len;
3390 else if (sum >= len) sum= len-1;
3396 * decodes first partition.
3397 * @return number of MBs decoded or <0 if an error occured
3399 static int mpeg4_decode_partition_a(MpegEncContext *s){
3401 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3403 /* decode first partition */
3405 s->first_slice_line=1;
3406 for(; s->mb_y<s->mb_height; s->mb_y++){
3407 ff_init_block_index(s);
3408 for(; s->mb_x<s->mb_width; s->mb_x++){
3409 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3414 ff_update_block_index(s);
3415 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3416 s->first_slice_line=0;
3418 if(s->pict_type==I_TYPE){
3422 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3426 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3428 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3433 s->cbp_table[xy]= cbpc & 3;
3434 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3438 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3440 s->current_picture.qscale_table[xy]= s->qscale;
3442 s->mbintra_table[xy]= 1;
3445 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3447 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3451 if(dc_pred_dir) dir|=1;
3453 s->pred_dir_table[xy]= dir;
3454 }else{ /* P/S_TYPE */
3455 int mx, my, pred_x, pred_y, bits;
3456 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3457 const int stride= s->b8_stride*2;
3460 bits= show_bits(&s->gb, 17);
3461 if(bits==MOTION_MARKER){
3467 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3468 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3472 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3475 mot_val[0 ]= mot_val[2 ]=
3476 mot_val[0+stride]= mot_val[2+stride]= mx;
3477 mot_val[1 ]= mot_val[3 ]=
3478 mot_val[1+stride]= mot_val[3+stride]= my;
3480 if(s->mbintra_table[xy])
3481 ff_clean_intra_table_entries(s);
3485 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3487 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3493 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3495 s->mb_intra = ((cbpc & 4) != 0);
3498 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499 s->mbintra_table[xy]= 1;
3500 mot_val[0 ]= mot_val[2 ]=
3501 mot_val[0+stride]= mot_val[2+stride]= 0;
3502 mot_val[1 ]= mot_val[3 ]=
3503 mot_val[1+stride]= mot_val[3+stride]= 0;
3505 if(s->mbintra_table[xy])
3506 ff_clean_intra_table_entries(s);
3508 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3509 s->mcsel= get_bits1(&s->gb);
3512 if ((cbpc & 16) == 0) {
3513 /* 16x16 motion prediction */
3515 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3517 mx = h263_decode_motion(s, pred_x, s->f_code);
3521 my = h263_decode_motion(s, pred_y, s->f_code);
3524 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3528 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3531 mot_val[0 ]= mot_val[2 ] =
3532 mot_val[0+stride]= mot_val[2+stride]= mx;
3533 mot_val[1 ]= mot_val[3 ]=
3534 mot_val[1+stride]= mot_val[3+stride]= my;
3537 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3539 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3540 mx = h263_decode_motion(s, pred_x, s->f_code);
3544 my = h263_decode_motion(s, pred_y, s->f_code);
3561 * decode second partition.
3562 * @return <0 if an error occured
3564 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3566 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3568 s->mb_x= s->resync_mb_x;
3569 s->first_slice_line=1;
3570 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3571 ff_init_block_index(s);
3572 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3573 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3576 ff_update_block_index(s);
3577 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3578 s->first_slice_line=0;
3580 if(s->pict_type==I_TYPE){
3581 int ac_pred= get_bits1(&s->gb);
3582 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3584 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3588 s->cbp_table[xy]|= cbpy<<2;
3589 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3590 }else{ /* P || S_TYPE */
3591 if(IS_INTRA(s->current_picture.mb_type[xy])){
3593 int ac_pred = get_bits1(&s->gb);
3594 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3597 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3601 if(s->cbp_table[xy] & 8) {
3602 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3604 s->current_picture.qscale_table[xy]= s->qscale;
3608 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3610 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3614 if(dc_pred_dir) dir|=1;
3616 s->cbp_table[xy]&= 3; //remove dquant
3617 s->cbp_table[xy]|= cbpy<<2;
3618 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3619 s->pred_dir_table[xy]= dir;
3620 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3621 s->current_picture.qscale_table[xy]= s->qscale;
3622 s->cbp_table[xy]= 0;
3624 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3627 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3631 if(s->cbp_table[xy] & 8) {
3632 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3634 s->current_picture.qscale_table[xy]= s->qscale;
3636 s->cbp_table[xy]&= 3; //remove dquant
3637 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3641 if(mb_num >= mb_count) return 0;
3648 * decodes the first & second partition
3649 * @return <0 if error (and sets error type in the error_status_table)
3651 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3654 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3655 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3657 mb_num= mpeg4_decode_partition_a(s);
3659 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3663 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3664 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3665 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3669 s->mb_num_left= mb_num;
3671 if(s->pict_type==I_TYPE){
3672 while(show_bits(&s->gb, 9) == 1)
3673 skip_bits(&s->gb, 9);
3674 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3675 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3679 while(show_bits(&s->gb, 10) == 1)
3680 skip_bits(&s->gb, 10);
3681 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3682 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3686 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3688 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3689 if(s->pict_type==P_TYPE)
3690 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3693 if(s->pict_type==P_TYPE)
3694 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3701 * decode partition C of one MB.
3702 * @return <0 if an error occured
3704 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3707 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3709 mb_type= s->current_picture.mb_type[xy];
3710 cbp = s->cbp_table[xy];
3712 if(s->current_picture.qscale_table[xy] != s->qscale){
3713 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3716 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3719 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3720 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3722 s->mb_intra = IS_INTRA(mb_type);
3724 if (IS_SKIP(mb_type)) {
3727 s->block_last_index[i] = -1;
3728 s->mv_dir = MV_DIR_FORWARD;
3729 s->mv_type = MV_TYPE_16X16;
3730 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3737 }else if(s->mb_intra){
3738 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3739 }else if(!s->mb_intra){
3740 // s->mcsel= 0; //FIXME do we need to init that
3742 s->mv_dir = MV_DIR_FORWARD;
3743 if (IS_8X8(mb_type)) {
3744 s->mv_type = MV_TYPE_8X8;
3746 s->mv_type = MV_TYPE_16X16;
3749 } else { /* I-Frame */
3751 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3754 if (!IS_SKIP(mb_type)) {
3756 s->dsp.clear_blocks(s->block[0]);
3757 /* decode each block */
3758 for (i = 0; i < 6; i++) {
3759 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3760 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3767 /* per-MB end of slice check */
3769 if(--s->mb_num_left <= 0){
3770 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3771 if(mpeg4_is_resync(s))
3776 if(mpeg4_is_resync(s)){
3777 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3778 if(s->cbp_table[xy+delta])
3786 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3788 static void preview_obmc(MpegEncContext *s){
3789 GetBitContext gb= s->gb;
3791 int cbpc, i, pred_x, pred_y, mx, my;
3793 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3794 const int stride= s->b8_stride*2;
3797 s->block_index[i]+= 2;
3799 s->block_index[i]+= 1;
3802 assert(s->pict_type == P_TYPE);
3805 if (get_bits1(&s->gb)) {
3807 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3808 mot_val[0 ]= mot_val[2 ]=
3809 mot_val[0+stride]= mot_val[2+stride]= 0;
3810 mot_val[1 ]= mot_val[3 ]=
3811 mot_val[1+stride]= mot_val[3+stride]= 0;
3813 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3816 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3820 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3822 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3824 if(s->modified_quant){
3825 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3826 else skip_bits(&s->gb, 5);
3828 skip_bits(&s->gb, 2);
3831 if ((cbpc & 16) == 0) {
3832 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3833 /* 16x16 motion prediction */
3834 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3836 mx = h263p_decode_umotion(s, pred_x);
3838 mx = h263_decode_motion(s, pred_x, 1);
3841 my = h263p_decode_umotion(s, pred_y);
3843 my = h263_decode_motion(s, pred_y, 1);
3845 mot_val[0 ]= mot_val[2 ]=
3846 mot_val[0+stride]= mot_val[2+stride]= mx;
3847 mot_val[1 ]= mot_val[3 ]=
3848 mot_val[1+stride]= mot_val[3+stride]= my;
3850 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3852 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3854 mx = h263p_decode_umotion(s, pred_x);
3856 mx = h263_decode_motion(s, pred_x, 1);
3859 my = h263p_decode_umotion(s, pred_y);
3861 my = h263_decode_motion(s, pred_y, 1);
3862 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3863 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3872 s->block_index[i]-= 2;
3874 s->block_index[i]-= 1;
3880 static void h263_decode_dquant(MpegEncContext *s){
3881 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3883 if(s->modified_quant){
3884 if(get_bits1(&s->gb))
3885 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3887 s->qscale= get_bits(&s->gb, 5);
3889 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3890 ff_set_qscale(s, s->qscale);
3893 int ff_h263_decode_mb(MpegEncContext *s,
3894 DCTELEM block[6][64])
3896 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3898 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3900 assert(!s->h263_pred);
3902 if (s->pict_type == P_TYPE) {
3904 if (get_bits1(&s->gb)) {
3908 s->block_last_index[i] = -1;
3909 s->mv_dir = MV_DIR_FORWARD;
3910 s->mv_type = MV_TYPE_16X16;
3911 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3914 s->mb_skipped = !(s->obmc | s->loop_filter);
3917 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3918 //fprintf(stderr, "\tCBPC: %d", cbpc);
3920 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3925 s->dsp.clear_blocks(s->block[0]);
3928 s->mb_intra = ((cbpc & 4) != 0);
3929 if (s->mb_intra) goto intra;
3931 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3933 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3936 cbp = (cbpc & 3) | (cbpy << 2);
3938 h263_decode_dquant(s);
3941 s->mv_dir = MV_DIR_FORWARD;
3942 if ((cbpc & 16) == 0) {
3943 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3944 /* 16x16 motion prediction */
3945 s->mv_type = MV_TYPE_16X16;
3946 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3948 mx = h263p_decode_umotion(s, pred_x);
3950 mx = h263_decode_motion(s, pred_x, 1);
3956 my = h263p_decode_umotion(s, pred_y);
3958 my = h263_decode_motion(s, pred_y, 1);
3962 s->mv[0][0][0] = mx;
3963 s->mv[0][0][1] = my;
3965 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3966 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3968 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3969 s->mv_type = MV_TYPE_8X8;
3971 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3973 mx = h263p_decode_umotion(s, pred_x);
3975 mx = h263_decode_motion(s, pred_x, 1);
3980 my = h263p_decode_umotion(s, pred_y);
3982 my = h263_decode_motion(s, pred_y, 1);
3985 s->mv[0][i][0] = mx;
3986 s->mv[0][i][1] = my;
3987 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3988 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3994 /* decode each block */
3995 for (i = 0; i < 6; i++) {
3996 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4002 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4005 } else if(s->pict_type==B_TYPE) {
4007 const int stride= s->b8_stride;
4008 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4009 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4010 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4013 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4014 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4015 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4016 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4019 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4021 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4025 mb_type= h263_mb_type_b_map[ mb_type ];
4028 s->mb_intra = IS_INTRA(mb_type);
4029 if(HAS_CBP(mb_type)){
4030 s->dsp.clear_blocks(s->block[0]);
4031 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4033 dquant = IS_QUANT(mb_type);
4037 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4040 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4044 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4047 cbp = (cbpc & 3) | (cbpy << 2);
4051 assert(!s->mb_intra);
4053 if(IS_QUANT(mb_type)){
4054 h263_decode_dquant(s);
4057 if(IS_DIRECT(mb_type)){
4058 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4059 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4062 s->mv_type= MV_TYPE_16X16;
4065 if(USES_LIST(mb_type, 0)){
4066 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4067 s->mv_dir = MV_DIR_FORWARD;
4069 mx = h263_decode_motion(s, mx, 1);
4070 my = h263_decode_motion(s, my, 1);
4072 s->mv[0][0][0] = mx;
4073 s->mv[0][0][1] = my;
4074 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4075 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4078 if(USES_LIST(mb_type, 1)){
4079 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4080 s->mv_dir |= MV_DIR_BACKWARD;
4082 mx = h263_decode_motion(s, mx, 1);
4083 my = h263_decode_motion(s, my, 1);
4085 s->mv[1][0][0] = mx;
4086 s->mv[1][0][1] = my;
4087 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4088 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4092 s->current_picture.mb_type[xy]= mb_type;
4094 /* decode each block */
4095 for (i = 0; i < 6; i++) {
4096 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4100 } else { /* I-Frame */
4102 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4104 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4109 s->dsp.clear_blocks(s->block[0]);
4114 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4116 s->ac_pred = get_bits1(&s->gb);
4118 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4120 s->h263_aic_dir = get_bits1(&s->gb);
4125 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4127 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4130 cbp = (cbpc & 3) | (cbpy << 2);
4132 h263_decode_dquant(s);
4135 /* decode each block */
4136 for (i = 0; i < 6; i++) {
4137 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4144 /* per-MB end of slice check */
4146 int v= show_bits(&s->gb, 16);
4148 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4149 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4159 int ff_mpeg4_decode_mb(MpegEncContext *s,
4160 DCTELEM block[6][64])
4162 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4164 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4165 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4167 assert(s->h263_pred);
4169 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4171 if (get_bits1(&s->gb)) {
4175 s->block_last_index[i] = -1;
4176 s->mv_dir = MV_DIR_FORWARD;
4177 s->mv_type = MV_TYPE_16X16;
4178 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4179 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4181 s->mv[0][0][0]= get_amv(s, 0);
4182 s->mv[0][0][1]= get_amv(s, 1);
4186 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4194 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4195 //fprintf(stderr, "\tCBPC: %d", cbpc);
4197 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4202 s->dsp.clear_blocks(s->block[0]);
4204 s->mb_intra = ((cbpc & 4) != 0);
4205 if (s->mb_intra) goto intra;
4207 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4208 s->mcsel= get_bits1(&s->gb);
4210 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4212 cbp = (cbpc & 3) | (cbpy << 2);
4214 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4216 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4217 s->interlaced_dct= get_bits1(&s->gb);
4219 s->mv_dir = MV_DIR_FORWARD;
4220 if ((cbpc & 16) == 0) {
4222 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4223 /* 16x16 global motion prediction */
4224 s->mv_type = MV_TYPE_16X16;
4227 s->mv[0][0][0] = mx;
4228 s->mv[0][0][1] = my;
4229 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4230 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4231 /* 16x8 field motion prediction */
4232 s->mv_type= MV_TYPE_FIELD;
4234 s->field_select[0][0]= get_bits1(&s->gb);
4235 s->field_select[0][1]= get_bits1(&s->gb);
4237 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4240 mx = h263_decode_motion(s, pred_x, s->f_code);
4244 my = h263_decode_motion(s, pred_y/2, s->f_code);
4248 s->mv[0][i][0] = mx;
4249 s->mv[0][i][1] = my;
4252 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4253 /* 16x16 motion prediction */
4254 s->mv_type = MV_TYPE_16X16;
4255 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4256 mx = h263_decode_motion(s, pred_x, s->f_code);
4261 my = h263_decode_motion(s, pred_y, s->f_code);
4265 s->mv[0][0][0] = mx;
4266 s->mv[0][0][1] = my;
4269 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4270 s->mv_type = MV_TYPE_8X8;
4272 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4273 mx = h263_decode_motion(s, pred_x, s->f_code);
4277 my = h263_decode_motion(s, pred_y, s->f_code);
4280 s->mv[0][i][0] = mx;
4281 s->mv[0][i][1] = my;
4286 } else if(s->pict_type==B_TYPE) {
4287 int modb1; // first bit of modb
4288 int modb2; // second bit of modb
4291 s->mb_intra = 0; //B-frames never contain intra blocks
4292 s->mcsel=0; // ... true gmc blocks
4296 s->last_mv[i][0][0]=
4297 s->last_mv[i][0][1]=
4298 s->last_mv[i][1][0]=
4299 s->last_mv[i][1][1]= 0;
4303 /* if we skipped it in the future P Frame than skip it now too */
4304 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4309 s->block_last_index[i] = -1;
4311 s->mv_dir = MV_DIR_FORWARD;
4312 s->mv_type = MV_TYPE_16X16;
4317 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4321 modb1= get_bits1(&s->gb);
4323 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4326 modb2= get_bits1(&s->gb);
4327 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4329 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4332 mb_type= mb_type_b_map[ mb_type ];
4335 s->dsp.clear_blocks(s->block[0]);
4336 cbp= get_bits(&s->gb, 6);
4339 if ((!IS_DIRECT(mb_type)) && cbp) {
4340 if(get_bits1(&s->gb)){
4341 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4345 if(!s->progressive_sequence){
4347 s->interlaced_dct= get_bits1(&s->gb);
4349 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4350 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4351 mb_type &= ~MB_TYPE_16x16;
4353 if(USES_LIST(mb_type, 0)){
4354 s->field_select[0][0]= get_bits1(&s->gb);
4355 s->field_select[0][1]= get_bits1(&s->gb);
4357 if(USES_LIST(mb_type, 1)){
4358 s->field_select[1][0]= get_bits1(&s->gb);
4359 s->field_select[1][1]= get_bits1(&s->gb);
4365 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4366 s->mv_type= MV_TYPE_16X16;
4368 if(USES_LIST(mb_type, 0)){
4369 s->mv_dir = MV_DIR_FORWARD;
4371 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4372 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4373 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4374 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4377 if(USES_LIST(mb_type, 1)){
4378 s->mv_dir |= MV_DIR_BACKWARD;
4380 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4381 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4382 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4383 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4385 }else if(!IS_DIRECT(mb_type)){
4386 s->mv_type= MV_TYPE_FIELD;
4388 if(USES_LIST(mb_type, 0)){
4389 s->mv_dir = MV_DIR_FORWARD;
4392 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4393 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4394 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4395 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4399 if(USES_LIST(mb_type, 1)){
4400 s->mv_dir |= MV_DIR_BACKWARD;
4403 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4404 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4405 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4406 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4412 if(IS_DIRECT(mb_type)){
4413 if(IS_SKIP(mb_type))
4416 mx = h263_decode_motion(s, 0, 1);
4417 my = h263_decode_motion(s, 0, 1);
4420 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4421 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4423 s->current_picture.mb_type[xy]= mb_type;
4424 } else { /* I-Frame */
4426 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4428 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4436 s->ac_pred = get_bits1(&s->gb);
4438 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4440 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4442 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4444 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4447 cbp = (cbpc & 3) | (cbpy << 2);
4449 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4452 if(!s->progressive_sequence)
4453 s->interlaced_dct= get_bits1(&s->gb);
4455 s->dsp.clear_blocks(s->block[0]);
4456 /* decode each block */
4457 for (i = 0; i < 6; i++) {
4458 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4465 /* decode each block */
4466 for (i = 0; i < 6; i++) {
4467 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4473 /* per-MB end of slice check */
4474 if(s->codec_id==CODEC_ID_MPEG4){
4475 if(mpeg4_is_resync(s)){
4476 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4477 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4486 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4488 int code, val, sign, shift, l;
4489 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4496 sign = get_bits1(&s->gb);
4500 val = (val - 1) << shift;
4501 val |= get_bits(&s->gb, shift);
4508 /* modulo decoding */
4509 if (!s->h263_long_vectors) {
4510 l = INT_BIT - 5 - f_code;
4513 /* horrible h263 long vector mode */
4514 if (pred < -31 && val < -63)
4516 if (pred > 32 && val > 63)
4523 /* Decodes RVLC of H.263+ UMV */
4524 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4528 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4531 code = 2 + get_bits1(&s->gb);
4533 while (get_bits1(&s->gb))
4536 code += get_bits1(&s->gb);
4541 code = (sign) ? (pred - code) : (pred + code);
4543 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4549 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4552 int code, level, i, j, last, run;
4553 RLTable *rl = &rl_inter;
4554 const uint8_t *scan_table;
4555 GetBitContext gb= s->gb;
4557 scan_table = s->intra_scantable.permutated;
4558 if (s->h263_aic && s->mb_intra) {
4562 if (s->h263_aic_dir)
4563 scan_table = s->intra_v_scantable.permutated; /* left */
4565 scan_table = s->intra_h_scantable.permutated; /* top */
4567 } else if (s->mb_intra) {
4569 if(s->codec_id == CODEC_ID_RV10){
4570 #ifdef CONFIG_RV10_DECODER
4571 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4572 int component, diff;
4573 component = (n <= 3 ? 0 : n - 4 + 1);
4574 level = s->last_dc[component];
4575 if (s->rv10_first_dc_coded[component]) {
4576 diff = rv_decode_dc(s, n);
4580 level = level & 0xff; /* handle wrap round */
4581 s->last_dc[component] = level;
4583 s->rv10_first_dc_coded[component] = 1;
4586 level = get_bits(&s->gb, 8);
4592 level = get_bits(&s->gb, 8);
4593 if((level&0x7F) == 0){
4594 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4595 if(s->error_resilience >= FF_ER_COMPLIANT)
4607 if (s->mb_intra && s->h263_aic)
4609 s->block_last_index[n] = i - 1;
4614 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4616 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4619 if (code == rl->n) {
4621 if (s->h263_flv > 1) {
4622 int is11 = get_bits1(&s->gb);
4623 last = get_bits1(&s->gb);
4624 run = get_bits(&s->gb, 6);
4626 level = get_sbits(&s->gb, 11);
4628 level = get_sbits(&s->gb, 7);
4631 last = get_bits1(&s->gb);
4632 run = get_bits(&s->gb, 6);
4633 level = (int8_t)get_bits(&s->gb, 8);
4635 if (s->codec_id == CODEC_ID_RV10) {
4636 /* XXX: should patch encoder too */
4637 level = get_sbits(&s->gb, 12);
4639 level = get_bits(&s->gb, 5);
4640 level |= get_sbits(&s->gb, 6)<<5;
4645 run = rl->table_run[code];
4646 level = rl->table_level[code];
4647 last = code >= rl->last;
4648 if (get_bits1(&s->gb))
4653 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4654 //looks like a hack but no, it's the way its supposed to work ...
4658 memset(block, 0, sizeof(DCTELEM)*64);
4661 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4671 if (s->mb_intra && s->h263_aic) {
4672 h263_pred_acdc(s, block, n);
4675 s->block_last_index[n] = i;
4680 * decodes the dc value.
4681 * @param n block index (0-3 are luma, 4-5 are chroma)
4682 * @param dir_ptr the prediction direction will be stored here
4683 * @return the quantized dc
4685 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4690 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4692 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4693 if (code < 0 || code > 9 /* && s->nbit<9 */){
4694 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4702 level= 2*get_bits1(&s->gb)-1;
4704 if(get_bits1(&s->gb))
4705 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4707 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4710 level = get_xbits(&s->gb, code);
4714 if(get_bits1(&s->gb)==0){ /* marker */
4715 if(s->error_resilience>=2){
4716 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4723 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4728 * @return <0 if an error occured
4730 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4731 int n, int coded, int intra, int rvlc)
4733 int level, i, last, run;
4736 RL_VLC_ELEM * rl_vlc;
4737 const uint8_t * scan_table;
4740 //Note intra & rvlc should be optimized away if this is inlined
4743 if(s->qscale < s->intra_dc_threshold){
4745 if(s->partitioned_frame){
4746 level = s->dc_val[0][ s->block_index[n] ];
4747 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4748 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4749 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4751 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4759 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4765 rl = &rvlc_rl_intra;
4766 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4769 rl_vlc = rl_intra.rl_vlc[0];
4772 if (dc_pred_dir == 0)
4773 scan_table = s->intra_v_scantable.permutated; /* left */
4775 scan_table = s->intra_h_scantable.permutated; /* top */
4777 scan_table = s->intra_scantable.permutated;
4784 s->block_last_index[n] = i;
4787 if(rvlc) rl = &rvlc_rl_inter;
4788 else rl = &rl_inter;
4790 scan_table = s->intra_scantable.permutated;
4796 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4798 rl_vlc = rl_inter.rl_vlc[0];
4801 qmul = s->qscale << 1;
4802 qadd = (s->qscale - 1) | 1;
4804 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4806 rl_vlc = rl_inter.rl_vlc[s->qscale];
4811 OPEN_READER(re, &s->gb);
4813 UPDATE_CACHE(re, &s->gb);
4814 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4818 if(SHOW_UBITS(re, &s->gb, 1)==0){
4819 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4821 }; SKIP_CACHE(re, &s->gb, 1);
4823 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4824 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4825 SKIP_COUNTER(re, &s->gb, 1+1+6);
4826 UPDATE_CACHE(re, &s->gb);
4828 if(SHOW_UBITS(re, &s->gb, 1)==0){
4829 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4831 }; SKIP_CACHE(re, &s->gb, 1);
4833 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4835 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4836 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4838 }; SKIP_CACHE(re, &s->gb, 5);
4840 level= level * qmul + qadd;
4841 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4842 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4848 cache= GET_CACHE(re, &s->gb);
4851 cache ^= 0xC0000000;
4853 if (cache&0x80000000) {
4854 if (cache&0x40000000) {
4856 SKIP_CACHE(re, &s->gb, 2);
4857 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4858 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4859 SKIP_COUNTER(re, &s->gb, 2+1+6);
4860 UPDATE_CACHE(re, &s->gb);
4863 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4865 if(SHOW_UBITS(re, &s->gb, 1)==0){
4866 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4868 }; SKIP_CACHE(re, &s->gb, 1);
4870 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4872 if(SHOW_UBITS(re, &s->gb, 1)==0){
4873 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4875 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4877 SKIP_COUNTER(re, &s->gb, 1+12+1);
4881 if(s->error_resilience >= FF_ER_COMPLIANT){
4882 const int abs_level= ABS(level);
4883 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4884 const int run1= run - rl->max_run[last][abs_level] - 1;
4885 if(abs_level <= rl->max_level[last][run]){
4886 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4889 if(s->error_resilience > FF_ER_COMPLIANT){
4890 if(abs_level <= rl->max_level[last][run]*2){
4891 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4894 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4895 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4902 if (level>0) level= level * qmul + qadd;
4903 else level= level * qmul - qadd;
4905 if((unsigned)(level + 2048) > 4095){
4906 if(s->error_resilience > FF_ER_COMPLIANT){
4907 if(level > 2560 || level<-2560){
4908 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4912 level= level<0 ? -2048 : 2047;
4919 #if MIN_CACHE_BITS < 20
4920 LAST_SKIP_BITS(re, &s->gb, 2);
4921 UPDATE_CACHE(re, &s->gb);
4923 SKIP_BITS(re, &s->gb, 2);
4925 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4926 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4927 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4928 LAST_SKIP_BITS(re, &s->gb, 1);
4932 #if MIN_CACHE_BITS < 19
4933 LAST_SKIP_BITS(re, &s->gb, 1);
4934 UPDATE_CACHE(re, &s->gb);
4936 SKIP_BITS(re, &s->gb, 1);
4938 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4940 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4941 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4942 LAST_SKIP_BITS(re, &s->gb, 1);
4947 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4948 LAST_SKIP_BITS(re, &s->gb, 1);
4953 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4957 block[scan_table[i]] = level;
4961 block[scan_table[i]] = level;
4963 CLOSE_READER(re, &s->gb);
4967 if(s->qscale >= s->intra_dc_threshold){
4968 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
4970 i -= i>>31; //if(i == -1) i=0;
4973 mpeg4_pred_ac(s, block, n, dc_pred_dir);
4975 i = 63; /* XXX: not optimal */
4978 s->block_last_index[n] = i;
4982 /* most is hardcoded. should extend to handle all h263 streams */
4983 int h263_decode_picture_header(MpegEncContext *s)
4985 int format, width, height, i;
4988 align_get_bits(&s->gb);
4990 startcode= get_bits(&s->gb, 22-8);
4992 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4993 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4995 if(startcode == 0x20)
4999 if (startcode != 0x20) {
5000 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5003 /* temporal reference */
5004 i = get_bits(&s->gb, 8); /* picture timestamp */
5005 if( (s->picture_number&~0xFF)+i < s->picture_number)
5007 s->current_picture_ptr->pts=
5008 s->picture_number= (s->picture_number&~0xFF) + i;
5010 /* PTYPE starts here */
5011 if (get_bits1(&s->gb) != 1) {
5013 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5016 if (get_bits1(&s->gb) != 0) {
5017 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5018 return -1; /* h263 id */
5020 skip_bits1(&s->gb); /* split screen off */
5021 skip_bits1(&s->gb); /* camera off */
5022 skip_bits1(&s->gb); /* freeze picture release off */
5024 format = get_bits(&s->gb, 3);
5029 7 extended PTYPE (PLUSPTYPE)
5032 if (format != 7 && format != 6) {
5035 width = h263_format[format][0];
5036 height = h263_format[format][1];
5040 s->pict_type = I_TYPE + get_bits1(&s->gb);
5042 s->h263_long_vectors = get_bits1(&s->gb);
5044 if (get_bits1(&s->gb) != 0) {
5045 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5046 return -1; /* SAC: off */
5048 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5049 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5051 if (get_bits1(&s->gb) != 0) {
5052 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5053 return -1; /* not PB frame */
5055 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5056 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5060 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5061 s->avctx->time_base= (AVRational){1001, 30000};
5067 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5069 /* ufep other than 0 and 1 are reserved */
5072 format = get_bits(&s->gb, 3);
5073 dprintf("ufep=1, format: %d\n", format);
5074 s->custom_pcf= get_bits1(&s->gb);
5075 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5076 if (get_bits1(&s->gb) != 0) {
5077 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5079 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5080 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5081 s->loop_filter= get_bits1(&s->gb);
5082 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5084 s->h263_slice_structured= get_bits1(&s->gb);
5085 if (get_bits1(&s->gb) != 0) {
5086 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5088 if (get_bits1(&s->gb) != 0) {
5089 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5091 s->alt_inter_vlc= get_bits1(&s->gb);
5092 s->modified_quant= get_bits1(&s->gb);
5093 if(s->modified_quant)
5094 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5096 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5098 skip_bits(&s->gb, 3); /* Reserved */
5099 } else if (ufep != 0) {
5100 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5105 s->pict_type = get_bits(&s->gb, 3);
5106 switch(s->pict_type){
5107 case 0: s->pict_type= I_TYPE;break;
5108 case 1: s->pict_type= P_TYPE;break;
5109 case 3: s->pict_type= B_TYPE;break;
5110 case 7: s->pict_type= I_TYPE;break; //ZYGO
5114 skip_bits(&s->gb, 2);
5115 s->no_rounding = get_bits1(&s->gb);
5116 skip_bits(&s->gb, 4);
5118 /* Get the picture dimensions */
5121 /* Custom Picture Format (CPFMT) */
5122 s->aspect_ratio_info = get_bits(&s->gb, 4);
5123 dprintf("aspect: %d\n", s->aspect_ratio_info);
5128 3 - 10:11 (525-type 4:3)
5129 4 - 16:11 (CIF 16:9)
5130 5 - 40:33 (525-type 16:9)
5133 width = (get_bits(&s->gb, 9) + 1) * 4;
5135 height = get_bits(&s->gb, 9) * 4;
5136 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5137 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5138 /* aspected dimensions */
5139 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5140 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5142 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5145 width = h263_format[format][0];
5146 height = h263_format[format][1];
5147 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5149 if ((width == 0) || (height == 0))
5156 s->avctx->time_base.den= 1800000;
5157 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5158 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5159 if(s->avctx->time_base.num == 0){
5160 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5163 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5164 s->avctx->time_base.den /= gcd;
5165 s->avctx->time_base.num /= gcd;
5166 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5168 s->avctx->time_base= (AVRational){1001, 30000};
5173 skip_bits(&s->gb, 2); //extended Temporal reference
5178 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5181 if(s->h263_slice_structured){
5182 if (get_bits1(&s->gb) != 0) {
5183 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5185 if (get_bits1(&s->gb) != 0) {
5186 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5191 s->qscale = get_bits(&s->gb, 5);
5194 s->mb_width = (s->width + 15) / 16;
5195 s->mb_height = (s->height + 15) / 16;
5196 s->mb_num = s->mb_width * s->mb_height;
5199 while (get_bits1(&s->gb) != 0) {
5200 skip_bits(&s->gb, 8);
5203 if(s->h263_slice_structured){
5204 if (get_bits1(&s->gb) != 1) {
5205 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5209 ff_h263_decode_mba(s);
5211 if (get_bits1(&s->gb) != 1) {
5212 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5219 s->y_dc_scale_table=
5220 s->c_dc_scale_table= ff_aic_dc_scale_table;
5222 s->y_dc_scale_table=
5223 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5226 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5227 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",
5228 s->qscale, av_get_pict_type_char(s->pict_type),
5229 s->gb.size_in_bits, 1-s->no_rounding,
5230 s->obmc ? " AP" : "",
5231 s->umvplus ? " UMV" : "",
5232 s->h263_long_vectors ? " LONG" : "",
5233 s->h263_plus ? " +" : "",
5234 s->h263_aic ? " AIC" : "",
5235 s->alt_inter_vlc ? " AIV" : "",
5236 s->modified_quant ? " MQ" : "",
5237 s->loop_filter ? " LOOP" : "",
5238 s->h263_slice_structured ? " SS" : "",
5239 s->avctx->time_base.den, s->avctx->time_base.num
5243 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5245 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5246 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5247 for(i=0; i<13; i++){
5249 int v= get_bits(&s->gb, 8);
5250 v |= get_sbits(&s->gb, 8)<<8;
5251 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5253 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5255 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5262 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5265 int a= 2<<s->sprite_warping_accuracy;
5266 int rho= 3-s->sprite_warping_accuracy;
5268 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5269 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5270 int sprite_ref[4][2];
5271 int virtual_ref[2][2];
5273 int alpha=0, beta=0;
5278 for(i=0; i<s->num_sprite_warping_points; i++){
5282 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5284 x= get_xbits(gb, length);
5286 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5288 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5290 y=get_xbits(gb, length);
5292 skip_bits1(gb); /* marker bit */
5293 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5298 while((1<<alpha)<w) alpha++;
5299 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5303 // Note, the 4th point isn't used for GMC
5304 if(s->divx_version==500 && s->divx_build==413){
5305 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5306 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5307 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5308 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5309 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5310 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5312 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5313 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5314 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5315 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5316 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5317 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5319 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5320 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5322 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5323 // perhaps it should be reordered to be more readable ...
5324 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5325 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5326 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5327 + 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);
5328 virtual_ref[0][1]= 16*vop_ref[0][1]
5329 + 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);
5330 virtual_ref[1][0]= 16*vop_ref[0][0]
5331 + 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);
5332 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5333 + 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);
5335 switch(s->num_sprite_warping_points)
5338 s->sprite_offset[0][0]= 0;
5339 s->sprite_offset[0][1]= 0;
5340 s->sprite_offset[1][0]= 0;
5341 s->sprite_offset[1][1]= 0;
5342 s->sprite_delta[0][0]= a;
5343 s->sprite_delta[0][1]= 0;
5344 s->sprite_delta[1][0]= 0;
5345 s->sprite_delta[1][1]= a;
5346 s->sprite_shift[0]= 0;
5347 s->sprite_shift[1]= 0;
5350 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5351 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5352 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5353 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5354 s->sprite_delta[0][0]= a;
5355 s->sprite_delta[0][1]= 0;
5356 s->sprite_delta[1][0]= 0;
5357 s->sprite_delta[1][1]= a;
5358 s->sprite_shift[0]= 0;
5359 s->sprite_shift[1]= 0;
5362 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5363 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5364 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5365 + (1<<(alpha+rho-1));
5366 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5367 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5368 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5369 + (1<<(alpha+rho-1));
5370 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5371 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5372 +2*w2*r*sprite_ref[0][0]
5374 + (1<<(alpha+rho+1)));
5375 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5376 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5377 +2*w2*r*sprite_ref[0][1]
5379 + (1<<(alpha+rho+1)));
5380 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5381 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5382 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5383 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5385 s->sprite_shift[0]= alpha+rho;
5386 s->sprite_shift[1]= alpha+rho+2;
5389 min_ab= FFMIN(alpha, beta);
5392 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5393 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5394 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5395 + (1<<(alpha+beta+rho-min_ab-1));
5396 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5397 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5398 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5399 + (1<<(alpha+beta+rho-min_ab-1));
5400 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5401 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5402 + 2*w2*h3*r*sprite_ref[0][0]
5404 + (1<<(alpha+beta+rho-min_ab+1));
5405 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5406 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5407 + 2*w2*h3*r*sprite_ref[0][1]
5409 + (1<<(alpha+beta+rho-min_ab+1));
5410 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5411 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5412 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5413 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5415 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5416 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5419 /* try to simplify the situation */
5420 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5421 && s->sprite_delta[0][1] == 0
5422 && s->sprite_delta[1][0] == 0
5423 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5425 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5426 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5427 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5428 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5429 s->sprite_delta[0][0]= a;
5430 s->sprite_delta[0][1]= 0;
5431 s->sprite_delta[1][0]= 0;
5432 s->sprite_delta[1][1]= a;
5433 s->sprite_shift[0]= 0;
5434 s->sprite_shift[1]= 0;
5435 s->real_sprite_warping_points=1;
5438 int shift_y= 16 - s->sprite_shift[0];
5439 int shift_c= 16 - s->sprite_shift[1];
5440 //printf("shifts %d %d\n", shift_y, shift_c);
5442 s->sprite_offset[0][i]<<= shift_y;
5443 s->sprite_offset[1][i]<<= shift_c;
5444 s->sprite_delta[0][i]<<= shift_y;
5445 s->sprite_delta[1][i]<<= shift_y;
5446 s->sprite_shift[i]= 16;
5448 s->real_sprite_warping_points= s->num_sprite_warping_points;
5451 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5452 vop_ref[0][0], vop_ref[0][1],
5453 vop_ref[1][0], vop_ref[1][1],
5454 vop_ref[2][0], vop_ref[2][1],
5455 sprite_ref[0][0], sprite_ref[0][1],
5456 sprite_ref[1][0], sprite_ref[1][1],
5457 sprite_ref[2][0], sprite_ref[2][1],
5458 virtual_ref[0][0], virtual_ref[0][1],
5459 virtual_ref[1][0], virtual_ref[1][1]
5462 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5463 s->sprite_offset[0][0], s->sprite_offset[0][1],
5464 s->sprite_delta[0][0], s->sprite_delta[0][1],
5465 s->sprite_delta[1][0], s->sprite_delta[1][1],
5471 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5472 int hours, minutes, seconds;
5474 hours= get_bits(gb, 5);
5475 minutes= get_bits(gb, 6);
5477 seconds= get_bits(gb, 6);
5479 s->time_base= seconds + 60*(minutes + 60*hours);
5487 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5488 int width, height, vo_ver_id;
5491 skip_bits(gb, 1); /* random access */
5492 s->vo_type= get_bits(gb, 8);
5493 if (get_bits1(gb) != 0) { /* is_ol_id */
5494 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5495 skip_bits(gb, 3); /* vo_priority */
5499 //printf("vo type:%d\n",s->vo_type);
5500 s->aspect_ratio_info= get_bits(gb, 4);
5501 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5502 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5503 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5505 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5508 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5509 int chroma_format= get_bits(gb, 2);
5510 if(chroma_format!=1){
5511 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5513 s->low_delay= get_bits1(gb);
5514 if(get_bits1(gb)){ /* vbv parameters */
5515 get_bits(gb, 15); /* first_half_bitrate */
5516 skip_bits1(gb); /* marker */
5517 get_bits(gb, 15); /* latter_half_bitrate */
5518 skip_bits1(gb); /* marker */
5519 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5520 skip_bits1(gb); /* marker */
5521 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5522 get_bits(gb, 11); /* first_half_vbv_occupancy */
5523 skip_bits1(gb); /* marker */
5524 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5525 skip_bits1(gb); /* marker */
5528 // set low delay flag only once the smartest? low delay detection won't be overriden
5529 if(s->picture_number==0)
5533 s->shape = get_bits(gb, 2); /* vol shape */
5534 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5535 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5536 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5537 skip_bits(gb, 4); //video_object_layer_shape_extension
5540 check_marker(gb, "before time_increment_resolution");
5542 s->avctx->time_base.den = get_bits(gb, 16);
5543 if(!s->avctx->time_base.den){
5544 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5548 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5549 if (s->time_increment_bits < 1)
5550 s->time_increment_bits = 1;
5552 check_marker(gb, "before fixed_vop_rate");
5554 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5555 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5557 s->avctx->time_base.num = 1;
5561 if (s->shape != BIN_ONLY_SHAPE) {
5562 if (s->shape == RECT_SHAPE) {
5563 skip_bits1(gb); /* marker */
5564 width = get_bits(gb, 13);
5565 skip_bits1(gb); /* marker */
5566 height = get_bits(gb, 13);
5567 skip_bits1(gb); /* marker */
5568 if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5571 // printf("width/height: %d %d\n", width, height);
5575 s->progressive_sequence=
5576 s->progressive_frame= get_bits1(gb)^1;
5577 s->interlaced_dct=0;
5578 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5579 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5580 if (vo_ver_id == 1) {
5581 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5583 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5585 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5586 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5587 if(s->vol_sprite_usage==STATIC_SPRITE){
5588 s->sprite_width = get_bits(gb, 13);
5589 skip_bits1(gb); /* marker */
5590 s->sprite_height= get_bits(gb, 13);
5591 skip_bits1(gb); /* marker */
5592 s->sprite_left = get_bits(gb, 13);
5593 skip_bits1(gb); /* marker */
5594 s->sprite_top = get_bits(gb, 13);
5595 skip_bits1(gb); /* marker */
5597 s->num_sprite_warping_points= get_bits(gb, 6);
5598 s->sprite_warping_accuracy = get_bits(gb, 2);
5599 s->sprite_brightness_change= get_bits1(gb);
5600 if(s->vol_sprite_usage==STATIC_SPRITE)
5601 s->low_latency_sprite= get_bits1(gb);
5603 // FIXME sadct disable bit if verid!=1 && shape not rect
5605 if (get_bits1(gb) == 1) { /* not_8_bit */
5606 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5607 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5608 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5610 s->quant_precision = 5;
5613 // FIXME a bunch of grayscale shape things
5615 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5618 /* load default matrixes */
5619 for(i=0; i<64; i++){
5620 int j= s->dsp.idct_permutation[i];
5621 v= ff_mpeg4_default_intra_matrix[i];
5622 s->intra_matrix[j]= v;
5623 s->chroma_intra_matrix[j]= v;
5625 v= ff_mpeg4_default_non_intra_matrix[i];
5626 s->inter_matrix[j]= v;
5627 s->chroma_inter_matrix[j]= v;
5630 /* load custom intra matrix */
5633 for(i=0; i<64; i++){
5639 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5640 s->intra_matrix[j]= v;
5641 s->chroma_intra_matrix[j]= v;
5644 /* replicate last value */
5646 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5647 s->intra_matrix[j]= last;
5648 s->chroma_intra_matrix[j]= last;
5652 /* load custom non intra matrix */
5655 for(i=0; i<64; i++){
5661 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5662 s->inter_matrix[j]= v;
5663 s->chroma_inter_matrix[j]= v;
5666 /* replicate last value */
5668 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5669 s->inter_matrix[j]= last;
5670 s->chroma_inter_matrix[j]= last;
5674 // FIXME a bunch of grayscale shape things
5678 s->quarter_sample= get_bits1(gb);
5679 else s->quarter_sample=0;
5681 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5683 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5685 s->data_partitioning= get_bits1(gb);
5686 if(s->data_partitioning){
5687 s->rvlc= get_bits1(gb);
5690 if(vo_ver_id != 1) {
5691 s->new_pred= get_bits1(gb);
5693 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5694 skip_bits(gb, 2); /* requested upstream message type */
5695 skip_bits1(gb); /* newpred segment type */
5697 s->reduced_res_vop= get_bits1(gb);
5698 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5702 s->reduced_res_vop= 0;
5705 s->scalability= get_bits1(gb);
5707 if (s->scalability) {
5708 GetBitContext bak= *gb;
5710 int ref_layer_sampling_dir;
5711 int h_sampling_factor_n;
5712 int h_sampling_factor_m;
5713 int v_sampling_factor_n;
5714 int v_sampling_factor_m;
5716 s->hierachy_type= get_bits1(gb);
5717 ref_layer_id= get_bits(gb, 4);
5718 ref_layer_sampling_dir= get_bits1(gb);
5719 h_sampling_factor_n= get_bits(gb, 5);
5720 h_sampling_factor_m= get_bits(gb, 5);
5721 v_sampling_factor_n= get_bits(gb, 5);
5722 v_sampling_factor_m= get_bits(gb, 5);
5723 s->enhancement_type= get_bits1(gb);
5725 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5726 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5728 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5733 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5735 // bin shape stuff FIXME
5742 * decodes the user data stuff in the header.
5743 * allso inits divx/xvid/lavc_version/build
5745 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5749 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5752 for(i=0; i<255 && gb->index < gb->size_in_bits; i++){
5753 if(show_bits(gb, 23) == 0) break;
5754 buf[i]= get_bits(gb, 8);
5758 /* divx detection */
5759 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5761 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5763 s->divx_version= ver;
5764 s->divx_build= build;
5765 s->divx_packed= e==3 && last=='p';
5768 /* ffmpeg detection */
5769 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5771 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5773 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5775 build= (ver<<16) + (ver2<<8) + ver3;
5778 if(strcmp(buf, "ffmpeg")==0){
5779 s->lavc_build= 4600;
5783 s->lavc_build= build;
5786 /* xvid detection */
5787 e=sscanf(buf, "XviD%d", &build);
5789 s->xvid_build= build;
5792 //printf("User Data: %s\n", buf);
5796 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5797 int time_incr, time_increment;
5799 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5800 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5801 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5805 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5806 if(s->partitioned_frame)
5807 s->decode_mb= mpeg4_decode_partitioned_mb;
5809 s->decode_mb= ff_mpeg4_decode_mb;
5812 while (get_bits1(gb) != 0)
5815 check_marker(gb, "before time_increment");
5817 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5818 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5820 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5821 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5824 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5827 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5828 else time_increment= get_bits(gb, s->time_increment_bits);
5830 // printf("%d %X\n", s->time_increment_bits, time_increment);
5831 //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);
5832 if(s->pict_type!=B_TYPE){
5833 s->last_time_base= s->time_base;
5834 s->time_base+= time_incr;
5835 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5836 if(s->workaround_bugs&FF_BUG_UMP4){
5837 if(s->time < s->last_non_b_time){
5838 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5840 s->time+= s->avctx->time_base.den;
5843 s->pp_time= s->time - s->last_non_b_time;
5844 s->last_non_b_time= s->time;
5846 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5847 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5848 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5849 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5850 return FRAME_SKIPPED;
5853 if(s->t_frame==0) s->t_frame= s->pb_time;
5854 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5855 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5856 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5857 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5858 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5860 //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);
5862 if(s->avctx->time_base.num)
5863 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5865 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5866 if(s->avctx->debug&FF_DEBUG_PTS)
5867 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5869 check_marker(gb, "before vop_coded");
5872 if (get_bits1(gb) != 1){
5873 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5874 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5875 return FRAME_SKIPPED;
5877 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5878 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5879 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5880 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5881 /* rounding type for motion estimation */
5882 s->no_rounding = get_bits1(gb);
5886 //FIXME reduced res stuff
5888 if (s->shape != RECT_SHAPE) {
5889 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5890 int width, height, hor_spat_ref, ver_spat_ref;
5892 width = get_bits(gb, 13);
5893 skip_bits1(gb); /* marker */
5894 height = get_bits(gb, 13);
5895 skip_bits1(gb); /* marker */
5896 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5897 skip_bits1(gb); /* marker */
5898 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5900 skip_bits1(gb); /* change_CR_disable */
5902 if (get_bits1(gb) != 0) {
5903 skip_bits(gb, 8); /* constant_alpha_value */
5906 //FIXME complexity estimation stuff
5908 if (s->shape != BIN_ONLY_SHAPE) {
5909 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5910 if(!s->progressive_sequence){
5911 s->top_field_first= get_bits1(gb);
5912 s->alternate_scan= get_bits1(gb);
5914 s->alternate_scan= 0;
5917 if(s->alternate_scan){
5918 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5919 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5920 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5921 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5923 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5924 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5925 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5926 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5929 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5930 mpeg4_decode_sprite_trajectory(s, gb);
5931 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5932 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5935 if (s->shape != BIN_ONLY_SHAPE) {
5936 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5938 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5939 return -1; // makes no sense to continue, as there is nothing left from the image then
5942 if (s->pict_type != I_TYPE) {
5943 s->f_code = get_bits(gb, 3); /* fcode_for */
5945 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5946 return -1; // makes no sense to continue, as the MV decoding will break very quickly
5951 if (s->pict_type == B_TYPE) {
5952 s->b_code = get_bits(gb, 3);
5956 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5957 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",
5958 s->qscale, s->f_code, s->b_code,
5959 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5960 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5961 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5962 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5965 if(!s->scalability){
5966 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5967 skip_bits1(gb); // vop shape coding type
5970 if(s->enhancement_type){
5971 int load_backward_shape= get_bits1(gb);
5972 if(load_backward_shape){
5973 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
5976 skip_bits(gb, 2); //ref_select_code
5979 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
5980 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
5981 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5982 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5986 s->picture_number++; // better than pic number==0 always ;)
5988 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5989 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5991 if(s->workaround_bugs&FF_BUG_EDGE){
5992 s->h_edge_pos= s->width;
5993 s->v_edge_pos= s->height;
5999 * decode mpeg4 headers
6000 * @return <0 if no VOP found (or a damaged one)
6001 * FRAME_SKIPPED if a not coded VOP is found
6002 * 0 if a VOP is found
6004 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6008 /* search next start code */
6011 if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6013 if(get_bits(gb, 8) == 0xF0)
6014 return decode_vop_header(s, gb);
6019 if(get_bits_count(gb) >= gb->size_in_bits){
6020 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6021 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6022 return FRAME_SKIPPED; //divx bug
6024 return -1; //end of stream
6027 /* use the bits after the test */
6028 v = get_bits(gb, 8);
6029 startcode = ((startcode << 8) | v) & 0xffffffff;
6031 if((startcode&0xFFFFFF00) != 0x100)
6032 continue; //no startcode
6034 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6035 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6036 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6037 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6038 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6039 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6040 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6041 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6042 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6043 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6044 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6045 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6046 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6047 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6048 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6049 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6050 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6051 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6052 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6053 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6054 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6055 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6056 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6057 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6058 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6059 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6060 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6061 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6062 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6063 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6066 if(startcode >= 0x120 && startcode <= 0x12F){
6067 if(decode_vol_header(s, gb) < 0)
6070 else if(startcode == USER_DATA_STARTCODE){
6071 decode_user_data(s, gb);
6073 else if(startcode == GOP_STARTCODE){
6074 mpeg4_decode_gop_header(s, gb);
6076 else if(startcode == VOP_STARTCODE){
6077 return decode_vop_header(s, gb);
6085 /* don't understand why they choose a different header ! */
6086 int intel_h263_decode_picture_header(MpegEncContext *s)
6090 /* picture header */
6091 if (get_bits_long(&s->gb, 22) != 0x20) {
6092 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6095 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6097 if (get_bits1(&s->gb) != 1) {
6098 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6099 return -1; /* marker */
6101 if (get_bits1(&s->gb) != 0) {
6102 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6103 return -1; /* h263 id */
6105 skip_bits1(&s->gb); /* split screen off */
6106 skip_bits1(&s->gb); /* camera off */
6107 skip_bits1(&s->gb); /* freeze picture release off */
6109 format = get_bits(&s->gb, 3);
6111 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6116 s->pict_type = I_TYPE + get_bits1(&s->gb);
6118 s->unrestricted_mv = get_bits1(&s->gb);
6119 s->h263_long_vectors = s->unrestricted_mv;
6121 if (get_bits1(&s->gb) != 0) {
6122 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6123 return -1; /* SAC: off */
6125 if (get_bits1(&s->gb) != 0) {
6127 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6128 // return -1; /* advanced prediction mode: off */
6130 if (get_bits1(&s->gb) != 0) {
6131 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6132 return -1; /* PB frame mode */
6135 /* skip unknown header garbage */
6136 skip_bits(&s->gb, 41);
6138 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6139 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6142 while (get_bits1(&s->gb) != 0) {
6143 skip_bits(&s->gb, 8);
6147 s->y_dc_scale_table=
6148 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6153 int flv_h263_decode_picture_header(MpegEncContext *s)
6155 int format, width, height;
6157 /* picture header */
6158 if (get_bits_long(&s->gb, 17) != 1) {
6159 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6162 format = get_bits(&s->gb, 5);
6163 if (format != 0 && format != 1) {
6164 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6167 s->h263_flv = format+1;
6168 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6169 format = get_bits(&s->gb, 3);
6172 width = get_bits(&s->gb, 8);
6173 height = get_bits(&s->gb, 8);
6176 width = get_bits(&s->gb, 16);
6177 height = get_bits(&s->gb, 16);
6203 if(avcodec_check_dimensions(s->avctx, width, height))
6208 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6209 s->dropable= s->pict_type > P_TYPE;
6211 s->pict_type = P_TYPE;
6213 skip_bits1(&s->gb); /* deblocking flag */
6214 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6218 s->unrestricted_mv = 1;
6219 s->h263_long_vectors = 0;
6222 while (get_bits1(&s->gb) != 0) {
6223 skip_bits(&s->gb, 8);
6227 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6228 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6229 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6232 s->y_dc_scale_table=
6233 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;