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;
1483 int16_t *dc_val, *ac_val;
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 ac_val = s->ac_val[0][0];
1492 scale = s->y_dc_scale;
1496 wrap = s->mb_stride;
1497 dc_val = s->dc_val[n - 4 + 1];
1498 ac_val = s->ac_val[n - 4 + 1][0];
1499 scale = s->c_dc_scale;
1504 a = dc_val[(x - 1) + (y) * wrap];
1505 c = dc_val[(x) + (y - 1) * wrap];
1507 /* No prediction outside GOB boundary */
1508 if(s->first_slice_line && n!=3){
1510 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1513 /* just DC prediction */
1514 if (a != 1024 && c != 1024)
1515 pred_dc = (a + c) >> 1;
1521 /* we assume pred is positive */
1522 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1523 *dc_val_ptr = &dc_val[x + y * wrap];
1527 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1529 int x, y, wrap, a, c, pred_dc, scale, i;
1530 int16_t *dc_val, *ac_val, *ac_val1;
1532 /* find prediction */
1534 x = 2 * s->mb_x + (n & 1);
1535 y = 2 * s->mb_y + (n>> 1);
1536 wrap = s->b8_stride;
1537 dc_val = s->dc_val[0];
1538 ac_val = s->ac_val[0][0];
1539 scale = s->y_dc_scale;
1543 wrap = s->mb_stride;
1544 dc_val = s->dc_val[n - 4 + 1];
1545 ac_val = s->ac_val[n - 4 + 1][0];
1546 scale = s->c_dc_scale;
1549 ac_val += ((y) * wrap + (x)) * 16;
1555 a = dc_val[(x - 1) + (y) * wrap];
1556 c = dc_val[(x) + (y - 1) * wrap];
1558 /* No prediction outside GOB boundary */
1559 if(s->first_slice_line && n!=3){
1561 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1566 if (s->h263_aic_dir) {
1567 /* left prediction */
1571 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1576 /* top prediction */
1578 ac_val -= 16 * wrap;
1580 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1586 /* just DC prediction */
1587 if (a != 1024 && c != 1024)
1588 pred_dc = (a + c) >> 1;
1595 /* we assume pred is positive */
1596 block[0]=block[0]*scale + pred_dc;
1603 /* Update AC/DC tables */
1604 dc_val[(x) + (y) * wrap] = block[0];
1608 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1611 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1614 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1618 int16_t *A, *B, *C, (*mot_val)[2];
1619 static const int off[4]= {2, 1, 1, -1};
1621 wrap = s->b8_stride;
1622 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1625 /* special case for first (slice) line */
1626 if (s->first_slice_line && block<3) {
1627 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1628 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1629 if(block==0){ //most common case
1630 if(s->mb_x == s->resync_mb_x){ //rare
1632 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1633 C = mot_val[off[block] - wrap];
1638 *px = mid_pred(A[0], 0, C[0]);
1639 *py = mid_pred(A[1], 0, C[1]);
1646 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1647 C = mot_val[off[block] - wrap];
1648 *px = mid_pred(A[0], 0, C[0]);
1649 *py = mid_pred(A[1], 0, C[1]);
1654 }else{ /* block==2*/
1655 B = mot_val[ - wrap];
1656 C = mot_val[off[block] - wrap];
1657 if(s->mb_x == s->resync_mb_x) //rare
1660 *px = mid_pred(A[0], B[0], C[0]);
1661 *py = mid_pred(A[1], B[1], C[1]);
1664 B = mot_val[ - wrap];
1665 C = mot_val[off[block] - wrap];
1666 *px = mid_pred(A[0], B[0], C[0]);
1667 *py = mid_pred(A[1], B[1], C[1]);
1672 #ifdef CONFIG_ENCODERS
1673 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1675 int range, l, bit_size, sign, code, bits;
1680 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1682 bit_size = f_code - 1;
1683 range = 1 << bit_size;
1684 /* modulo encoding */
1685 l= INT_BIT - 6 - bit_size;
1688 val= (val^sign)-sign;
1692 code = (val >> bit_size) + 1;
1693 bits = val & (range - 1);
1695 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1697 put_bits(&s->pb, bit_size, bits);
1702 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1703 static void h263p_encode_umotion(MpegEncContext * s, int val)
1713 put_bits(&s->pb, 1, 1);
1715 put_bits(&s->pb, 3, 0);
1717 put_bits(&s->pb, 3, 2);
1720 sval = ((val < 0) ? (short)(-val):(short)val);
1723 while (temp_val != 0) {
1724 temp_val = temp_val >> 1;
1730 tcode = (sval & (1 << (i-1))) >> (i-1);
1731 tcode = (tcode << 1) | 1;
1732 code = (code << 2) | tcode;
1735 code = ((code << 1) | (val < 0)) << 1;
1736 put_bits(&s->pb, (2*n_bits)+1, code);
1737 //printf("\nVal = %d\tCode = %d", sval, code);
1741 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1746 if(mv_penalty==NULL)
1747 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1749 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1750 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1753 if(mv==0) len= mvtab[0][1];
1755 int val, bit_size, range, code;
1757 bit_size = f_code - 1;
1758 range = 1 << bit_size;
1764 code = (val >> bit_size) + 1;
1766 len= mvtab[code][1] + 1 + bit_size;
1768 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1772 mv_penalty[f_code][mv+MAX_MV]= len;
1776 for(f_code=MAX_FCODE; f_code>0; f_code--){
1777 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1778 fcode_tab[mv+MAX_MV]= f_code;
1782 for(mv=0; mv<MAX_MV*2+1; mv++){
1783 umv_fcode_tab[mv]= 1;
1788 #ifdef CONFIG_ENCODERS
1790 static void init_uni_dc_tab(void)
1792 int level, uni_code, uni_len;
1794 for(level=-256; level<256; level++){
1796 /* find number of bits */
1805 l= (-level) ^ ((1 << size) - 1);
1810 uni_code= DCtab_lum[size][0];
1811 uni_len = DCtab_lum[size][1];
1814 uni_code<<=size; uni_code|=l;
1817 uni_code<<=1; uni_code|=1;
1821 uni_DCtab_lum_bits[level+256]= uni_code;
1822 uni_DCtab_lum_len [level+256]= uni_len;
1825 uni_code= DCtab_chrom[size][0];
1826 uni_len = DCtab_chrom[size][1];
1829 uni_code<<=size; uni_code|=l;
1832 uni_code<<=1; uni_code|=1;
1836 uni_DCtab_chrom_bits[level+256]= uni_code;
1837 uni_DCtab_chrom_len [level+256]= uni_len;
1842 #endif //CONFIG_ENCODERS
1844 #ifdef CONFIG_ENCODERS
1845 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1846 int slevel, run, last;
1848 assert(MAX_LEVEL >= 64);
1849 assert(MAX_RUN >= 63);
1851 for(slevel=-64; slevel<64; slevel++){
1852 if(slevel==0) continue;
1853 for(run=0; run<64; run++){
1854 for(last=0; last<=1; last++){
1855 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1856 int level= slevel < 0 ? -slevel : slevel;
1857 int sign= slevel < 0 ? 1 : 0;
1858 int bits, len, code;
1861 len_tab[index]= 100;
1864 code= get_rl_index(rl, last, run, level);
1865 bits= rl->table_vlc[code][0];
1866 len= rl->table_vlc[code][1];
1867 bits=bits*2+sign; len++;
1869 if(code!=rl->n && len < len_tab[index]){
1870 bits_tab[index]= bits;
1871 len_tab [index]= len;
1875 bits= rl->table_vlc[rl->n][0];
1876 len= rl->table_vlc[rl->n][1];
1877 bits=bits*2; len++; //esc1
1878 level1= level - rl->max_level[last][run];
1880 code= get_rl_index(rl, last, run, level1);
1881 bits<<= rl->table_vlc[code][1];
1882 len += rl->table_vlc[code][1];
1883 bits += rl->table_vlc[code][0];
1884 bits=bits*2+sign; len++;
1886 if(code!=rl->n && len < len_tab[index]){
1887 bits_tab[index]= bits;
1888 len_tab [index]= len;
1894 bits= rl->table_vlc[rl->n][0];
1895 len= rl->table_vlc[rl->n][1];
1896 bits=bits*4+2; len+=2; //esc2
1897 run1 = run - rl->max_run[last][level] - 1;
1899 code= get_rl_index(rl, last, run1, level);
1900 bits<<= rl->table_vlc[code][1];
1901 len += rl->table_vlc[code][1];
1902 bits += rl->table_vlc[code][0];
1903 bits=bits*2+sign; len++;
1905 if(code!=rl->n && len < len_tab[index]){
1906 bits_tab[index]= bits;
1907 len_tab [index]= len;
1912 bits= rl->table_vlc[rl->n][0];
1913 len = rl->table_vlc[rl->n][1];
1914 bits=bits*4+3; len+=2; //esc3
1915 bits=bits*2+last; len++;
1916 bits=bits*64+run; len+=6;
1917 bits=bits*2+1; len++; //marker
1918 bits=bits*4096+(slevel&0xfff); len+=12;
1919 bits=bits*2+1; len++; //marker
1921 if(len < len_tab[index]){
1922 bits_tab[index]= bits;
1923 len_tab [index]= len;
1930 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1931 int slevel, run, last;
1933 assert(MAX_LEVEL >= 64);
1934 assert(MAX_RUN >= 63);
1936 for(slevel=-64; slevel<64; slevel++){
1937 if(slevel==0) continue;
1938 for(run=0; run<64; run++){
1939 for(last=0; last<=1; last++){
1940 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1941 int level= slevel < 0 ? -slevel : slevel;
1942 int sign= slevel < 0 ? 1 : 0;
1943 int bits, len, code;
1945 len_tab[index]= 100;
1948 code= get_rl_index(rl, last, run, level);
1949 bits= rl->table_vlc[code][0];
1950 len= rl->table_vlc[code][1];
1951 bits=bits*2+sign; len++;
1953 if(code!=rl->n && len < len_tab[index]){
1954 if(bits_tab) bits_tab[index]= bits;
1955 len_tab [index]= len;
1958 bits= rl->table_vlc[rl->n][0];
1959 len = rl->table_vlc[rl->n][1];
1960 bits=bits*2+last; len++;
1961 bits=bits*64+run; len+=6;
1962 bits=bits*256+(level&0xff); len+=8;
1964 if(len < len_tab[index]){
1965 if(bits_tab) bits_tab[index]= bits;
1966 len_tab [index]= len;
1973 void h263_encode_init(MpegEncContext *s)
1975 static int done = 0;
1982 init_rl(&rl_inter, 1);
1983 init_rl(&rl_intra, 1);
1984 init_rl(&rl_intra_aic, 1);
1986 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1987 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1989 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1990 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
1992 init_mv_penalty_and_fcode(s);
1994 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1996 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
1997 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1999 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2000 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2002 s->ac_esc_length= 7+1+6+8;
2004 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2005 switch(s->codec_id){
2006 case CODEC_ID_MPEG4:
2007 s->fcode_tab= fcode_tab;
2008 s->min_qcoeff= -2048;
2009 s->max_qcoeff= 2047;
2010 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2011 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2012 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2013 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2014 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2015 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2016 s->ac_esc_length= 7+2+1+6+1+12+1;
2017 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2018 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2020 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2022 s->avctx->extradata= av_malloc(1024);
2023 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2025 if(!(s->workaround_bugs & FF_BUG_MS))
2026 mpeg4_encode_visual_object_header(s);
2027 mpeg4_encode_vol_header(s, 0, 0);
2029 // ff_mpeg4_stuffing(&s->pb); ?
2030 flush_put_bits(&s->pb);
2031 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2035 case CODEC_ID_H263P:
2037 s->fcode_tab= umv_fcode_tab;
2038 if(s->modified_quant){
2039 s->min_qcoeff= -2047;
2040 s->max_qcoeff= 2047;
2042 s->min_qcoeff= -127;
2046 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2048 if (s->h263_flv > 1) {
2049 s->min_qcoeff= -1023;
2050 s->max_qcoeff= 1023;
2052 s->min_qcoeff= -127;
2055 s->y_dc_scale_table=
2056 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2058 default: //nothing needed - default table already set in mpegvideo.c
2059 s->min_qcoeff= -127;
2061 s->y_dc_scale_table=
2062 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2067 * encodes a 8x8 block.
2068 * @param block the 8x8 block
2069 * @param n block index (0-3 are luma, 4-5 are chroma)
2071 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2073 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2077 if (s->mb_intra && !s->h263_aic) {
2080 /* 255 cannot be represented, so we clamp */
2085 /* 0 cannot be represented also */
2086 else if (level < 1) {
2090 if (level == 128) //FIXME check rv10
2091 put_bits(&s->pb, 8, 0xff);
2093 put_bits(&s->pb, 8, level);
2097 if (s->h263_aic && s->mb_intra)
2100 if(s->alt_inter_vlc && !s->mb_intra){
2102 int inter_vlc_bits=0;
2106 last_index = s->block_last_index[n];
2107 last_non_zero = i - 1;
2108 for (; i <= last_index; i++) {
2109 j = s->intra_scantable.permutated[i];
2112 run = i - last_non_zero - 1;
2113 last = (i == last_index);
2115 if(level<0) level= -level;
2117 code = get_rl_index(rl, last, run, level);
2118 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2119 inter_vlc_bits += rl->table_vlc[code][1]+1;
2120 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2122 if (code == rl->n) {
2123 inter_vlc_bits += 1+6+8-1;
2125 if (aic_code == rl_intra_aic.n) {
2126 aic_vlc_bits += 1+6+8-1;
2127 wrong_pos += run + 1;
2129 wrong_pos += wrong_run[aic_code];
2134 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2140 last_index = s->block_last_index[n];
2141 last_non_zero = i - 1;
2142 for (; i <= last_index; i++) {
2143 j = s->intra_scantable.permutated[i];
2146 run = i - last_non_zero - 1;
2147 last = (i == last_index);
2154 code = get_rl_index(rl, last, run, level);
2155 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2156 if (code == rl->n) {
2157 if(s->h263_flv <= 1){
2158 put_bits(&s->pb, 1, last);
2159 put_bits(&s->pb, 6, run);
2161 assert(slevel != 0);
2164 put_bits(&s->pb, 8, slevel & 0xff);
2166 put_bits(&s->pb, 8, 128);
2167 put_bits(&s->pb, 5, slevel & 0x1f);
2168 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2171 if(level < 64) { // 7-bit level
2172 put_bits(&s->pb, 1, 0);
2173 put_bits(&s->pb, 1, last);
2174 put_bits(&s->pb, 6, run);
2176 put_bits(&s->pb, 7, slevel & 0x7f);
2179 put_bits(&s->pb, 1, 1);
2180 put_bits(&s->pb, 1, last);
2181 put_bits(&s->pb, 6, run);
2183 put_bits(&s->pb, 11, slevel & 0x7ff);
2187 put_bits(&s->pb, 1, sign);
2195 #ifdef CONFIG_ENCODERS
2197 /***************************************************/
2199 * add mpeg4 stuffing bits (01...1)
2201 void ff_mpeg4_stuffing(PutBitContext * pbc)
2204 put_bits(pbc, 1, 0);
2205 length= (-put_bits_count(pbc))&7;
2206 if(length) put_bits(pbc, length, (1<<length)-1);
2209 /* must be called before writing the header */
2210 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2211 int time_div, time_mod;
2213 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2214 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2216 time_div= s->time/s->avctx->time_base.den;
2217 time_mod= s->time%s->avctx->time_base.den;
2219 if(s->pict_type==B_TYPE){
2220 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2221 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2223 s->last_time_base= s->time_base;
2224 s->time_base= time_div;
2225 s->pp_time= s->time - s->last_non_b_time;
2226 s->last_non_b_time= s->time;
2227 assert(picture_number==0 || s->pp_time > 0);
2231 static void mpeg4_encode_gop_header(MpegEncContext * s){
2232 int hours, minutes, seconds;
2235 put_bits(&s->pb, 16, 0);
2236 put_bits(&s->pb, 16, GOP_STARTCODE);
2238 time= s->current_picture_ptr->pts;
2239 if(s->reordered_input_picture[1])
2240 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2241 time= time*s->avctx->time_base.num;
2243 seconds= time/s->avctx->time_base.den;
2244 minutes= seconds/60; seconds %= 60;
2245 hours= minutes/60; minutes %= 60;
2248 put_bits(&s->pb, 5, hours);
2249 put_bits(&s->pb, 6, minutes);
2250 put_bits(&s->pb, 1, 1);
2251 put_bits(&s->pb, 6, seconds);
2253 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2254 put_bits(&s->pb, 1, 0); //broken link == NO
2256 s->last_time_base= time / s->avctx->time_base.den;
2258 ff_mpeg4_stuffing(&s->pb);
2261 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2262 int profile_and_level_indication;
2265 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2266 profile_and_level_indication = s->avctx->profile << 4;
2267 }else if(s->max_b_frames || s->quarter_sample){
2268 profile_and_level_indication= 0xF0; // adv simple
2270 profile_and_level_indication= 0x00; // simple
2273 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2274 profile_and_level_indication |= s->avctx->level;
2276 profile_and_level_indication |= 1; //level 1
2279 if(profile_and_level_indication>>4 == 0xF){
2287 put_bits(&s->pb, 16, 0);
2288 put_bits(&s->pb, 16, VOS_STARTCODE);
2290 put_bits(&s->pb, 8, profile_and_level_indication);
2292 put_bits(&s->pb, 16, 0);
2293 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2295 put_bits(&s->pb, 1, 1);
2296 put_bits(&s->pb, 4, vo_ver_id);
2297 put_bits(&s->pb, 3, 1); //priority
2299 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2301 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2303 ff_mpeg4_stuffing(&s->pb);
2306 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2310 if(s->max_b_frames || s->quarter_sample){
2312 s->vo_type= ADV_SIMPLE_VO_TYPE;
2315 s->vo_type= SIMPLE_VO_TYPE;
2318 put_bits(&s->pb, 16, 0);
2319 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2320 put_bits(&s->pb, 16, 0);
2321 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2323 put_bits(&s->pb, 1, 0); /* random access vol */
2324 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2325 if(s->workaround_bugs & FF_BUG_MS) {
2326 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2328 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2329 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2330 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2333 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2335 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2336 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2337 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2338 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2341 if(s->workaround_bugs & FF_BUG_MS) { //
2342 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2344 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2345 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2346 put_bits(&s->pb, 1, s->low_delay);
2347 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2350 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2351 put_bits(&s->pb, 1, 1); /* marker bit */
2353 put_bits(&s->pb, 16, s->avctx->time_base.den);
2354 if (s->time_increment_bits < 1)
2355 s->time_increment_bits = 1;
2356 put_bits(&s->pb, 1, 1); /* marker bit */
2357 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2358 put_bits(&s->pb, 1, 1); /* marker bit */
2359 put_bits(&s->pb, 13, s->width); /* vol width */
2360 put_bits(&s->pb, 1, 1); /* marker bit */
2361 put_bits(&s->pb, 13, s->height); /* vol height */
2362 put_bits(&s->pb, 1, 1); /* marker bit */
2363 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2364 put_bits(&s->pb, 1, 1); /* obmc disable */
2365 if (vo_ver_id == 1) {
2366 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2368 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2371 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2372 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2375 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2376 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2380 put_bits(&s->pb, 1, s->quarter_sample);
2381 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2382 s->resync_marker= s->rtp_mode;
2383 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2384 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2385 if(s->data_partitioning){
2386 put_bits(&s->pb, 1, 0); /* no rvlc */
2389 if (vo_ver_id != 1){
2390 put_bits(&s->pb, 1, 0); /* newpred */
2391 put_bits(&s->pb, 1, 0); /* reduced res vop */
2393 put_bits(&s->pb, 1, 0); /* scalability */
2395 ff_mpeg4_stuffing(&s->pb);
2398 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2399 put_bits(&s->pb, 16, 0);
2400 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2401 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2405 /* write mpeg4 VOP header */
2406 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2409 int time_div, time_mod;
2411 if(s->pict_type==I_TYPE){
2412 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2413 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2414 mpeg4_encode_visual_object_header(s);
2415 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2416 mpeg4_encode_vol_header(s, 0, 0);
2418 if(!(s->workaround_bugs & FF_BUG_MS))
2419 mpeg4_encode_gop_header(s);
2422 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2424 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2426 put_bits(&s->pb, 16, 0); /* vop header */
2427 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2428 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2431 time_div= s->time/s->avctx->time_base.den;
2432 time_mod= s->time%s->avctx->time_base.den;
2433 time_incr= time_div - s->last_time_base;
2434 assert(time_incr >= 0);
2436 put_bits(&s->pb, 1, 1);
2438 put_bits(&s->pb, 1, 0);
2440 put_bits(&s->pb, 1, 1); /* marker */
2441 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2442 put_bits(&s->pb, 1, 1); /* marker */
2443 put_bits(&s->pb, 1, 1); /* vop coded */
2444 if ( s->pict_type == P_TYPE
2445 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2446 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2448 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2449 if(!s->progressive_sequence){
2450 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2451 put_bits(&s->pb, 1, s->alternate_scan);
2453 //FIXME sprite stuff
2455 put_bits(&s->pb, 5, s->qscale);
2457 if (s->pict_type != I_TYPE)
2458 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2459 if (s->pict_type == B_TYPE)
2460 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2461 // printf("****frame %d\n", picture_number);
2464 #endif //CONFIG_ENCODERS
2467 * set qscale and update qscale dependant variables.
2469 void ff_set_qscale(MpegEncContext * s, int qscale)
2473 else if (qscale > 31)
2477 s->chroma_qscale= s->chroma_qscale_table[qscale];
2479 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2480 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2485 * encoding quantized level -> quantized diff
2486 * decoding quantized diff -> quantized level
2487 * @param n block index (0-3 are luma, 4-5 are chroma)
2488 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2490 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2492 int a, b, c, wrap, pred, scale, ret;
2495 /* find prediction */
2497 scale = s->y_dc_scale;
2499 scale = s->c_dc_scale;
2504 wrap= s->block_wrap[n];
2505 dc_val = s->dc_val[0] + s->block_index[n];
2511 b = dc_val[ - 1 - wrap];
2512 c = dc_val[ - wrap];
2514 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2515 if(s->first_slice_line && n!=3){
2517 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2519 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2520 if(n==0 || n==4 || n==5)
2524 if (abs(a - b) < abs(b - c)) {
2526 *dir_ptr = 1; /* top */
2529 *dir_ptr = 0; /* left */
2531 /* we assume pred is positive */
2532 pred = FASTDIV((pred + (scale >> 1)), scale);
2539 if(s->error_resilience>=3){
2541 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2544 if(level*scale > 2048 + scale){
2545 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2554 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2564 * @param n block index (0-3 are luma, 4-5 are chroma)
2565 * @param dir the ac prediction direction
2567 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2571 int16_t *ac_val, *ac_val1;
2572 int8_t * const qscale_table= s->current_picture.qscale_table;
2574 /* find prediction */
2575 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2579 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2580 /* left prediction */
2583 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2586 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2589 /* different qscale, we must rescale */
2591 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2595 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2596 /* top prediction */
2597 ac_val -= 16 * s->block_wrap[n];
2599 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2602 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2605 /* different qscale, we must rescale */
2607 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2614 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2618 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2622 #ifdef CONFIG_ENCODERS
2625 * encodes the dc value.
2626 * @param n block index (0-3 are luma, 4-5 are chroma)
2628 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2631 // if(level<-255 || level>255) printf("dc overflow\n");
2635 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2638 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2642 /* find number of bits */
2652 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2655 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2658 /* encode remaining bits */
2661 level = (-level) ^ ((1 << size) - 1);
2662 put_bits(&s->pb, size, level);
2664 put_bits(&s->pb, 1, 1);
2669 static inline int mpeg4_get_dc_length(int level, int n){
2671 return uni_DCtab_lum_len[level + 256];
2673 return uni_DCtab_chrom_len[level + 256];
2678 * encodes a 8x8 block
2679 * @param n block index (0-3 are luma, 4-5 are chroma)
2681 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2682 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2684 int i, last_non_zero;
2685 #if 0 //variables for the outcommented version
2686 int code, sign, last;
2691 const int last_index = s->block_last_index[n];
2693 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2694 /* mpeg4 based DC predictor */
2695 mpeg4_encode_dc(dc_pb, intra_dc, n);
2696 if(last_index<1) return;
2699 bits_tab= uni_mpeg4_intra_rl_bits;
2700 len_tab = uni_mpeg4_intra_rl_len;
2702 if(last_index<0) return;
2705 bits_tab= uni_mpeg4_inter_rl_bits;
2706 len_tab = uni_mpeg4_inter_rl_len;
2710 last_non_zero = i - 1;
2712 for (; i < last_index; i++) {
2713 int level = block[ scan_table[i] ];
2715 int run = i - last_non_zero - 1;
2717 if((level&(~127)) == 0){
2718 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2719 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2721 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);
2726 /*if(i<=last_index)*/{
2727 int level = block[ scan_table[i] ];
2728 int run = i - last_non_zero - 1;
2730 if((level&(~127)) == 0){
2731 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2732 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2734 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);
2738 for (; i <= last_index; i++) {
2739 const int slevel = block[ scan_table[i] ];
2742 int run = i - last_non_zero - 1;
2743 last = (i == last_index);
2750 code = get_rl_index(rl, last, run, level);
2751 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2752 if (code == rl->n) {
2754 level1 = level - rl->max_level[last][run];
2757 code = get_rl_index(rl, last, run, level1);
2758 if (code == rl->n) {
2760 put_bits(ac_pb, 1, 1);
2761 if (level > MAX_LEVEL)
2763 run1 = run - rl->max_run[last][level] - 1;
2766 code = get_rl_index(rl, last, run1, level);
2767 if (code == rl->n) {
2770 put_bits(ac_pb, 1, 1);
2771 put_bits(ac_pb, 1, last);
2772 put_bits(ac_pb, 6, run);
2773 put_bits(ac_pb, 1, 1);
2774 put_bits(ac_pb, 12, slevel & 0xfff);
2775 put_bits(ac_pb, 1, 1);
2778 put_bits(ac_pb, 1, 0);
2779 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2780 put_bits(ac_pb, 1, sign);
2784 put_bits(ac_pb, 1, 0);
2785 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2786 put_bits(ac_pb, 1, sign);
2789 put_bits(ac_pb, 1, sign);
2797 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2798 uint8_t *scan_table)
2800 int i, last_non_zero;
2803 const int last_index = s->block_last_index[n];
2806 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2807 /* mpeg4 based DC predictor */
2808 len += mpeg4_get_dc_length(intra_dc, n);
2809 if(last_index<1) return len;
2812 len_tab = uni_mpeg4_intra_rl_len;
2814 if(last_index<0) return 0;
2817 len_tab = uni_mpeg4_inter_rl_len;
2821 last_non_zero = i - 1;
2822 for (; i < last_index; i++) {
2823 int level = block[ scan_table[i] ];
2825 int run = i - last_non_zero - 1;
2827 if((level&(~127)) == 0){
2828 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2829 len += len_tab[index];
2831 len += 7+2+1+6+1+12+1;
2836 /*if(i<=last_index)*/{
2837 int level = block[ scan_table[i] ];
2838 int run = i - last_non_zero - 1;
2840 if((level&(~127)) == 0){
2841 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2842 len += len_tab[index];
2844 len += 7+2+1+6+1+12+1;
2854 /***********************************************/
2857 static VLC intra_MCBPC_vlc;
2858 static VLC inter_MCBPC_vlc;
2859 static VLC cbpy_vlc;
2861 static VLC dc_lum, dc_chrom;
2862 static VLC sprite_trajectory;
2863 static VLC mb_type_b_vlc;
2864 static VLC h263_mbtype_b_vlc;
2865 static VLC cbpc_b_vlc;
2867 void init_vlc_rl(RLTable *rl, int use_static)
2871 /* Return if static table is already initialized */
2872 if(use_static && rl->rl_vlc[0])
2875 init_vlc(&rl->vlc, 9, rl->n + 1,
2876 &rl->table_vlc[0][1], 4, 2,
2877 &rl->table_vlc[0][0], 4, 2, use_static);
2880 for(q=0; q<32; q++){
2889 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2891 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2892 for(i=0; i<rl->vlc.table_size; i++){
2893 int code= rl->vlc.table[i][0];
2894 int len = rl->vlc.table[i][1];
2897 if(len==0){ // illegal code
2900 }else if(len<0){ //more bits needed
2904 if(code==rl->n){ //esc
2908 run= rl->table_run [code] + 1;
2909 level= rl->table_level[code] * qmul + qadd;
2910 if(code >= rl->last) run+=192;
2913 rl->rl_vlc[q][i].len= len;
2914 rl->rl_vlc[q][i].level= level;
2915 rl->rl_vlc[q][i].run= run;
2922 /* XXX: find a better solution to handle static init */
2923 void h263_decode_init_vlc(MpegEncContext *s)
2925 static int done = 0;
2930 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2931 intra_MCBPC_bits, 1, 1,
2932 intra_MCBPC_code, 1, 1, 1);
2933 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2934 inter_MCBPC_bits, 1, 1,
2935 inter_MCBPC_code, 1, 1, 1);
2936 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2937 &cbpy_tab[0][1], 2, 1,
2938 &cbpy_tab[0][0], 2, 1, 1);
2939 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2941 &mvtab[0][0], 2, 1, 1);
2942 init_rl(&rl_inter, 1);
2943 init_rl(&rl_intra, 1);
2944 init_rl(&rvlc_rl_inter, 1);
2945 init_rl(&rvlc_rl_intra, 1);
2946 init_rl(&rl_intra_aic, 1);
2947 init_vlc_rl(&rl_inter, 1);
2948 init_vlc_rl(&rl_intra, 1);
2949 init_vlc_rl(&rvlc_rl_inter, 1);
2950 init_vlc_rl(&rvlc_rl_intra, 1);
2951 init_vlc_rl(&rl_intra_aic, 1);
2952 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2953 &DCtab_lum[0][1], 2, 1,
2954 &DCtab_lum[0][0], 2, 1, 1);
2955 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2956 &DCtab_chrom[0][1], 2, 1,
2957 &DCtab_chrom[0][0], 2, 1, 1);
2958 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2959 &sprite_trajectory_tab[0][1], 4, 2,
2960 &sprite_trajectory_tab[0][0], 4, 2, 1);
2961 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2962 &mb_type_b_tab[0][1], 2, 1,
2963 &mb_type_b_tab[0][0], 2, 1, 1);
2964 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2965 &h263_mbtype_b_tab[0][1], 2, 1,
2966 &h263_mbtype_b_tab[0][0], 2, 1, 1);
2967 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2968 &cbpc_b_tab[0][1], 2, 1,
2969 &cbpc_b_tab[0][0], 2, 1, 1);
2974 * Get the GOB height based on picture height.
2976 int ff_h263_get_gob_height(MpegEncContext *s){
2977 if (s->height <= 400)
2979 else if (s->height <= 800)
2985 int ff_h263_decode_mba(MpegEncContext *s)
2990 if(s->mb_num-1 <= ff_mba_max[i]) break;
2992 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2993 s->mb_x= mb_pos % s->mb_width;
2994 s->mb_y= mb_pos / s->mb_width;
2999 void ff_h263_encode_mba(MpegEncContext *s)
3004 if(s->mb_num-1 <= ff_mba_max[i]) break;
3006 mb_pos= s->mb_x + s->mb_width*s->mb_y;
3007 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3011 * decodes the group of blocks header or slice header.
3012 * @return <0 if an error occured
3014 static int h263_decode_gob_header(MpegEncContext *s)
3016 unsigned int val, gfid, gob_number;
3019 /* Check for GOB Start Code */
3020 val = show_bits(&s->gb, 16);
3024 /* We have a GBSC probably with GSTUFF */
3025 skip_bits(&s->gb, 16); /* Drop the zeros */
3026 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3027 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3028 for(;left>13; left--){
3029 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3034 if(s->h263_slice_structured){
3035 if(get_bits1(&s->gb)==0)
3038 ff_h263_decode_mba(s);
3040 if(s->mb_num > 1583)
3041 if(get_bits1(&s->gb)==0)
3044 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3045 if(get_bits1(&s->gb)==0)
3047 gfid = get_bits(&s->gb, 2); /* GFID */
3049 gob_number = get_bits(&s->gb, 5); /* GN */
3051 s->mb_y= s->gob_index* gob_number;
3052 gfid = get_bits(&s->gb, 2); /* GFID */
3053 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3056 if(s->mb_y >= s->mb_height)
3065 static inline void memsetw(short *tab, int val, int n)
3072 #ifdef CONFIG_ENCODERS
3074 void ff_mpeg4_init_partitions(MpegEncContext *s)
3076 uint8_t *start= pbBufPtr(&s->pb);
3077 uint8_t *end= s->pb.buf_end;
3078 int size= end - start;
3079 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3080 int tex_size= (size - 2*pb_size)&(~3);
3082 set_put_bits_buffer_size(&s->pb, pb_size);
3083 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3084 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3087 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3089 const int pb2_len = put_bits_count(&s->pb2 );
3090 const int tex_pb_len= put_bits_count(&s->tex_pb);
3091 const int bits= put_bits_count(&s->pb);
3093 if(s->pict_type==I_TYPE){
3094 put_bits(&s->pb, 19, DC_MARKER);
3095 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3096 s->i_tex_bits+= tex_pb_len;
3098 put_bits(&s->pb, 17, MOTION_MARKER);
3099 s->misc_bits+=17 + pb2_len;
3100 s->mv_bits+= bits - s->last_bits;
3101 s->p_tex_bits+= tex_pb_len;
3104 flush_put_bits(&s->pb2);
3105 flush_put_bits(&s->tex_pb);
3107 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3108 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3109 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3110 s->last_bits= put_bits_count(&s->pb);
3113 #endif //CONFIG_ENCODERS
3115 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3116 switch(s->pict_type){
3121 return s->f_code+15;
3123 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3129 #ifdef CONFIG_ENCODERS
3131 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3133 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3135 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3136 put_bits(&s->pb, 1, 1);
3138 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3139 put_bits(&s->pb, s->quant_precision, s->qscale);
3140 put_bits(&s->pb, 1, 0); /* no HEC */
3143 #endif //CONFIG_ENCODERS
3146 * check if the next stuff is a resync marker or the end.
3149 static inline int mpeg4_is_resync(MpegEncContext *s){
3150 const int bits_count= get_bits_count(&s->gb);
3152 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3156 if(bits_count + 8 >= s->gb.size_in_bits){
3157 int v= show_bits(&s->gb, 8);
3158 v|= 0x7F >> (7-(bits_count&7));
3163 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3165 GetBitContext gb= s->gb;
3167 skip_bits(&s->gb, 1);
3168 align_get_bits(&s->gb);
3170 for(len=0; len<32; len++){
3171 if(get_bits1(&s->gb)) break;
3176 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3184 * decodes the next video packet.
3185 * @return <0 if something went wrong
3187 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3189 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3190 int header_extension=0, mb_num, len;
3192 /* is there enough space left for a video packet + header */
3193 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3195 for(len=0; len<32; len++){
3196 if(get_bits1(&s->gb)) break;
3199 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3200 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3204 if(s->shape != RECT_SHAPE){
3205 header_extension= get_bits1(&s->gb);
3206 //FIXME more stuff here
3209 mb_num= get_bits(&s->gb, mb_num_bits);
3210 if(mb_num>=s->mb_num){
3211 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3214 if(s->pict_type == B_TYPE){
3215 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3216 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3219 s->mb_x= mb_num % s->mb_width;
3220 s->mb_y= mb_num / s->mb_width;
3222 if(s->shape != BIN_ONLY_SHAPE){
3223 int qscale= get_bits(&s->gb, s->quant_precision);
3225 s->chroma_qscale=s->qscale= qscale;
3228 if(s->shape == RECT_SHAPE){
3229 header_extension= get_bits1(&s->gb);
3231 if(header_extension){
3235 while (get_bits1(&s->gb) != 0)
3238 check_marker(&s->gb, "before time_increment in video packed header");
3239 time_increment= get_bits(&s->gb, s->time_increment_bits);
3240 check_marker(&s->gb, "before vop_coding_type in video packed header");
3242 skip_bits(&s->gb, 2); /* vop coding type */
3243 //FIXME not rect stuff here
3245 if(s->shape != BIN_ONLY_SHAPE){
3246 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3247 //FIXME don't just ignore everything
3248 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3249 mpeg4_decode_sprite_trajectory(s, &s->gb);
3250 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3253 //FIXME reduced res stuff here
3255 if (s->pict_type != I_TYPE) {
3256 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3258 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3261 if (s->pict_type == B_TYPE) {
3262 int b_code = get_bits(&s->gb, 3);
3264 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3269 //FIXME new-pred stuff
3271 //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));
3276 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3278 int c_wrap, c_xy, l_wrap, l_xy;
3280 l_wrap= s->b8_stride;
3281 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3282 c_wrap= s->mb_stride;
3283 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3287 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3288 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3289 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3293 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3294 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3295 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3298 // we can't clear the MVs as they might be needed by a b frame
3299 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3300 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3301 s->last_mv[0][0][0]=
3302 s->last_mv[0][0][1]=
3303 s->last_mv[1][0][0]=
3304 s->last_mv[1][0][1]= 0;
3308 * decodes the group of blocks / video packet header.
3309 * @return <0 if no resync found
3311 int ff_h263_resync(MpegEncContext *s){
3314 if(s->codec_id==CODEC_ID_MPEG4){
3316 align_get_bits(&s->gb);
3319 if(show_bits(&s->gb, 16)==0){
3320 if(s->codec_id==CODEC_ID_MPEG4)
3321 ret= mpeg4_decode_video_packet_header(s);
3323 ret= h263_decode_gob_header(s);
3327 //ok, it's not where its supposed to be ...
3328 s->gb= s->last_resync_gb;
3329 align_get_bits(&s->gb);
3330 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3332 for(;left>16+1+5+5; left-=8){
3333 if(show_bits(&s->gb, 16)==0){
3334 GetBitContext bak= s->gb;
3336 if(s->codec_id==CODEC_ID_MPEG4)
3337 ret= mpeg4_decode_video_packet_header(s);
3339 ret= h263_decode_gob_header(s);
3345 skip_bits(&s->gb, 8);
3352 * gets the average motion vector for a GMC MB.
3353 * @param n either 0 for the x component or 1 for y
3354 * @returns the average MV for a GMC MB
3356 static inline int get_amv(MpegEncContext *s, int n){
3357 int x, y, mb_v, sum, dx, dy, shift;
3358 int len = 1 << (s->f_code + 4);
3359 const int a= s->sprite_warping_accuracy;
3361 if(s->workaround_bugs & FF_BUG_AMV)
3362 len >>= s->quarter_sample;
3364 if(s->real_sprite_warping_points==1){
3365 if(s->divx_version==500 && s->divx_build==413)
3366 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3368 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3370 dx= s->sprite_delta[n][0];
3371 dy= s->sprite_delta[n][1];
3372 shift= s->sprite_shift[0];
3373 if(n) dy -= 1<<(shift + a + 1);
3374 else dx -= 1<<(shift + a + 1);
3375 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3378 for(y=0; y<16; y++){
3382 //XXX FIXME optimize
3383 for(x=0; x<16; x++){
3388 sum= RSHIFT(sum, a+8-s->quarter_sample);
3391 if (sum < -len) sum= -len;
3392 else if (sum >= len) sum= len-1;
3398 * decodes first partition.
3399 * @return number of MBs decoded or <0 if an error occured
3401 static int mpeg4_decode_partition_a(MpegEncContext *s){
3403 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3405 /* decode first partition */
3407 s->first_slice_line=1;
3408 for(; s->mb_y<s->mb_height; s->mb_y++){
3409 ff_init_block_index(s);
3410 for(; s->mb_x<s->mb_width; s->mb_x++){
3411 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3416 ff_update_block_index(s);
3417 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3418 s->first_slice_line=0;
3420 if(s->pict_type==I_TYPE){
3424 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3428 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3430 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3435 s->cbp_table[xy]= cbpc & 3;
3436 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3440 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3442 s->current_picture.qscale_table[xy]= s->qscale;
3444 s->mbintra_table[xy]= 1;
3447 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3449 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3453 if(dc_pred_dir) dir|=1;
3455 s->pred_dir_table[xy]= dir;
3456 }else{ /* P/S_TYPE */
3457 int mx, my, pred_x, pred_y, bits;
3458 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3459 const int stride= s->b8_stride*2;
3462 bits= show_bits(&s->gb, 17);
3463 if(bits==MOTION_MARKER){
3469 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3470 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3474 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3477 mot_val[0 ]= mot_val[2 ]=
3478 mot_val[0+stride]= mot_val[2+stride]= mx;
3479 mot_val[1 ]= mot_val[3 ]=
3480 mot_val[1+stride]= mot_val[3+stride]= my;
3482 if(s->mbintra_table[xy])
3483 ff_clean_intra_table_entries(s);
3487 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3489 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3495 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3497 s->mb_intra = ((cbpc & 4) != 0);
3500 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3501 s->mbintra_table[xy]= 1;
3502 mot_val[0 ]= mot_val[2 ]=
3503 mot_val[0+stride]= mot_val[2+stride]= 0;
3504 mot_val[1 ]= mot_val[3 ]=
3505 mot_val[1+stride]= mot_val[3+stride]= 0;
3507 if(s->mbintra_table[xy])
3508 ff_clean_intra_table_entries(s);
3510 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3511 s->mcsel= get_bits1(&s->gb);
3514 if ((cbpc & 16) == 0) {
3515 /* 16x16 motion prediction */
3517 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3519 mx = h263_decode_motion(s, pred_x, s->f_code);
3523 my = h263_decode_motion(s, pred_y, s->f_code);
3526 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3530 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3533 mot_val[0 ]= mot_val[2 ] =
3534 mot_val[0+stride]= mot_val[2+stride]= mx;
3535 mot_val[1 ]= mot_val[3 ]=
3536 mot_val[1+stride]= mot_val[3+stride]= my;
3539 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3541 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3542 mx = h263_decode_motion(s, pred_x, s->f_code);
3546 my = h263_decode_motion(s, pred_y, s->f_code);
3563 * decode second partition.
3564 * @return <0 if an error occured
3566 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3568 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3570 s->mb_x= s->resync_mb_x;
3571 s->first_slice_line=1;
3572 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3573 ff_init_block_index(s);
3574 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3575 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3578 ff_update_block_index(s);
3579 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3580 s->first_slice_line=0;
3582 if(s->pict_type==I_TYPE){
3583 int ac_pred= get_bits1(&s->gb);
3584 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3586 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3590 s->cbp_table[xy]|= cbpy<<2;
3591 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3592 }else{ /* P || S_TYPE */
3593 if(IS_INTRA(s->current_picture.mb_type[xy])){
3595 int ac_pred = get_bits1(&s->gb);
3596 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3599 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3603 if(s->cbp_table[xy] & 8) {
3604 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3606 s->current_picture.qscale_table[xy]= s->qscale;
3610 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3612 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3616 if(dc_pred_dir) dir|=1;
3618 s->cbp_table[xy]&= 3; //remove dquant
3619 s->cbp_table[xy]|= cbpy<<2;
3620 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3621 s->pred_dir_table[xy]= dir;
3622 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3623 s->current_picture.qscale_table[xy]= s->qscale;
3624 s->cbp_table[xy]= 0;
3626 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3629 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3633 if(s->cbp_table[xy] & 8) {
3634 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3636 s->current_picture.qscale_table[xy]= s->qscale;
3638 s->cbp_table[xy]&= 3; //remove dquant
3639 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3643 if(mb_num >= mb_count) return 0;
3650 * decodes the first & second partition
3651 * @return <0 if error (and sets error type in the error_status_table)
3653 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3656 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3657 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3659 mb_num= mpeg4_decode_partition_a(s);
3661 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3665 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3666 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3667 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3671 s->mb_num_left= mb_num;
3673 if(s->pict_type==I_TYPE){
3674 while(show_bits(&s->gb, 9) == 1)
3675 skip_bits(&s->gb, 9);
3676 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3677 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3681 while(show_bits(&s->gb, 10) == 1)
3682 skip_bits(&s->gb, 10);
3683 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3684 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3688 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3690 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3691 if(s->pict_type==P_TYPE)
3692 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3695 if(s->pict_type==P_TYPE)
3696 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3703 * decode partition C of one MB.
3704 * @return <0 if an error occured
3706 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3709 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3711 mb_type= s->current_picture.mb_type[xy];
3712 cbp = s->cbp_table[xy];
3714 if(s->current_picture.qscale_table[xy] != s->qscale){
3715 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3718 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3721 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3722 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3724 s->mb_intra = IS_INTRA(mb_type);
3726 if (IS_SKIP(mb_type)) {
3729 s->block_last_index[i] = -1;
3730 s->mv_dir = MV_DIR_FORWARD;
3731 s->mv_type = MV_TYPE_16X16;
3732 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3739 }else if(s->mb_intra){
3740 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3741 }else if(!s->mb_intra){
3742 // s->mcsel= 0; //FIXME do we need to init that
3744 s->mv_dir = MV_DIR_FORWARD;
3745 if (IS_8X8(mb_type)) {
3746 s->mv_type = MV_TYPE_8X8;
3748 s->mv_type = MV_TYPE_16X16;
3751 } else { /* I-Frame */
3753 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3756 if (!IS_SKIP(mb_type)) {
3758 s->dsp.clear_blocks(s->block[0]);
3759 /* decode each block */
3760 for (i = 0; i < 6; i++) {
3761 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3762 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3769 /* per-MB end of slice check */
3771 if(--s->mb_num_left <= 0){
3772 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3773 if(mpeg4_is_resync(s))
3778 if(mpeg4_is_resync(s)){
3779 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3780 if(s->cbp_table[xy+delta])
3788 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3790 static void preview_obmc(MpegEncContext *s){
3791 GetBitContext gb= s->gb;
3793 int cbpc, i, pred_x, pred_y, mx, my;
3795 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3796 const int stride= s->b8_stride*2;
3799 s->block_index[i]+= 2;
3801 s->block_index[i]+= 1;
3804 assert(s->pict_type == P_TYPE);
3807 if (get_bits1(&s->gb)) {
3809 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3810 mot_val[0 ]= mot_val[2 ]=
3811 mot_val[0+stride]= mot_val[2+stride]= 0;
3812 mot_val[1 ]= mot_val[3 ]=
3813 mot_val[1+stride]= mot_val[3+stride]= 0;
3815 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3818 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3822 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3824 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3826 if(s->modified_quant){
3827 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3828 else skip_bits(&s->gb, 5);
3830 skip_bits(&s->gb, 2);
3833 if ((cbpc & 16) == 0) {
3834 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3835 /* 16x16 motion prediction */
3836 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3838 mx = h263p_decode_umotion(s, pred_x);
3840 mx = h263_decode_motion(s, pred_x, 1);
3843 my = h263p_decode_umotion(s, pred_y);
3845 my = h263_decode_motion(s, pred_y, 1);
3847 mot_val[0 ]= mot_val[2 ]=
3848 mot_val[0+stride]= mot_val[2+stride]= mx;
3849 mot_val[1 ]= mot_val[3 ]=
3850 mot_val[1+stride]= mot_val[3+stride]= my;
3852 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3854 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3856 mx = h263p_decode_umotion(s, pred_x);
3858 mx = h263_decode_motion(s, pred_x, 1);
3861 my = h263p_decode_umotion(s, pred_y);
3863 my = h263_decode_motion(s, pred_y, 1);
3864 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3865 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3874 s->block_index[i]-= 2;
3876 s->block_index[i]-= 1;
3882 static void h263_decode_dquant(MpegEncContext *s){
3883 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3885 if(s->modified_quant){
3886 if(get_bits1(&s->gb))
3887 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3889 s->qscale= get_bits(&s->gb, 5);
3891 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3892 ff_set_qscale(s, s->qscale);
3895 int ff_h263_decode_mb(MpegEncContext *s,
3896 DCTELEM block[6][64])
3898 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3900 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3902 assert(!s->h263_pred);
3904 if (s->pict_type == P_TYPE) {
3906 if (get_bits1(&s->gb)) {
3910 s->block_last_index[i] = -1;
3911 s->mv_dir = MV_DIR_FORWARD;
3912 s->mv_type = MV_TYPE_16X16;
3913 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3916 s->mb_skipped = !(s->obmc | s->loop_filter);
3919 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3920 //fprintf(stderr, "\tCBPC: %d", cbpc);
3922 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3927 s->dsp.clear_blocks(s->block[0]);
3930 s->mb_intra = ((cbpc & 4) != 0);
3931 if (s->mb_intra) goto intra;
3933 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3935 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3938 cbp = (cbpc & 3) | (cbpy << 2);
3940 h263_decode_dquant(s);
3943 s->mv_dir = MV_DIR_FORWARD;
3944 if ((cbpc & 16) == 0) {
3945 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3946 /* 16x16 motion prediction */
3947 s->mv_type = MV_TYPE_16X16;
3948 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3950 mx = h263p_decode_umotion(s, pred_x);
3952 mx = h263_decode_motion(s, pred_x, 1);
3958 my = h263p_decode_umotion(s, pred_y);
3960 my = h263_decode_motion(s, pred_y, 1);
3964 s->mv[0][0][0] = mx;
3965 s->mv[0][0][1] = my;
3967 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3968 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3970 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3971 s->mv_type = MV_TYPE_8X8;
3973 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3975 mx = h263p_decode_umotion(s, pred_x);
3977 mx = h263_decode_motion(s, pred_x, 1);
3982 my = h263p_decode_umotion(s, pred_y);
3984 my = h263_decode_motion(s, pred_y, 1);
3987 s->mv[0][i][0] = mx;
3988 s->mv[0][i][1] = my;
3989 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3990 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3996 /* decode each block */
3997 for (i = 0; i < 6; i++) {
3998 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4004 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4007 } else if(s->pict_type==B_TYPE) {
4009 const int stride= s->b8_stride;
4010 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4011 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4012 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4015 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4016 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4017 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4018 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4021 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4023 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4027 mb_type= h263_mb_type_b_map[ mb_type ];
4030 s->mb_intra = IS_INTRA(mb_type);
4031 if(HAS_CBP(mb_type)){
4032 s->dsp.clear_blocks(s->block[0]);
4033 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4035 dquant = IS_QUANT(mb_type);
4039 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4042 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4046 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4049 cbp = (cbpc & 3) | (cbpy << 2);
4053 assert(!s->mb_intra);
4055 if(IS_QUANT(mb_type)){
4056 h263_decode_dquant(s);
4059 if(IS_DIRECT(mb_type)){
4060 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4061 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4064 s->mv_type= MV_TYPE_16X16;
4067 if(USES_LIST(mb_type, 0)){
4068 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4069 s->mv_dir = MV_DIR_FORWARD;
4071 mx = h263_decode_motion(s, mx, 1);
4072 my = h263_decode_motion(s, my, 1);
4074 s->mv[0][0][0] = mx;
4075 s->mv[0][0][1] = my;
4076 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4077 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4080 if(USES_LIST(mb_type, 1)){
4081 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4082 s->mv_dir |= MV_DIR_BACKWARD;
4084 mx = h263_decode_motion(s, mx, 1);
4085 my = h263_decode_motion(s, my, 1);
4087 s->mv[1][0][0] = mx;
4088 s->mv[1][0][1] = my;
4089 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4090 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4094 s->current_picture.mb_type[xy]= mb_type;
4096 /* decode each block */
4097 for (i = 0; i < 6; i++) {
4098 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4102 } else { /* I-Frame */
4104 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4106 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4111 s->dsp.clear_blocks(s->block[0]);
4116 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4118 s->ac_pred = get_bits1(&s->gb);
4120 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4122 s->h263_aic_dir = get_bits1(&s->gb);
4127 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4129 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4132 cbp = (cbpc & 3) | (cbpy << 2);
4134 h263_decode_dquant(s);
4137 /* decode each block */
4138 for (i = 0; i < 6; i++) {
4139 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4146 /* per-MB end of slice check */
4148 int v= show_bits(&s->gb, 16);
4150 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4151 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4161 int ff_mpeg4_decode_mb(MpegEncContext *s,
4162 DCTELEM block[6][64])
4164 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4166 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4167 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4169 assert(s->h263_pred);
4171 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4173 if (get_bits1(&s->gb)) {
4177 s->block_last_index[i] = -1;
4178 s->mv_dir = MV_DIR_FORWARD;
4179 s->mv_type = MV_TYPE_16X16;
4180 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4181 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4183 s->mv[0][0][0]= get_amv(s, 0);
4184 s->mv[0][0][1]= get_amv(s, 1);
4188 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4196 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4197 //fprintf(stderr, "\tCBPC: %d", cbpc);
4199 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4204 s->dsp.clear_blocks(s->block[0]);
4206 s->mb_intra = ((cbpc & 4) != 0);
4207 if (s->mb_intra) goto intra;
4209 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4210 s->mcsel= get_bits1(&s->gb);
4212 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4214 cbp = (cbpc & 3) | (cbpy << 2);
4216 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4218 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4219 s->interlaced_dct= get_bits1(&s->gb);
4221 s->mv_dir = MV_DIR_FORWARD;
4222 if ((cbpc & 16) == 0) {
4224 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4225 /* 16x16 global motion prediction */
4226 s->mv_type = MV_TYPE_16X16;
4229 s->mv[0][0][0] = mx;
4230 s->mv[0][0][1] = my;
4231 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4232 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4233 /* 16x8 field motion prediction */
4234 s->mv_type= MV_TYPE_FIELD;
4236 s->field_select[0][0]= get_bits1(&s->gb);
4237 s->field_select[0][1]= get_bits1(&s->gb);
4239 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4242 mx = h263_decode_motion(s, pred_x, s->f_code);
4246 my = h263_decode_motion(s, pred_y/2, s->f_code);
4250 s->mv[0][i][0] = mx;
4251 s->mv[0][i][1] = my;
4254 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4255 /* 16x16 motion prediction */
4256 s->mv_type = MV_TYPE_16X16;
4257 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4258 mx = h263_decode_motion(s, pred_x, s->f_code);
4263 my = h263_decode_motion(s, pred_y, s->f_code);
4267 s->mv[0][0][0] = mx;
4268 s->mv[0][0][1] = my;
4271 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4272 s->mv_type = MV_TYPE_8X8;
4274 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4275 mx = h263_decode_motion(s, pred_x, s->f_code);
4279 my = h263_decode_motion(s, pred_y, s->f_code);
4282 s->mv[0][i][0] = mx;
4283 s->mv[0][i][1] = my;
4288 } else if(s->pict_type==B_TYPE) {
4289 int modb1; // first bit of modb
4290 int modb2; // second bit of modb
4293 s->mb_intra = 0; //B-frames never contain intra blocks
4294 s->mcsel=0; // ... true gmc blocks
4298 s->last_mv[i][0][0]=
4299 s->last_mv[i][0][1]=
4300 s->last_mv[i][1][0]=
4301 s->last_mv[i][1][1]= 0;
4305 /* if we skipped it in the future P Frame than skip it now too */
4306 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4311 s->block_last_index[i] = -1;
4313 s->mv_dir = MV_DIR_FORWARD;
4314 s->mv_type = MV_TYPE_16X16;
4319 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4323 modb1= get_bits1(&s->gb);
4325 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4328 modb2= get_bits1(&s->gb);
4329 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4331 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4334 mb_type= mb_type_b_map[ mb_type ];
4337 s->dsp.clear_blocks(s->block[0]);
4338 cbp= get_bits(&s->gb, 6);
4341 if ((!IS_DIRECT(mb_type)) && cbp) {
4342 if(get_bits1(&s->gb)){
4343 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4347 if(!s->progressive_sequence){
4349 s->interlaced_dct= get_bits1(&s->gb);
4351 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4352 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4353 mb_type &= ~MB_TYPE_16x16;
4355 if(USES_LIST(mb_type, 0)){
4356 s->field_select[0][0]= get_bits1(&s->gb);
4357 s->field_select[0][1]= get_bits1(&s->gb);
4359 if(USES_LIST(mb_type, 1)){
4360 s->field_select[1][0]= get_bits1(&s->gb);
4361 s->field_select[1][1]= get_bits1(&s->gb);
4367 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4368 s->mv_type= MV_TYPE_16X16;
4370 if(USES_LIST(mb_type, 0)){
4371 s->mv_dir = MV_DIR_FORWARD;
4373 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4374 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4375 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4376 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4379 if(USES_LIST(mb_type, 1)){
4380 s->mv_dir |= MV_DIR_BACKWARD;
4382 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4383 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4384 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4385 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4387 }else if(!IS_DIRECT(mb_type)){
4388 s->mv_type= MV_TYPE_FIELD;
4390 if(USES_LIST(mb_type, 0)){
4391 s->mv_dir = MV_DIR_FORWARD;
4394 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4395 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4396 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4397 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4401 if(USES_LIST(mb_type, 1)){
4402 s->mv_dir |= MV_DIR_BACKWARD;
4405 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4406 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4407 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4408 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4414 if(IS_DIRECT(mb_type)){
4415 if(IS_SKIP(mb_type))
4418 mx = h263_decode_motion(s, 0, 1);
4419 my = h263_decode_motion(s, 0, 1);
4422 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4423 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4425 s->current_picture.mb_type[xy]= mb_type;
4426 } else { /* I-Frame */
4428 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4430 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4438 s->ac_pred = get_bits1(&s->gb);
4440 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4442 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4444 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4446 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4449 cbp = (cbpc & 3) | (cbpy << 2);
4451 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4454 if(!s->progressive_sequence)
4455 s->interlaced_dct= get_bits1(&s->gb);
4457 s->dsp.clear_blocks(s->block[0]);
4458 /* decode each block */
4459 for (i = 0; i < 6; i++) {
4460 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4467 /* decode each block */
4468 for (i = 0; i < 6; i++) {
4469 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4475 /* per-MB end of slice check */
4476 if(s->codec_id==CODEC_ID_MPEG4){
4477 if(mpeg4_is_resync(s)){
4478 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4479 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4488 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4490 int code, val, sign, shift, l;
4491 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4498 sign = get_bits1(&s->gb);
4502 val = (val - 1) << shift;
4503 val |= get_bits(&s->gb, shift);
4510 /* modulo decoding */
4511 if (!s->h263_long_vectors) {
4512 l = INT_BIT - 5 - f_code;
4515 /* horrible h263 long vector mode */
4516 if (pred < -31 && val < -63)
4518 if (pred > 32 && val > 63)
4525 /* Decodes RVLC of H.263+ UMV */
4526 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4530 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4533 code = 2 + get_bits1(&s->gb);
4535 while (get_bits1(&s->gb))
4538 code += get_bits1(&s->gb);
4543 code = (sign) ? (pred - code) : (pred + code);
4545 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4551 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4554 int code, level, i, j, last, run;
4555 RLTable *rl = &rl_inter;
4556 const uint8_t *scan_table;
4557 GetBitContext gb= s->gb;
4559 scan_table = s->intra_scantable.permutated;
4560 if (s->h263_aic && s->mb_intra) {
4564 if (s->h263_aic_dir)
4565 scan_table = s->intra_v_scantable.permutated; /* left */
4567 scan_table = s->intra_h_scantable.permutated; /* top */
4569 } else if (s->mb_intra) {
4571 if(s->codec_id == CODEC_ID_RV10){
4572 #ifdef CONFIG_RV10_DECODER
4573 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4574 int component, diff;
4575 component = (n <= 3 ? 0 : n - 4 + 1);
4576 level = s->last_dc[component];
4577 if (s->rv10_first_dc_coded[component]) {
4578 diff = rv_decode_dc(s, n);
4582 level = level & 0xff; /* handle wrap round */
4583 s->last_dc[component] = level;
4585 s->rv10_first_dc_coded[component] = 1;
4588 level = get_bits(&s->gb, 8);
4594 level = get_bits(&s->gb, 8);
4595 if((level&0x7F) == 0){
4596 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4597 if(s->error_resilience >= FF_ER_COMPLIANT)
4609 if (s->mb_intra && s->h263_aic)
4611 s->block_last_index[n] = i - 1;
4616 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4618 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4621 if (code == rl->n) {
4623 if (s->h263_flv > 1) {
4624 int is11 = get_bits1(&s->gb);
4625 last = get_bits1(&s->gb);
4626 run = get_bits(&s->gb, 6);
4628 level = get_sbits(&s->gb, 11);
4630 level = get_sbits(&s->gb, 7);
4633 last = get_bits1(&s->gb);
4634 run = get_bits(&s->gb, 6);
4635 level = (int8_t)get_bits(&s->gb, 8);
4637 if (s->codec_id == CODEC_ID_RV10) {
4638 /* XXX: should patch encoder too */
4639 level = get_sbits(&s->gb, 12);
4641 level = get_bits(&s->gb, 5);
4642 level |= get_sbits(&s->gb, 6)<<5;
4647 run = rl->table_run[code];
4648 level = rl->table_level[code];
4649 last = code >= rl->last;
4650 if (get_bits1(&s->gb))
4655 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4656 //looks like a hack but no, it's the way its supposed to work ...
4660 memset(block, 0, sizeof(DCTELEM)*64);
4663 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4673 if (s->mb_intra && s->h263_aic) {
4674 h263_pred_acdc(s, block, n);
4677 s->block_last_index[n] = i;
4682 * decodes the dc value.
4683 * @param n block index (0-3 are luma, 4-5 are chroma)
4684 * @param dir_ptr the prediction direction will be stored here
4685 * @return the quantized dc
4687 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4692 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4694 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4695 if (code < 0 || code > 9 /* && s->nbit<9 */){
4696 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4704 level= 2*get_bits1(&s->gb)-1;
4706 if(get_bits1(&s->gb))
4707 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4709 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4712 level = get_xbits(&s->gb, code);
4716 if(get_bits1(&s->gb)==0){ /* marker */
4717 if(s->error_resilience>=2){
4718 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4725 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4730 * @return <0 if an error occured
4732 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4733 int n, int coded, int intra, int rvlc)
4735 int level, i, last, run;
4738 RL_VLC_ELEM * rl_vlc;
4739 const uint8_t * scan_table;
4742 //Note intra & rvlc should be optimized away if this is inlined
4745 if(s->qscale < s->intra_dc_threshold){
4747 if(s->partitioned_frame){
4748 level = s->dc_val[0][ s->block_index[n] ];
4749 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4750 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4751 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4753 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4766 rl = &rvlc_rl_intra;
4767 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4770 rl_vlc = rl_intra.rl_vlc[0];
4773 if (dc_pred_dir == 0)
4774 scan_table = s->intra_v_scantable.permutated; /* left */
4776 scan_table = s->intra_h_scantable.permutated; /* top */
4778 scan_table = s->intra_scantable.permutated;
4785 s->block_last_index[n] = i;
4788 if(rvlc) rl = &rvlc_rl_inter;
4789 else rl = &rl_inter;
4791 scan_table = s->intra_scantable.permutated;
4797 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4799 rl_vlc = rl_inter.rl_vlc[0];
4802 qmul = s->qscale << 1;
4803 qadd = (s->qscale - 1) | 1;
4805 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4807 rl_vlc = rl_inter.rl_vlc[s->qscale];
4812 OPEN_READER(re, &s->gb);
4814 UPDATE_CACHE(re, &s->gb);
4815 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4819 if(SHOW_UBITS(re, &s->gb, 1)==0){
4820 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4822 }; SKIP_CACHE(re, &s->gb, 1);
4824 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4825 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4826 SKIP_COUNTER(re, &s->gb, 1+1+6);
4827 UPDATE_CACHE(re, &s->gb);
4829 if(SHOW_UBITS(re, &s->gb, 1)==0){
4830 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4832 }; SKIP_CACHE(re, &s->gb, 1);
4834 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4836 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4837 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4839 }; SKIP_CACHE(re, &s->gb, 5);
4841 level= level * qmul + qadd;
4842 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4843 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4849 cache= GET_CACHE(re, &s->gb);
4852 cache ^= 0xC0000000;
4854 if (cache&0x80000000) {
4855 if (cache&0x40000000) {
4857 SKIP_CACHE(re, &s->gb, 2);
4858 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4859 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4860 SKIP_COUNTER(re, &s->gb, 2+1+6);
4861 UPDATE_CACHE(re, &s->gb);
4864 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4866 if(SHOW_UBITS(re, &s->gb, 1)==0){
4867 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4869 }; SKIP_CACHE(re, &s->gb, 1);
4871 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4873 if(SHOW_UBITS(re, &s->gb, 1)==0){
4874 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4876 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4878 SKIP_COUNTER(re, &s->gb, 1+12+1);
4882 if(s->error_resilience >= FF_ER_COMPLIANT){
4883 const int abs_level= ABS(level);
4884 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4885 const int run1= run - rl->max_run[last][abs_level] - 1;
4886 if(abs_level <= rl->max_level[last][run]){
4887 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4890 if(s->error_resilience > FF_ER_COMPLIANT){
4891 if(abs_level <= rl->max_level[last][run]*2){
4892 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4895 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4896 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4903 if (level>0) level= level * qmul + qadd;
4904 else level= level * qmul - qadd;
4906 if((unsigned)(level + 2048) > 4095){
4907 if(s->error_resilience > FF_ER_COMPLIANT){
4908 if(level > 2560 || level<-2560){
4909 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4913 level= level<0 ? -2048 : 2047;
4920 #if MIN_CACHE_BITS < 20
4921 LAST_SKIP_BITS(re, &s->gb, 2);
4922 UPDATE_CACHE(re, &s->gb);
4924 SKIP_BITS(re, &s->gb, 2);
4926 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4927 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4928 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4929 LAST_SKIP_BITS(re, &s->gb, 1);
4933 #if MIN_CACHE_BITS < 19
4934 LAST_SKIP_BITS(re, &s->gb, 1);
4935 UPDATE_CACHE(re, &s->gb);
4937 SKIP_BITS(re, &s->gb, 1);
4939 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4941 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4942 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4943 LAST_SKIP_BITS(re, &s->gb, 1);
4948 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4949 LAST_SKIP_BITS(re, &s->gb, 1);
4954 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4958 block[scan_table[i]] = level;
4962 block[scan_table[i]] = level;
4964 CLOSE_READER(re, &s->gb);
4968 if(s->qscale >= s->intra_dc_threshold){
4969 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
4974 mpeg4_pred_ac(s, block, n, dc_pred_dir);
4976 i = 63; /* XXX: not optimal */
4979 s->block_last_index[n] = i;
4983 /* most is hardcoded. should extend to handle all h263 streams */
4984 int h263_decode_picture_header(MpegEncContext *s)
4986 int format, width, height, i;
4989 align_get_bits(&s->gb);
4991 startcode= get_bits(&s->gb, 22-8);
4993 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4994 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4996 if(startcode == 0x20)
5000 if (startcode != 0x20) {
5001 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5004 /* temporal reference */
5005 i = get_bits(&s->gb, 8); /* picture timestamp */
5006 if( (s->picture_number&~0xFF)+i < s->picture_number)
5008 s->current_picture_ptr->pts=
5009 s->picture_number= (s->picture_number&~0xFF) + i;
5011 /* PTYPE starts here */
5012 if (get_bits1(&s->gb) != 1) {
5014 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5017 if (get_bits1(&s->gb) != 0) {
5018 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5019 return -1; /* h263 id */
5021 skip_bits1(&s->gb); /* split screen off */
5022 skip_bits1(&s->gb); /* camera off */
5023 skip_bits1(&s->gb); /* freeze picture release off */
5025 format = get_bits(&s->gb, 3);
5030 7 extended PTYPE (PLUSPTYPE)
5033 if (format != 7 && format != 6) {
5036 width = h263_format[format][0];
5037 height = h263_format[format][1];
5041 s->pict_type = I_TYPE + get_bits1(&s->gb);
5043 s->h263_long_vectors = get_bits1(&s->gb);
5045 if (get_bits1(&s->gb) != 0) {
5046 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5047 return -1; /* SAC: off */
5049 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5050 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5052 if (get_bits1(&s->gb) != 0) {
5053 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5054 return -1; /* not PB frame */
5056 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5057 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5061 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5062 s->avctx->time_base= (AVRational){1001, 30000};
5068 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5070 /* ufep other than 0 and 1 are reserved */
5073 format = get_bits(&s->gb, 3);
5074 dprintf("ufep=1, format: %d\n", format);
5075 s->custom_pcf= get_bits1(&s->gb);
5076 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5077 if (get_bits1(&s->gb) != 0) {
5078 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5080 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5081 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5082 s->loop_filter= get_bits1(&s->gb);
5083 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5085 s->h263_slice_structured= get_bits1(&s->gb);
5086 if (get_bits1(&s->gb) != 0) {
5087 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5089 if (get_bits1(&s->gb) != 0) {
5090 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5092 s->alt_inter_vlc= get_bits1(&s->gb);
5093 s->modified_quant= get_bits1(&s->gb);
5094 if(s->modified_quant)
5095 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5097 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5099 skip_bits(&s->gb, 3); /* Reserved */
5100 } else if (ufep != 0) {
5101 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5106 s->pict_type = get_bits(&s->gb, 3);
5107 switch(s->pict_type){
5108 case 0: s->pict_type= I_TYPE;break;
5109 case 1: s->pict_type= P_TYPE;break;
5110 case 3: s->pict_type= B_TYPE;break;
5111 case 7: s->pict_type= I_TYPE;break; //ZYGO
5115 skip_bits(&s->gb, 2);
5116 s->no_rounding = get_bits1(&s->gb);
5117 skip_bits(&s->gb, 4);
5119 /* Get the picture dimensions */
5122 /* Custom Picture Format (CPFMT) */
5123 s->aspect_ratio_info = get_bits(&s->gb, 4);
5124 dprintf("aspect: %d\n", s->aspect_ratio_info);
5129 3 - 10:11 (525-type 4:3)
5130 4 - 16:11 (CIF 16:9)
5131 5 - 40:33 (525-type 16:9)
5134 width = (get_bits(&s->gb, 9) + 1) * 4;
5136 height = get_bits(&s->gb, 9) * 4;
5137 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5138 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5139 /* aspected dimensions */
5140 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5141 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5143 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5146 width = h263_format[format][0];
5147 height = h263_format[format][1];
5148 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5150 if ((width == 0) || (height == 0))
5157 s->avctx->time_base.den= 1800000;
5158 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5159 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5160 if(s->avctx->time_base.num == 0){
5161 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5164 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5165 s->avctx->time_base.den /= gcd;
5166 s->avctx->time_base.num /= gcd;
5167 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5169 s->avctx->time_base= (AVRational){1001, 30000};
5174 skip_bits(&s->gb, 2); //extended Temporal reference
5179 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5182 if(s->h263_slice_structured){
5183 if (get_bits1(&s->gb) != 0) {
5184 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5186 if (get_bits1(&s->gb) != 0) {
5187 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5192 s->qscale = get_bits(&s->gb, 5);
5195 s->mb_width = (s->width + 15) / 16;
5196 s->mb_height = (s->height + 15) / 16;
5197 s->mb_num = s->mb_width * s->mb_height;
5200 while (get_bits1(&s->gb) != 0) {
5201 skip_bits(&s->gb, 8);
5204 if(s->h263_slice_structured){
5205 if (get_bits1(&s->gb) != 1) {
5206 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5210 ff_h263_decode_mba(s);
5212 if (get_bits1(&s->gb) != 1) {
5213 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5220 s->y_dc_scale_table=
5221 s->c_dc_scale_table= ff_aic_dc_scale_table;
5223 s->y_dc_scale_table=
5224 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5227 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5228 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",
5229 s->qscale, av_get_pict_type_char(s->pict_type),
5230 s->gb.size_in_bits, 1-s->no_rounding,
5231 s->obmc ? " AP" : "",
5232 s->umvplus ? " UMV" : "",
5233 s->h263_long_vectors ? " LONG" : "",
5234 s->h263_plus ? " +" : "",
5235 s->h263_aic ? " AIC" : "",
5236 s->alt_inter_vlc ? " AIV" : "",
5237 s->modified_quant ? " MQ" : "",
5238 s->loop_filter ? " LOOP" : "",
5239 s->h263_slice_structured ? " SS" : "",
5240 s->avctx->time_base.den, s->avctx->time_base.num
5244 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5246 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5247 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5248 for(i=0; i<13; i++){
5250 int v= get_bits(&s->gb, 8);
5251 v |= get_sbits(&s->gb, 8)<<8;
5252 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5254 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5256 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5263 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5266 int a= 2<<s->sprite_warping_accuracy;
5267 int rho= 3-s->sprite_warping_accuracy;
5269 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5270 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5271 int sprite_ref[4][2];
5272 int virtual_ref[2][2];
5274 int alpha=0, beta=0;
5279 for(i=0; i<s->num_sprite_warping_points; i++){
5283 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5285 x= get_xbits(gb, length);
5287 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5289 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5291 y=get_xbits(gb, length);
5293 skip_bits1(gb); /* marker bit */
5294 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5299 while((1<<alpha)<w) alpha++;
5300 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5304 // Note, the 4th point isn't used for GMC
5305 if(s->divx_version==500 && s->divx_build==413){
5306 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5307 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5308 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5309 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5310 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5311 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5313 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5314 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5315 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5316 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5317 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5318 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5320 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5321 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5323 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5324 // perhaps it should be reordered to be more readable ...
5325 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5326 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5327 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5328 + 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);
5329 virtual_ref[0][1]= 16*vop_ref[0][1]
5330 + 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);
5331 virtual_ref[1][0]= 16*vop_ref[0][0]
5332 + 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);
5333 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5334 + 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);
5336 switch(s->num_sprite_warping_points)
5339 s->sprite_offset[0][0]= 0;
5340 s->sprite_offset[0][1]= 0;
5341 s->sprite_offset[1][0]= 0;
5342 s->sprite_offset[1][1]= 0;
5343 s->sprite_delta[0][0]= a;
5344 s->sprite_delta[0][1]= 0;
5345 s->sprite_delta[1][0]= 0;
5346 s->sprite_delta[1][1]= a;
5347 s->sprite_shift[0]= 0;
5348 s->sprite_shift[1]= 0;
5351 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5352 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5353 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5354 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5355 s->sprite_delta[0][0]= a;
5356 s->sprite_delta[0][1]= 0;
5357 s->sprite_delta[1][0]= 0;
5358 s->sprite_delta[1][1]= a;
5359 s->sprite_shift[0]= 0;
5360 s->sprite_shift[1]= 0;
5363 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5364 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5365 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5366 + (1<<(alpha+rho-1));
5367 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5368 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5369 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5370 + (1<<(alpha+rho-1));
5371 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5372 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5373 +2*w2*r*sprite_ref[0][0]
5375 + (1<<(alpha+rho+1)));
5376 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5377 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5378 +2*w2*r*sprite_ref[0][1]
5380 + (1<<(alpha+rho+1)));
5381 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5382 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5383 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5384 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5386 s->sprite_shift[0]= alpha+rho;
5387 s->sprite_shift[1]= alpha+rho+2;
5390 min_ab= FFMIN(alpha, beta);
5393 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5394 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5395 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5396 + (1<<(alpha+beta+rho-min_ab-1));
5397 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5398 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5399 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5400 + (1<<(alpha+beta+rho-min_ab-1));
5401 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5402 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5403 + 2*w2*h3*r*sprite_ref[0][0]
5405 + (1<<(alpha+beta+rho-min_ab+1));
5406 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5407 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5408 + 2*w2*h3*r*sprite_ref[0][1]
5410 + (1<<(alpha+beta+rho-min_ab+1));
5411 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5412 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5413 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5414 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5416 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5417 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5420 /* try to simplify the situation */
5421 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5422 && s->sprite_delta[0][1] == 0
5423 && s->sprite_delta[1][0] == 0
5424 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5426 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5427 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5428 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5429 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5430 s->sprite_delta[0][0]= a;
5431 s->sprite_delta[0][1]= 0;
5432 s->sprite_delta[1][0]= 0;
5433 s->sprite_delta[1][1]= a;
5434 s->sprite_shift[0]= 0;
5435 s->sprite_shift[1]= 0;
5436 s->real_sprite_warping_points=1;
5439 int shift_y= 16 - s->sprite_shift[0];
5440 int shift_c= 16 - s->sprite_shift[1];
5441 //printf("shifts %d %d\n", shift_y, shift_c);
5443 s->sprite_offset[0][i]<<= shift_y;
5444 s->sprite_offset[1][i]<<= shift_c;
5445 s->sprite_delta[0][i]<<= shift_y;
5446 s->sprite_delta[1][i]<<= shift_y;
5447 s->sprite_shift[i]= 16;
5449 s->real_sprite_warping_points= s->num_sprite_warping_points;
5452 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5453 vop_ref[0][0], vop_ref[0][1],
5454 vop_ref[1][0], vop_ref[1][1],
5455 vop_ref[2][0], vop_ref[2][1],
5456 sprite_ref[0][0], sprite_ref[0][1],
5457 sprite_ref[1][0], sprite_ref[1][1],
5458 sprite_ref[2][0], sprite_ref[2][1],
5459 virtual_ref[0][0], virtual_ref[0][1],
5460 virtual_ref[1][0], virtual_ref[1][1]
5463 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5464 s->sprite_offset[0][0], s->sprite_offset[0][1],
5465 s->sprite_delta[0][0], s->sprite_delta[0][1],
5466 s->sprite_delta[1][0], s->sprite_delta[1][1],
5472 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5473 int hours, minutes, seconds;
5475 hours= get_bits(gb, 5);
5476 minutes= get_bits(gb, 6);
5478 seconds= get_bits(gb, 6);
5480 s->time_base= seconds + 60*(minutes + 60*hours);
5488 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5489 int width, height, vo_ver_id;
5492 skip_bits(gb, 1); /* random access */
5493 s->vo_type= get_bits(gb, 8);
5494 if (get_bits1(gb) != 0) { /* is_ol_id */
5495 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5496 skip_bits(gb, 3); /* vo_priority */
5500 //printf("vo type:%d\n",s->vo_type);
5501 s->aspect_ratio_info= get_bits(gb, 4);
5502 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5503 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5504 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5506 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5509 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5510 int chroma_format= get_bits(gb, 2);
5511 if(chroma_format!=1){
5512 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5514 s->low_delay= get_bits1(gb);
5515 if(get_bits1(gb)){ /* vbv parameters */
5516 get_bits(gb, 15); /* first_half_bitrate */
5517 skip_bits1(gb); /* marker */
5518 get_bits(gb, 15); /* latter_half_bitrate */
5519 skip_bits1(gb); /* marker */
5520 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5521 skip_bits1(gb); /* marker */
5522 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5523 get_bits(gb, 11); /* first_half_vbv_occupancy */
5524 skip_bits1(gb); /* marker */
5525 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5526 skip_bits1(gb); /* marker */
5529 // set low delay flag only once the smartest? low delay detection won't be overriden
5530 if(s->picture_number==0)
5534 s->shape = get_bits(gb, 2); /* vol shape */
5535 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5536 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5537 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5538 skip_bits(gb, 4); //video_object_layer_shape_extension
5541 check_marker(gb, "before time_increment_resolution");
5543 s->avctx->time_base.den = get_bits(gb, 16);
5544 if(!s->avctx->time_base.den){
5545 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5549 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5550 if (s->time_increment_bits < 1)
5551 s->time_increment_bits = 1;
5553 check_marker(gb, "before fixed_vop_rate");
5555 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5556 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5558 s->avctx->time_base.num = 1;
5562 if (s->shape != BIN_ONLY_SHAPE) {
5563 if (s->shape == RECT_SHAPE) {
5564 skip_bits1(gb); /* marker */
5565 width = get_bits(gb, 13);
5566 skip_bits1(gb); /* marker */
5567 height = get_bits(gb, 13);
5568 skip_bits1(gb); /* marker */
5569 if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5572 // printf("width/height: %d %d\n", width, height);
5576 s->progressive_sequence=
5577 s->progressive_frame= get_bits1(gb)^1;
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;