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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 h263_encode_motion(MpegEncContext * s, int val, int fcode);
60 static void h263p_encode_umotion(MpegEncContext * s, int val);
61 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
62 int n, int dc, uint8_t *scan_table,
63 PutBitContext *dc_pb, PutBitContext *ac_pb);
66 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
67 static int h263p_decode_umotion(MpegEncContext * s, int pred);
68 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
70 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
71 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
72 int n, int coded, int intra, int rvlc);
73 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
74 #ifdef CONFIG_ENCODERS
75 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
76 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
77 #endif //CONFIG_ENCODERS
78 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
79 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
81 #ifdef CONFIG_ENCODERS
82 static uint8_t uni_DCtab_lum_len[512];
83 static uint8_t uni_DCtab_chrom_len[512];
84 static uint16_t uni_DCtab_lum_bits[512];
85 static uint16_t uni_DCtab_chrom_bits[512];
87 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
88 static uint8_t fcode_tab[MAX_MV*2+1];
89 static uint8_t umv_fcode_tab[MAX_MV*2+1];
91 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
92 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
93 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
94 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
95 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
96 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
97 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
110 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit
111 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
116 int h263_get_picture_format(int width, int height)
120 if (width == 128 && height == 96)
122 else if (width == 176 && height == 144)
124 else if (width == 352 && height == 288)
126 else if (width == 704 && height == 576)
128 else if (width == 1408 && height == 1152)
135 #ifdef CONFIG_ENCODERS
137 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
140 if(aspect.num==0) aspect= (AVRational){1,1};
143 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
144 s->aspect_ratio_info=i;
149 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
152 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
156 align_put_bits(&s->pb);
158 put_bits(&s->pb, 17, 1);
159 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
160 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
161 s->avctx->frame_rate) & 0xff); /* TemporalReference */
162 if (s->width == 352 && s->height == 288)
164 else if (s->width == 176 && s->height == 144)
166 else if (s->width == 128 && s->height == 96)
168 else if (s->width == 320 && s->height == 240)
170 else if (s->width == 160 && s->height == 120)
172 else if (s->width <= 255 && s->height <= 255)
173 format = 0; /* use 1 byte width & height */
175 format = 1; /* use 2 bytes width & height */
176 put_bits(&s->pb, 3, format); /* PictureSize */
178 put_bits(&s->pb, 8, s->width);
179 put_bits(&s->pb, 8, s->height);
180 } else if (format == 1) {
181 put_bits(&s->pb, 16, s->width);
182 put_bits(&s->pb, 16, s->height);
184 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
185 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
186 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
187 put_bits(&s->pb, 1, 0); /* ExtraInformation */
191 s->c_dc_scale_table= ff_aic_dc_scale_table;
194 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
198 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
202 align_put_bits(&s->pb);
204 /* Update the pointer to last GOB */
205 s->ptr_lastgob = pbBufPtr(&s->pb);
206 put_bits(&s->pb, 22, 0x20); /* PSC */
207 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
208 s->avctx->frame_rate) & 0xff);
210 put_bits(&s->pb, 1, 1); /* marker */
211 put_bits(&s->pb, 1, 0); /* h263 id */
212 put_bits(&s->pb, 1, 0); /* split screen off */
213 put_bits(&s->pb, 1, 0); /* camera off */
214 put_bits(&s->pb, 1, 0); /* freeze picture release off */
216 format = h263_get_picture_format(s->width, s->height);
219 put_bits(&s->pb, 3, format);
220 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
221 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
222 of H.263v1 UMV implies to check the predicted MV after
223 calculation of the current MB to see if we're on the limits */
224 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
225 put_bits(&s->pb, 1, 0); /* SAC: off */
226 put_bits(&s->pb, 1, s->obmc); /* advanced prediction mode */
227 put_bits(&s->pb, 1, 0); /* not PB frame */
228 put_bits(&s->pb, 5, s->qscale);
229 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
232 /* H.263 Plus PTYPE */
233 put_bits(&s->pb, 3, 7);
234 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
236 put_bits(&s->pb,3,6); /* Custom Source Format */
238 put_bits(&s->pb, 3, format);
240 put_bits(&s->pb,1,0); /* Custom PCF: off */
241 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
242 put_bits(&s->pb,1,0); /* SAC: off */
243 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
244 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
245 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
246 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
247 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
248 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
249 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
250 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
251 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
252 put_bits(&s->pb,3,0); /* Reserved */
254 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
256 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
257 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
258 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
259 put_bits(&s->pb,2,0); /* Reserved */
260 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
262 /* This should be here if PLUSPTYPE */
263 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
266 /* Custom Picture Format (CPFMT) */
267 aspect_to_info(s, s->avctx->sample_aspect_ratio);
269 put_bits(&s->pb,4,s->aspect_ratio_info);
270 put_bits(&s->pb,9,(s->width >> 2) - 1);
271 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
272 put_bits(&s->pb,9,(s->height >> 2));
273 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
274 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
275 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
279 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
281 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
282 //FIXME check actual requested range
283 put_bits(&s->pb,2,1); /* unlimited */
284 if(s->h263_slice_structured)
285 put_bits(&s->pb,2,0); /* no weird submodes */
287 put_bits(&s->pb, 5, s->qscale);
290 put_bits(&s->pb, 1, 0); /* no PEI */
292 if(s->h263_slice_structured){
293 put_bits(&s->pb, 1, 1);
295 assert(s->mb_x == 0 && s->mb_y == 0);
296 ff_h263_encode_mba(s);
298 put_bits(&s->pb, 1, 1);
303 s->c_dc_scale_table= ff_aic_dc_scale_table;
306 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
311 * Encodes a group of blocks header.
313 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
315 put_bits(&s->pb, 17, 1); /* GBSC */
317 if(s->h263_slice_structured){
318 put_bits(&s->pb, 1, 1);
320 ff_h263_encode_mba(s);
323 put_bits(&s->pb, 1, 1);
324 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
325 put_bits(&s->pb, 1, 1);
326 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
328 int gob_number= mb_line / s->gob_index;
330 put_bits(&s->pb, 5, gob_number); /* GN */
331 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
332 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
336 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
341 for(j=1; j<=block_last_index; j++){
342 const int index= scantable[j];
343 int level= block[index];
346 if((level&(~127)) == 0){
347 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
348 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
350 rate += s->ac_esc_length;
360 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
364 int8_t * const qscale_table= s->current_picture.qscale_table;
366 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
369 int16_t *ac_val, *ac_val1;
371 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
373 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
376 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
378 ac_val-= s->block_wrap[n]*16;
379 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
382 const int level= block[n][s->dsp.idct_permutation[i ]];
383 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
384 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
388 /* different qscale, we must rescale */
390 const int level= block[n][s->dsp.idct_permutation[i ]];
391 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
392 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
396 st[n]= s->intra_h_scantable.permutated;
398 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
399 /* left prediction */
401 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
404 const int level= block[n][s->dsp.idct_permutation[i<<3]];
405 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
407 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
410 /* different qscale, we must rescale */
412 const int level= block[n][s->dsp.idct_permutation[i<<3]];
413 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
415 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
418 st[n]= s->intra_v_scantable.permutated;
421 for(i=63; i>0; i--) //FIXME optimize
422 if(block[n][ st[n][i] ]) break;
423 s->block_last_index[n]= i;
425 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
431 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
434 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
437 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
439 st[n]= s->intra_scantable.permutated;
443 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
446 /* left prediction */
448 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
455 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
457 void ff_clean_h263_qscales(MpegEncContext *s){
459 int8_t * const qscale_table= s->current_picture.qscale_table;
461 for(i=1; i<s->mb_num; i++){
462 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
463 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
465 for(i=s->mb_num-2; i>=0; i--){
466 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
467 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
472 * modify mb_type & qscale so that encoding is acually possible in mpeg4
474 void ff_clean_mpeg4_qscales(MpegEncContext *s){
476 int8_t * const qscale_table= s->current_picture.qscale_table;
478 ff_clean_h263_qscales(s);
480 for(i=1; i<s->mb_num; i++){
481 int mb_xy= s->mb_index2xy[i];
483 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
484 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
485 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
489 if(s->pict_type== B_TYPE){
491 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
492 for the actual adaptive quantization */
494 for(i=0; i<s->mb_num; i++){
495 int mb_xy= s->mb_index2xy[i];
496 odd += qscale_table[mb_xy]&1;
499 if(2*odd > s->mb_num) odd=1;
502 for(i=0; i<s->mb_num; i++){
503 int mb_xy= s->mb_index2xy[i];
504 if((qscale_table[mb_xy]&1) != odd)
505 qscale_table[mb_xy]++;
506 if(qscale_table[mb_xy] > 31)
507 qscale_table[mb_xy]= 31;
510 for(i=1; i<s->mb_num; i++){
511 int mb_xy= s->mb_index2xy[i];
512 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
513 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
514 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
520 #endif //CONFIG_ENCODERS
523 * @return the mb_type
525 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
526 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
527 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
528 int xy= s->block_index[0];
529 uint16_t time_pp= s->pp_time;
530 uint16_t time_pb= s->pb_time;
533 //FIXME avoid divides
535 if(IS_8X8(colocated_mb_type)){
536 s->mv_type = MV_TYPE_8X8;
538 xy= s->block_index[i];
539 s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
540 s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
541 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
542 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
543 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1]
544 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
546 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
547 } else if(IS_INTERLACED(colocated_mb_type)){
548 s->mv_type = MV_TYPE_FIELD;
550 if(s->top_field_first){
551 time_pp= s->pp_field_time - s->p_field_select_table[i][mb_index] + i;
552 time_pb= s->pb_field_time - s->p_field_select_table[i][mb_index] + i;
554 time_pp= s->pp_field_time + s->p_field_select_table[i][mb_index] - i;
555 time_pb= s->pb_field_time + s->p_field_select_table[i][mb_index] - i;
557 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
558 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
559 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
560 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
561 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
562 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
564 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
566 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;
567 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;
568 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]
569 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
570 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]
571 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
572 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
573 s->mv_type= MV_TYPE_16X16;
575 s->mv_type= MV_TYPE_8X8;
576 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
580 void ff_h263_update_motion_val(MpegEncContext * s){
581 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
582 //FIXME a lot of thet is only needed for !low_delay
583 const int wrap = s->block_wrap[0];
584 const int xy = s->block_index[0];
586 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
588 if(s->mv_type != MV_TYPE_8X8){
589 int motion_x, motion_y;
593 } else if (s->mv_type == MV_TYPE_16X16) {
594 motion_x = s->mv[0][0][0];
595 motion_y = s->mv[0][0][1];
596 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
598 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
599 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
600 motion_x = (motion_x>>1) | (motion_x&1);
602 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
603 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
604 s->p_field_select_table[i][mb_xy]= s->field_select[0][i];
608 /* no update if 8X8 because it has been done during parsing */
609 s->current_picture.motion_val[0][xy][0] = motion_x;
610 s->current_picture.motion_val[0][xy][1] = motion_y;
611 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
612 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
613 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
614 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
615 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
616 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
619 if(s->encoding){ //FIXME encoding MUST be cleaned up
620 if (s->mv_type == MV_TYPE_8X8)
621 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
623 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
625 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
629 #ifdef CONFIG_ENCODERS
631 static inline int get_p_cbp(MpegEncContext * s,
632 DCTELEM block[6][64],
633 int motion_x, int motion_y){
636 if(s->flags & CODEC_FLAG_CBP_RD){
637 int best_cbpy_score= INT_MAX;
638 int best_cbpc_score= INT_MAX;
639 int cbpc = (-1), cbpy= (-1);
640 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
641 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
644 int score= inter_MCBPC_bits[i + offset] * lambda;
645 if(i&1) score += s->coded_score[5];
646 if(i&2) score += s->coded_score[4];
648 if(score < best_cbpc_score){
649 best_cbpc_score= score;
655 int score= cbpy_tab[i ^ 0xF][1] * lambda;
656 if(i&1) score += s->coded_score[3];
657 if(i&2) score += s->coded_score[2];
658 if(i&4) score += s->coded_score[1];
659 if(i&8) score += s->coded_score[0];
661 if(score < best_cbpy_score){
662 best_cbpy_score= score;
667 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
668 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
672 for (i = 0; i < 6; i++) {
673 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
674 s->block_last_index[i]= -1;
675 memset(s->block[i], 0, sizeof(DCTELEM)*64);
680 for (i = 0; i < 6; i++) {
681 if (s->block_last_index[i] >= 0)
688 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
689 int motion_x, int motion_y, int mb_type){
692 if(s->flags & CODEC_FLAG_CBP_RD){
694 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
697 if(s->coded_score[i] < 0){
698 score += s->coded_score[i];
705 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
706 zero_score-= 4; //2*MV + mb_type + cbp bit
710 if(zero_score <= score){
715 for (i = 0; i < 6; i++) {
716 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
717 s->block_last_index[i]= -1;
718 memset(s->block[i], 0, sizeof(DCTELEM)*64);
722 for (i = 0; i < 6; i++) {
723 if (s->block_last_index[i] >= 0)
730 void mpeg4_encode_mb(MpegEncContext * s,
731 DCTELEM block[6][64],
732 int motion_x, int motion_y)
734 int cbpc, cbpy, pred_x, pred_y;
735 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
736 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
737 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
738 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
739 const int dquant_code[5]= {1,0,9,2,3};
741 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
745 if(s->pict_type==B_TYPE){
746 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
747 int mb_type= mb_type_table[s->mv_dir];
754 s->last_mv[i][1][1]= 0;
758 assert(s->dquant>=-2 && s->dquant<=2);
759 assert((s->dquant&1)==0);
762 /* nothing to do if this MB was skiped in the next P Frame */
763 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
769 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
770 s->qscale -= s->dquant;
776 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
778 if ((cbp | motion_x | motion_y | mb_type) ==0) {
779 /* direct MB with MV={0,0} */
780 assert(s->dquant==0);
782 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
784 if(interleaved_stats){
792 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
793 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
794 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
795 if(cbp) put_bits(&s->pb, 6, cbp);
799 put_bits(&s->pb, 2, (s->dquant>>2)+3);
801 put_bits(&s->pb, 1, 0);
803 s->qscale -= s->dquant;
805 if(!s->progressive_sequence){
807 put_bits(&s->pb, 1, s->interlaced_dct);
808 if(mb_type) // not diect mode
809 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
812 if(interleaved_stats){
813 s->misc_bits+= get_bits_diff(s);
817 assert(s->mv_dir & MV_DIRECT);
818 h263_encode_motion(s, motion_x, 1);
819 h263_encode_motion(s, motion_y, 1);
823 assert(mb_type > 0 && mb_type < 4);
824 if(s->mv_type != MV_TYPE_FIELD){
825 if(s->mv_dir & MV_DIR_FORWARD){
826 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
827 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
828 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
829 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
832 if(s->mv_dir & MV_DIR_BACKWARD){
833 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
834 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
835 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
836 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
840 if(s->mv_dir & MV_DIR_FORWARD){
841 put_bits(&s->pb, 1, s->field_select[0][0]);
842 put_bits(&s->pb, 1, s->field_select[0][1]);
844 if(s->mv_dir & MV_DIR_BACKWARD){
845 put_bits(&s->pb, 1, s->field_select[1][0]);
846 put_bits(&s->pb, 1, s->field_select[1][1]);
848 if(s->mv_dir & MV_DIR_FORWARD){
850 h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code);
851 h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
852 s->last_mv[0][i][0]= s->mv[0][i][0];
853 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
857 if(s->mv_dir & MV_DIR_BACKWARD){
859 h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code);
860 h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
861 s->last_mv[1][i][0]= s->mv[1][i][0];
862 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
869 if(interleaved_stats){
870 s->mv_bits+= get_bits_diff(s);
873 /* encode each block */
874 for (i = 0; i < 6; i++) {
875 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
878 if(interleaved_stats){
879 s->p_tex_bits+= get_bits_diff(s);
882 }else{ /* s->pict_type==B_TYPE */
883 cbp= get_p_cbp(s, block, motion_x, motion_y);
885 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
886 /* check if the B frames can skip it too, as we must skip it if we skip here
887 why didnt they just compress the skip-mb bits instead of reusing them ?! */
888 if(s->max_b_frames>0){
895 if(x+16 > s->width) x= s->width-16;
896 if(y+16 > s->height) y= s->height-16;
898 offset= x + y*s->linesize;
899 p_pic= s->new_picture.data[0] + offset;
902 for(i=0; i<s->max_b_frames; i++){
905 Picture *pic= s->reordered_input_picture[i+1];
907 if(pic==NULL || pic->pict_type!=B_TYPE) break;
909 b_pic= pic->data[0] + offset + 16; //FIXME +16
910 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
911 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
920 /* skip macroblock */
921 put_bits(&s->pb, 1, 1);
923 if(interleaved_stats){
933 put_bits(&s->pb, 1, 0); /* mb coded */
937 if(s->mv_type==MV_TYPE_16X16){
938 if(s->dquant) cbpc+= 8;
940 inter_MCBPC_bits[cbpc],
941 inter_MCBPC_code[cbpc]);
943 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
945 put_bits(pb2, 2, dquant_code[s->dquant+2]);
947 if(!s->progressive_sequence){
949 put_bits(pb2, 1, s->interlaced_dct);
953 if(interleaved_stats){
954 s->misc_bits+= get_bits_diff(s);
957 /* motion vectors: 16x16 mode */
958 h263_pred_motion(s, 0, &pred_x, &pred_y);
960 h263_encode_motion(s, motion_x - pred_x, s->f_code);
961 h263_encode_motion(s, motion_y - pred_y, s->f_code);
962 }else if(s->mv_type==MV_TYPE_FIELD){
963 if(s->dquant) cbpc+= 8;
965 inter_MCBPC_bits[cbpc],
966 inter_MCBPC_code[cbpc]);
968 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
970 put_bits(pb2, 2, dquant_code[s->dquant+2]);
972 assert(!s->progressive_sequence);
974 put_bits(pb2, 1, s->interlaced_dct);
977 if(interleaved_stats){
978 s->misc_bits+= get_bits_diff(s);
981 /* motion vectors: 16x8 interlaced mode */
982 h263_pred_motion(s, 0, &pred_x, &pred_y);
985 put_bits(&s->pb, 1, s->field_select[0][0]);
986 put_bits(&s->pb, 1, s->field_select[0][1]);
988 h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
989 h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
990 h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
991 h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
993 assert(s->mv_type==MV_TYPE_8X8);
995 inter_MCBPC_bits[cbpc+16],
996 inter_MCBPC_code[cbpc+16]);
997 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
999 if(!s->progressive_sequence){
1001 put_bits(pb2, 1, s->interlaced_dct);
1004 if(interleaved_stats){
1005 s->misc_bits+= get_bits_diff(s);
1009 /* motion vectors: 8x8 mode*/
1010 h263_pred_motion(s, i, &pred_x, &pred_y);
1012 h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
1013 h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1017 if(interleaved_stats){
1018 s->mv_bits+= get_bits_diff(s);
1021 /* encode each block */
1022 for (i = 0; i < 6; i++) {
1023 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
1026 if(interleaved_stats){
1027 s->p_tex_bits+= get_bits_diff(s);
1033 int dc_diff[6]; //dc values with the dc prediction subtracted
1034 int dir[6]; //prediction direction
1035 int zigzag_last_index[6];
1036 uint8_t *scan_table[6];
1040 const int level= block[i][0];
1043 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
1045 *dc_ptr = level * s->y_dc_scale;
1047 *dc_ptr = level * s->c_dc_scale;
1051 if(s->flags & CODEC_FLAG_AC_PRED){
1052 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1054 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1057 scan_table[i]= s->intra_scantable.permutated;
1062 for (i = 0; i < 6; i++) {
1063 if (s->block_last_index[i] >= 1)
1064 cbp |= 1 << (5 - i);
1068 if (s->pict_type == I_TYPE) {
1069 if(s->dquant) cbpc+=4;
1071 intra_MCBPC_bits[cbpc],
1072 intra_MCBPC_code[cbpc]);
1074 if(s->dquant) cbpc+=8;
1075 put_bits(&s->pb, 1, 0); /* mb coded */
1077 inter_MCBPC_bits[cbpc + 4],
1078 inter_MCBPC_code[cbpc + 4]);
1080 put_bits(pb2, 1, s->ac_pred);
1082 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1084 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1086 if(!s->progressive_sequence){
1087 put_bits(dc_pb, 1, s->interlaced_dct);
1090 if(interleaved_stats){
1091 s->misc_bits+= get_bits_diff(s);
1094 /* encode each block */
1095 for (i = 0; i < 6; i++) {
1096 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
1099 if(interleaved_stats){
1100 s->i_tex_bits+= get_bits_diff(s);
1104 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1106 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1110 void h263_encode_mb(MpegEncContext * s,
1111 DCTELEM block[6][64],
1112 int motion_x, int motion_y)
1114 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1116 int16_t rec_intradc[6];
1117 uint16_t *dc_ptr[6];
1118 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1119 const int dquant_code[5]= {1,0,9,2,3};
1121 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1124 cbp= get_p_cbp(s, block, motion_x, motion_y);
1126 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1127 /* skip macroblock */
1128 put_bits(&s->pb, 1, 1);
1129 if(interleaved_stats){
1137 put_bits(&s->pb, 1, 0); /* mb coded */
1141 if(s->alt_inter_vlc==0 || cbpc!=3)
1143 if(s->dquant) cbpc+= 8;
1144 if(s->mv_type==MV_TYPE_16X16){
1146 inter_MCBPC_bits[cbpc],
1147 inter_MCBPC_code[cbpc]);
1149 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1151 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1153 if(interleaved_stats){
1154 s->misc_bits+= get_bits_diff(s);
1157 /* motion vectors: 16x16 mode */
1158 h263_pred_motion(s, 0, &pred_x, &pred_y);
1161 h263_encode_motion(s, motion_x - pred_x, 1);
1162 h263_encode_motion(s, motion_y - pred_y, 1);
1165 h263p_encode_umotion(s, motion_x - pred_x);
1166 h263p_encode_umotion(s, motion_y - pred_y);
1167 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1168 /* To prevent Start Code emulation */
1169 put_bits(&s->pb,1,1);
1173 inter_MCBPC_bits[cbpc+16],
1174 inter_MCBPC_code[cbpc+16]);
1175 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1177 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1179 if(interleaved_stats){
1180 s->misc_bits+= get_bits_diff(s);
1184 /* motion vectors: 8x8 mode*/
1185 h263_pred_motion(s, i, &pred_x, &pred_y);
1187 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1188 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1190 h263_encode_motion(s, motion_x - pred_x, 1);
1191 h263_encode_motion(s, motion_y - pred_y, 1);
1194 h263p_encode_umotion(s, motion_x - pred_x);
1195 h263p_encode_umotion(s, motion_y - pred_y);
1196 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1197 /* To prevent Start Code emulation */
1198 put_bits(&s->pb,1,1);
1203 if(interleaved_stats){
1204 s->mv_bits+= get_bits_diff(s);
1207 assert(s->mb_intra);
1212 for(i=0; i<6; i++) {
1213 int16_t level = block[i][0];
1216 if(i<4) scale= s->y_dc_scale;
1217 else scale= s->c_dc_scale;
1219 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1223 level = (level + (scale>>1))/scale;
1225 level = (level - (scale>>1))/scale;
1227 /* AIC can change CBP */
1228 if (level == 0 && s->block_last_index[i] == 0)
1229 s->block_last_index[i] = -1;
1231 if(!s->modified_quant){
1234 else if (level > 127)
1238 block[i][0] = level;
1239 /* Reconstruction */
1240 rec_intradc[i] = scale*level + pred_dc;
1242 rec_intradc[i] |= 1;
1243 //if ((rec_intradc[i] % 2) == 0)
1244 // rec_intradc[i]++;
1246 if (rec_intradc[i] < 0)
1248 else if (rec_intradc[i] > 2047)
1249 rec_intradc[i] = 2047;
1251 /* Update AC/DC tables */
1252 *dc_ptr[i] = rec_intradc[i];
1253 if (s->block_last_index[i] >= 0)
1254 cbp |= 1 << (5 - i);
1257 for(i=0; i<6; i++) {
1259 if (s->block_last_index[i] >= 1)
1260 cbp |= 1 << (5 - i);
1265 if (s->pict_type == I_TYPE) {
1266 if(s->dquant) cbpc+=4;
1268 intra_MCBPC_bits[cbpc],
1269 intra_MCBPC_code[cbpc]);
1271 if(s->dquant) cbpc+=8;
1272 put_bits(&s->pb, 1, 0); /* mb coded */
1274 inter_MCBPC_bits[cbpc + 4],
1275 inter_MCBPC_code[cbpc + 4]);
1278 /* XXX: currently, we do not try to use ac prediction */
1279 put_bits(&s->pb, 1, 0); /* no AC prediction */
1282 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1284 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1286 if(interleaved_stats){
1287 s->misc_bits+= get_bits_diff(s);
1291 for(i=0; i<6; i++) {
1292 /* encode each block */
1293 h263_encode_block(s, block[i], i);
1295 /* Update INTRADC for decoding */
1296 if (s->h263_aic && s->mb_intra) {
1297 block[i][0] = rec_intradc[i];
1302 if(interleaved_stats){
1304 s->p_tex_bits+= get_bits_diff(s);
1307 s->i_tex_bits+= get_bits_diff(s);
1314 void ff_h263_loop_filter(MpegEncContext * s){
1316 const int linesize = s->linesize;
1317 const int uvlinesize= s->uvlinesize;
1318 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1319 uint8_t *dest_y = s->dest[0];
1320 uint8_t *dest_cb= s->dest[1];
1321 uint8_t *dest_cr= s->dest[2];
1323 // if(s->pict_type==B_TYPE && !s->readable) return;
1329 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1331 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1332 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1337 int qp_dt, qp_t, qp_tc;
1339 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1342 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1350 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1351 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1352 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1354 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1355 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1359 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1362 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1365 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1368 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1369 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1370 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1371 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1377 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1378 if(s->mb_y + 1 == s->mb_height)
1379 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1384 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1387 qp_lc= s->current_picture.qscale_table[xy-1];
1390 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1391 if(s->mb_y + 1 == s->mb_height){
1392 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1393 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1394 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1395 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1401 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1403 int x, y, wrap, a, c, pred_dc, scale;
1404 int16_t *dc_val, *ac_val;
1406 /* find prediction */
1408 x = 2 * s->mb_x + 1 + (n & 1);
1409 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1410 wrap = s->mb_width * 2 + 2;
1411 dc_val = s->dc_val[0];
1412 ac_val = s->ac_val[0][0];
1413 scale = s->y_dc_scale;
1417 wrap = s->mb_width + 2;
1418 dc_val = s->dc_val[n - 4 + 1];
1419 ac_val = s->ac_val[n - 4 + 1][0];
1420 scale = s->c_dc_scale;
1425 a = dc_val[(x - 1) + (y) * wrap];
1426 c = dc_val[(x) + (y - 1) * wrap];
1428 /* No prediction outside GOB boundary */
1429 if (s->first_slice_line && ((n < 2) || (n > 3)))
1432 /* just DC prediction */
1433 if (a != 1024 && c != 1024)
1434 pred_dc = (a + c) >> 1;
1440 /* we assume pred is positive */
1441 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1442 *dc_val_ptr = &dc_val[x + y * wrap];
1446 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1448 int x, y, wrap, a, c, pred_dc, scale, i;
1449 int16_t *dc_val, *ac_val, *ac_val1;
1451 /* find prediction */
1453 x = 2 * s->mb_x + 1 + (n & 1);
1454 y = 2 * s->mb_y + 1 + (n>> 1);
1455 wrap = s->mb_width * 2 + 2;
1456 dc_val = s->dc_val[0];
1457 ac_val = s->ac_val[0][0];
1458 scale = s->y_dc_scale;
1462 wrap = s->mb_width + 2;
1463 dc_val = s->dc_val[n - 4 + 1];
1464 ac_val = s->ac_val[n - 4 + 1][0];
1465 scale = s->c_dc_scale;
1468 ac_val += ((y) * wrap + (x)) * 16;
1474 a = dc_val[(x - 1) + (y) * wrap];
1475 c = dc_val[(x) + (y - 1) * wrap];
1477 /* No prediction outside GOB boundary */
1478 if(s->first_slice_line && n!=3){
1480 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1485 if (s->h263_aic_dir) {
1486 /* left prediction */
1490 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1495 /* top prediction */
1497 ac_val -= 16 * wrap;
1499 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1505 /* just DC prediction */
1506 if (a != 1024 && c != 1024)
1507 pred_dc = (a + c) >> 1;
1514 /* we assume pred is positive */
1515 block[0]=block[0]*scale + pred_dc;
1522 /* Update AC/DC tables */
1523 dc_val[(x) + (y) * wrap] = block[0];
1527 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1530 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1533 int16_t *h263_pred_motion(MpegEncContext * s, int block,
1537 int16_t *A, *B, *C, *mot_val;
1538 static const int off[4]= {2, 1, 1, -1};
1540 wrap = s->block_wrap[0];
1541 xy = s->block_index[block];
1543 mot_val = s->current_picture.motion_val[0][xy];
1545 A = s->current_picture.motion_val[0][xy - 1];
1546 /* special case for first (slice) line */
1547 if (s->first_slice_line && block<3) {
1548 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1549 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1550 if(block==0){ //most common case
1551 if(s->mb_x == s->resync_mb_x){ //rare
1553 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1554 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1559 *px = mid_pred(A[0], 0, C[0]);
1560 *py = mid_pred(A[1], 0, C[1]);
1567 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1568 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1569 *px = mid_pred(A[0], 0, C[0]);
1570 *py = mid_pred(A[1], 0, C[1]);
1575 }else{ /* block==2*/
1576 B = s->current_picture.motion_val[0][xy - wrap];
1577 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1578 if(s->mb_x == s->resync_mb_x) //rare
1581 *px = mid_pred(A[0], B[0], C[0]);
1582 *py = mid_pred(A[1], B[1], C[1]);
1585 B = s->current_picture.motion_val[0][xy - wrap];
1586 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
1587 *px = mid_pred(A[0], B[0], C[0]);
1588 *py = mid_pred(A[1], B[1], C[1]);
1593 // identical to above but with s->current_picture->motion_val, the above one will be removed, and this renamed to it
1594 int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir,
1598 int16_t *A, *B, *C, (*mot_val)[2];
1599 static const int off[4]= {2, 1, 1, -1};
1601 wrap = s->b8_stride;
1602 xy = 2*(s->mb_x + s->mb_y * wrap);
1604 mot_val = s->current_picture.motion_val[dir] + xy;
1607 /* special case for first (slice) line */
1608 if (s->first_slice_line && block<3) {
1609 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1610 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1611 if(block==0){ //most common case
1612 if(s->mb_x == s->resync_mb_x){ //rare
1614 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1615 C = mot_val[off[block] - wrap];
1620 *px = mid_pred(A[0], 0, C[0]);
1621 *py = mid_pred(A[1], 0, C[1]);
1628 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1629 C = mot_val[off[block] - wrap];
1630 *px = mid_pred(A[0], 0, C[0]);
1631 *py = mid_pred(A[1], 0, C[1]);
1636 }else{ /* block==2*/
1637 B = mot_val[ - wrap];
1638 C = mot_val[off[block] - wrap];
1639 if(s->mb_x == s->resync_mb_x) //rare
1642 *px = mid_pred(A[0], B[0], C[0]);
1643 *py = mid_pred(A[1], B[1], C[1]);
1646 B = mot_val[ - wrap];
1647 C = mot_val[off[block] - wrap];
1648 *px = mid_pred(A[0], B[0], C[0]);
1649 *py = mid_pred(A[1], B[1], C[1]);
1654 #ifdef CONFIG_ENCODERS
1655 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1657 int range, l, bit_size, sign, code, bits;
1662 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1664 bit_size = f_code - 1;
1665 range = 1 << bit_size;
1666 /* modulo encoding */
1673 val= (val^sign)-sign;
1678 } else if (val >= l) {
1682 assert(val>=-l && val<l);
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);
1703 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1704 static void h263p_encode_umotion(MpegEncContext * s, int val)
1714 put_bits(&s->pb, 1, 1);
1716 put_bits(&s->pb, 3, 0);
1718 put_bits(&s->pb, 3, 2);
1721 sval = ((val < 0) ? (short)(-val):(short)val);
1724 while (temp_val != 0) {
1725 temp_val = temp_val >> 1;
1731 tcode = (sval & (1 << (i-1))) >> (i-1);
1732 tcode = (tcode << 1) | 1;
1733 code = (code << 2) | tcode;
1736 code = ((code << 1) | (val < 0)) << 1;
1737 put_bits(&s->pb, (2*n_bits)+1, code);
1738 //printf("\nVal = %d\tCode = %d", sval, code);
1742 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1747 if(mv_penalty==NULL)
1748 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1750 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1751 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1754 if(mv==0) len= mvtab[0][1];
1756 int val, bit_size, range, code;
1758 bit_size = s->f_code - 1;
1759 range = 1 << bit_size;
1765 code = (val >> bit_size) + 1;
1767 len= mvtab[code][1] + 1 + bit_size;
1769 len= mvtab[32][1] + 2 + bit_size;
1773 mv_penalty[f_code][mv+MAX_MV]= len;
1777 for(f_code=MAX_FCODE; f_code>0; f_code--){
1778 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1779 fcode_tab[mv+MAX_MV]= f_code;
1783 for(mv=0; mv<MAX_MV*2+1; mv++){
1784 umv_fcode_tab[mv]= 1;
1789 #ifdef CONFIG_ENCODERS
1791 static void init_uni_dc_tab(void)
1793 int level, uni_code, uni_len;
1795 for(level=-256; level<256; level++){
1797 /* find number of bits */
1806 l= (-level) ^ ((1 << size) - 1);
1811 uni_code= DCtab_lum[size][0];
1812 uni_len = DCtab_lum[size][1];
1815 uni_code<<=size; uni_code|=l;
1818 uni_code<<=1; uni_code|=1;
1822 uni_DCtab_lum_bits[level+256]= uni_code;
1823 uni_DCtab_lum_len [level+256]= uni_len;
1826 uni_code= DCtab_chrom[size][0];
1827 uni_len = DCtab_chrom[size][1];
1830 uni_code<<=size; uni_code|=l;
1833 uni_code<<=1; uni_code|=1;
1837 uni_DCtab_chrom_bits[level+256]= uni_code;
1838 uni_DCtab_chrom_len [level+256]= uni_len;
1843 #endif //CONFIG_ENCODERS
1845 #ifdef CONFIG_ENCODERS
1846 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1847 int slevel, run, last;
1849 assert(MAX_LEVEL >= 64);
1850 assert(MAX_RUN >= 63);
1852 for(slevel=-64; slevel<64; slevel++){
1853 if(slevel==0) continue;
1854 for(run=0; run<64; run++){
1855 for(last=0; last<=1; last++){
1856 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1857 int level= slevel < 0 ? -slevel : slevel;
1858 int sign= slevel < 0 ? 1 : 0;
1859 int bits, len, code;
1862 len_tab[index]= 100;
1865 code= get_rl_index(rl, last, run, level);
1866 bits= rl->table_vlc[code][0];
1867 len= rl->table_vlc[code][1];
1868 bits=bits*2+sign; len++;
1870 if(code!=rl->n && len < len_tab[index]){
1871 bits_tab[index]= bits;
1872 len_tab [index]= len;
1876 bits= rl->table_vlc[rl->n][0];
1877 len= rl->table_vlc[rl->n][1];
1878 bits=bits*2; len++; //esc1
1879 level1= level - rl->max_level[last][run];
1881 code= get_rl_index(rl, last, run, level1);
1882 bits<<= rl->table_vlc[code][1];
1883 len += rl->table_vlc[code][1];
1884 bits += rl->table_vlc[code][0];
1885 bits=bits*2+sign; len++;
1887 if(code!=rl->n && len < len_tab[index]){
1888 bits_tab[index]= bits;
1889 len_tab [index]= len;
1895 bits= rl->table_vlc[rl->n][0];
1896 len= rl->table_vlc[rl->n][1];
1897 bits=bits*4+2; len+=2; //esc2
1898 run1 = run - rl->max_run[last][level] - 1;
1900 code= get_rl_index(rl, last, run1, level);
1901 bits<<= rl->table_vlc[code][1];
1902 len += rl->table_vlc[code][1];
1903 bits += rl->table_vlc[code][0];
1904 bits=bits*2+sign; len++;
1906 if(code!=rl->n && len < len_tab[index]){
1907 bits_tab[index]= bits;
1908 len_tab [index]= len;
1913 bits= rl->table_vlc[rl->n][0];
1914 len = rl->table_vlc[rl->n][1];
1915 bits=bits*4+3; len+=2; //esc3
1916 bits=bits*2+last; len++;
1917 bits=bits*64+run; len+=6;
1918 bits=bits*2+1; len++; //marker
1919 bits=bits*4096+(slevel&0xfff); len+=12;
1920 bits=bits*2+1; len++; //marker
1922 if(len < len_tab[index]){
1923 bits_tab[index]= bits;
1924 len_tab [index]= len;
1931 void h263_encode_init(MpegEncContext *s)
1933 static int done = 0;
1942 init_rl(&rl_intra_aic);
1944 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1945 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1947 init_mv_penalty_and_fcode(s);
1949 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1951 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1952 switch(s->codec_id){
1953 case CODEC_ID_MPEG4:
1954 s->fcode_tab= fcode_tab;
1955 s->min_qcoeff= -2048;
1956 s->max_qcoeff= 2047;
1957 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
1958 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1959 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
1960 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1961 s->luma_dc_vlc_length= uni_DCtab_lum_len;
1962 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1963 s->ac_esc_length= 7+2+1+6+1+12+1;
1965 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1967 s->avctx->extradata= av_malloc(1024);
1968 init_put_bits(&s->pb, s->avctx->extradata, 1024);
1970 mpeg4_encode_visual_object_header(s);
1971 mpeg4_encode_vol_header(s, 0, 0);
1973 // ff_mpeg4_stuffing(&s->pb); ?
1974 flush_put_bits(&s->pb);
1975 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1979 case CODEC_ID_H263P:
1981 s->fcode_tab= umv_fcode_tab;
1982 if(s->modified_quant){
1983 s->min_qcoeff= -2047;
1984 s->max_qcoeff= 2047;
1986 s->min_qcoeff= -127;
1990 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1992 if (s->h263_flv > 1) {
1993 s->min_qcoeff= -1023;
1994 s->max_qcoeff= 1023;
1996 s->min_qcoeff= -127;
1999 s->y_dc_scale_table=
2000 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2002 default: //nothing needed default table allready set in mpegvideo.c
2003 s->min_qcoeff= -127;
2005 s->y_dc_scale_table=
2006 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2011 * encodes a 8x8 block.
2012 * @param block the 8x8 block
2013 * @param n block index (0-3 are luma, 4-5 are chroma)
2015 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2017 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2021 if (s->mb_intra && !s->h263_aic) {
2024 /* 255 cannot be represented, so we clamp */
2029 /* 0 cannot be represented also */
2030 else if (level < 1) {
2034 if (level == 128) //FIXME check rv10
2035 put_bits(&s->pb, 8, 0xff);
2037 put_bits(&s->pb, 8, level);
2041 if (s->h263_aic && s->mb_intra)
2044 if(s->alt_inter_vlc && !s->mb_intra){
2046 int inter_vlc_bits=0;
2050 last_index = s->block_last_index[n];
2051 last_non_zero = i - 1;
2052 for (; i <= last_index; i++) {
2053 j = s->intra_scantable.permutated[i];
2056 run = i - last_non_zero - 1;
2057 last = (i == last_index);
2059 if(level<0) level= -level;
2061 code = get_rl_index(rl, last, run, level);
2062 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2063 inter_vlc_bits += rl->table_vlc[code][1]+1;
2064 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2066 if (code == rl->n) {
2067 inter_vlc_bits += 1+6+8-1;
2069 if (aic_code == rl_intra_aic.n) {
2070 aic_vlc_bits += 1+6+8-1;
2071 wrong_pos += run + 1;
2073 wrong_pos += wrong_run[aic_code];
2078 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2084 last_index = s->block_last_index[n];
2085 last_non_zero = i - 1;
2086 for (; i <= last_index; i++) {
2087 j = s->intra_scantable.permutated[i];
2090 run = i - last_non_zero - 1;
2091 last = (i == last_index);
2098 code = get_rl_index(rl, last, run, level);
2099 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2100 if (code == rl->n) {
2101 if(s->h263_flv <= 1){
2102 put_bits(&s->pb, 1, last);
2103 put_bits(&s->pb, 6, run);
2105 assert(slevel != 0);
2108 put_bits(&s->pb, 8, slevel & 0xff);
2110 put_bits(&s->pb, 8, 128);
2111 put_bits(&s->pb, 5, slevel & 0x1f);
2112 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2115 if(level < 64) { // 7-bit level
2116 put_bits(&s->pb, 1, 0);
2117 put_bits(&s->pb, 1, last);
2118 put_bits(&s->pb, 6, run);
2120 put_bits(&s->pb, 7, slevel & 0x7f);
2123 put_bits(&s->pb, 1, 1);
2124 put_bits(&s->pb, 1, last);
2125 put_bits(&s->pb, 6, run);
2127 put_bits(&s->pb, 11, slevel & 0x7ff);
2131 put_bits(&s->pb, 1, sign);
2139 #ifdef CONFIG_ENCODERS
2141 /***************************************************/
2143 * add mpeg4 stuffing bits (01...1)
2145 void ff_mpeg4_stuffing(PutBitContext * pbc)
2148 put_bits(pbc, 1, 0);
2149 length= (-put_bits_count(pbc))&7;
2150 if(length) put_bits(pbc, length, (1<<length)-1);
2153 /* must be called before writing the header */
2154 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2155 int time_div, time_mod;
2157 if(s->current_picture_ptr->pts)
2158 s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
2160 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
2161 time_div= s->time/s->time_increment_resolution;
2162 time_mod= s->time%s->time_increment_resolution;
2164 if(s->pict_type==B_TYPE){
2165 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2167 s->last_time_base= s->time_base;
2168 s->time_base= time_div;
2169 s->pp_time= s->time - s->last_non_b_time;
2170 s->last_non_b_time= s->time;
2174 static void mpeg4_encode_gop_header(MpegEncContext * s){
2175 int hours, minutes, seconds;
2178 put_bits(&s->pb, 16, 0);
2179 put_bits(&s->pb, 16, GOP_STARTCODE);
2181 if(s->current_picture_ptr->pts && s->reordered_input_picture[1]){
2182 time= FFMIN(s->reordered_input_picture[1]->pts, s->current_picture_ptr->pts);
2183 time= (time*s->time_increment_resolution + 500*1000)/(1000*1000);
2185 time= av_rescale(s->current_picture_ptr->coded_picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
2187 seconds= time/s->time_increment_resolution;
2188 minutes= seconds/60; seconds %= 60;
2189 hours= minutes/60; minutes %= 60;
2192 put_bits(&s->pb, 5, hours);
2193 put_bits(&s->pb, 6, minutes);
2194 put_bits(&s->pb, 1, 1);
2195 put_bits(&s->pb, 6, seconds);
2197 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2198 put_bits(&s->pb, 1, 0); //broken link == NO
2200 s->last_time_base= time / s->time_increment_resolution;
2202 ff_mpeg4_stuffing(&s->pb);
2205 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2206 int profile_and_level_indication;
2209 if(s->max_b_frames || s->quarter_sample){
2210 profile_and_level_indication= 0xF1; // adv simple level 1
2213 profile_and_level_indication= 0x01; // simple level 1
2218 put_bits(&s->pb, 16, 0);
2219 put_bits(&s->pb, 16, VOS_STARTCODE);
2221 put_bits(&s->pb, 8, profile_and_level_indication);
2223 put_bits(&s->pb, 16, 0);
2224 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2226 put_bits(&s->pb, 1, 1);
2227 put_bits(&s->pb, 4, vo_ver_id);
2228 put_bits(&s->pb, 3, 1); //priority
2230 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2232 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2234 ff_mpeg4_stuffing(&s->pb);
2237 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2241 if(s->max_b_frames || s->quarter_sample){
2243 s->vo_type= ADV_SIMPLE_VO_TYPE;
2246 s->vo_type= SIMPLE_VO_TYPE;
2249 put_bits(&s->pb, 16, 0);
2250 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2251 put_bits(&s->pb, 16, 0);
2252 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2254 put_bits(&s->pb, 1, 0); /* random access vol */
2255 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2256 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2257 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2258 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2260 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2262 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2263 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2264 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2265 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2269 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2270 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2271 put_bits(&s->pb, 1, s->low_delay);
2272 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2274 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
2277 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2278 put_bits(&s->pb, 1, 1); /* marker bit */
2280 put_bits(&s->pb, 16, s->time_increment_resolution);
2281 if (s->time_increment_bits < 1)
2282 s->time_increment_bits = 1;
2283 put_bits(&s->pb, 1, 1); /* marker bit */
2284 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2285 put_bits(&s->pb, 1, 1); /* marker bit */
2286 put_bits(&s->pb, 13, s->width); /* vol width */
2287 put_bits(&s->pb, 1, 1); /* marker bit */
2288 put_bits(&s->pb, 13, s->height); /* vol height */
2289 put_bits(&s->pb, 1, 1); /* marker bit */
2290 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2291 put_bits(&s->pb, 1, 1); /* obmc disable */
2292 if (vo_ver_id == 1) {
2293 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
2295 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
2298 s->quant_precision=5;
2299 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2300 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2303 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2304 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2308 put_bits(&s->pb, 1, s->quarter_sample);
2309 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2310 s->resync_marker= s->rtp_mode;
2311 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2312 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2313 if(s->data_partitioning){
2314 put_bits(&s->pb, 1, 0); /* no rvlc */
2317 if (vo_ver_id != 1){
2318 put_bits(&s->pb, 1, 0); /* newpred */
2319 put_bits(&s->pb, 1, 0); /* reduced res vop */
2321 put_bits(&s->pb, 1, 0); /* scalability */
2323 ff_mpeg4_stuffing(&s->pb);
2326 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2327 put_bits(&s->pb, 16, 0);
2328 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2329 put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2333 /* write mpeg4 VOP header */
2334 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2337 int time_div, time_mod;
2339 if(s->pict_type==I_TYPE){
2340 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2341 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2342 mpeg4_encode_visual_object_header(s);
2343 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2344 mpeg4_encode_vol_header(s, 0, 0);
2346 mpeg4_encode_gop_header(s);
2349 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2351 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2353 put_bits(&s->pb, 16, 0); /* vop header */
2354 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2355 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2357 time_div= s->time/s->time_increment_resolution;
2358 time_mod= s->time%s->time_increment_resolution;
2359 time_incr= time_div - s->last_time_base;
2361 put_bits(&s->pb, 1, 1);
2363 put_bits(&s->pb, 1, 0);
2365 put_bits(&s->pb, 1, 1); /* marker */
2366 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2367 put_bits(&s->pb, 1, 1); /* marker */
2368 put_bits(&s->pb, 1, 1); /* vop coded */
2369 if ( s->pict_type == P_TYPE
2370 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2371 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2373 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2374 if(!s->progressive_sequence){
2375 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2376 put_bits(&s->pb, 1, s->alternate_scan);
2378 //FIXME sprite stuff
2380 put_bits(&s->pb, 5, s->qscale);
2382 if (s->pict_type != I_TYPE)
2383 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2384 if (s->pict_type == B_TYPE)
2385 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2386 // printf("****frame %d\n", picture_number);
2388 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
2389 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2392 #endif //CONFIG_ENCODERS
2395 * set qscale and update qscale dependant variables.
2397 void ff_set_qscale(MpegEncContext * s, int qscale)
2401 else if (qscale > 31)
2405 s->chroma_qscale= s->chroma_qscale_table[qscale];
2407 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2408 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2413 * @param n block index (0-3 are luma, 4-5 are chroma)
2414 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
2415 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2416 * @return the quantized predicted dc
2418 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2420 int a, b, c, wrap, pred, scale;
2423 /* find prediction */
2425 scale = s->y_dc_scale;
2427 scale = s->c_dc_scale;
2432 wrap= s->block_wrap[n];
2433 dc_val = s->dc_val[0] + s->block_index[n];
2439 b = dc_val[ - 1 - wrap];
2440 c = dc_val[ - wrap];
2442 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2443 if(s->first_slice_line && n!=3){
2445 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2447 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2448 if(n==0 || n==4 || n==5)
2452 if (abs(a - b) < abs(b - c)) {
2454 *dir_ptr = 1; /* top */
2457 *dir_ptr = 0; /* left */
2459 /* we assume pred is positive */
2460 pred = FASTDIV((pred + (scale >> 1)), scale);
2462 /* prepare address for prediction update */
2463 *dc_val_ptr = &dc_val[0];
2470 * @param n block index (0-3 are luma, 4-5 are chroma)
2471 * @param dir the ac prediction direction
2473 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2477 int16_t *ac_val, *ac_val1;
2478 int8_t * const qscale_table= s->current_picture.qscale_table;
2480 /* find prediction */
2481 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2485 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2486 /* left prediction */
2489 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2492 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2495 /* different qscale, we must rescale */
2497 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2501 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2502 /* top prediction */
2503 ac_val -= 16 * s->block_wrap[n];
2505 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2508 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2511 /* different qscale, we must rescale */
2513 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2520 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2524 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2528 #ifdef CONFIG_ENCODERS
2531 * encodes the dc value.
2532 * @param n block index (0-3 are luma, 4-5 are chroma)
2534 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2537 // if(level<-255 || level>255) printf("dc overflow\n");
2541 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2544 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2548 /* find number of bits */
2558 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2561 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2564 /* encode remaining bits */
2567 level = (-level) ^ ((1 << size) - 1);
2568 put_bits(&s->pb, size, level);
2570 put_bits(&s->pb, 1, 1);
2576 * encodes a 8x8 block
2577 * @param n block index (0-3 are luma, 4-5 are chroma)
2579 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2580 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2582 int i, last_non_zero;
2583 #if 0 //variables for the outcommented version
2584 int code, sign, last;
2589 const int last_index = s->block_last_index[n];
2591 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2592 /* mpeg4 based DC predictor */
2593 mpeg4_encode_dc(dc_pb, intra_dc, n);
2594 if(last_index<1) return;
2597 bits_tab= uni_mpeg4_intra_rl_bits;
2598 len_tab = uni_mpeg4_intra_rl_len;
2600 if(last_index<0) return;
2603 bits_tab= uni_mpeg4_inter_rl_bits;
2604 len_tab = uni_mpeg4_inter_rl_len;
2608 last_non_zero = i - 1;
2610 for (; i < last_index; i++) {
2611 int level = block[ scan_table[i] ];
2613 int run = i - last_non_zero - 1;
2615 if((level&(~127)) == 0){
2616 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2617 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2619 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);
2624 /*if(i<=last_index)*/{
2625 int level = block[ scan_table[i] ];
2626 int run = i - last_non_zero - 1;
2628 if((level&(~127)) == 0){
2629 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2630 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2632 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);
2636 for (; i <= last_index; i++) {
2637 const int slevel = block[ scan_table[i] ];
2640 int run = i - last_non_zero - 1;
2641 last = (i == last_index);
2648 code = get_rl_index(rl, last, run, level);
2649 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2650 if (code == rl->n) {
2652 level1 = level - rl->max_level[last][run];
2655 code = get_rl_index(rl, last, run, level1);
2656 if (code == rl->n) {
2658 put_bits(ac_pb, 1, 1);
2659 if (level > MAX_LEVEL)
2661 run1 = run - rl->max_run[last][level] - 1;
2664 code = get_rl_index(rl, last, run1, level);
2665 if (code == rl->n) {
2668 put_bits(ac_pb, 1, 1);
2669 put_bits(ac_pb, 1, last);
2670 put_bits(ac_pb, 6, run);
2671 put_bits(ac_pb, 1, 1);
2672 put_bits(ac_pb, 12, slevel & 0xfff);
2673 put_bits(ac_pb, 1, 1);
2676 put_bits(ac_pb, 1, 0);
2677 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2678 put_bits(ac_pb, 1, sign);
2682 put_bits(ac_pb, 1, 0);
2683 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2684 put_bits(ac_pb, 1, sign);
2687 put_bits(ac_pb, 1, sign);
2695 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2696 uint8_t *scan_table)
2698 int i, last_non_zero;
2701 const int last_index = s->block_last_index[n];
2704 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2705 /* mpeg4 based DC predictor */
2706 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2707 if(last_index<1) return len;
2710 len_tab = uni_mpeg4_intra_rl_len;
2712 if(last_index<0) return 0;
2715 len_tab = uni_mpeg4_inter_rl_len;
2719 last_non_zero = i - 1;
2720 for (; i < last_index; i++) {
2721 int level = block[ scan_table[i] ];
2723 int run = i - last_non_zero - 1;
2725 if((level&(~127)) == 0){
2726 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2727 len += len_tab[index];
2729 len += 7+2+1+6+1+12+1;
2734 /*if(i<=last_index)*/{
2735 int level = block[ scan_table[i] ];
2736 int run = i - last_non_zero - 1;
2738 if((level&(~127)) == 0){
2739 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2740 len += len_tab[index];
2742 len += 7+2+1+6+1+12+1;
2752 /***********************************************/
2755 static VLC intra_MCBPC_vlc;
2756 static VLC inter_MCBPC_vlc;
2757 static VLC cbpy_vlc;
2759 static VLC dc_lum, dc_chrom;
2760 static VLC sprite_trajectory;
2761 static VLC mb_type_b_vlc;
2762 static VLC h263_mbtype_b_vlc;
2763 static VLC cbpc_b_vlc;
2765 void init_vlc_rl(RLTable *rl)
2769 init_vlc(&rl->vlc, 9, rl->n + 1,
2770 &rl->table_vlc[0][1], 4, 2,
2771 &rl->table_vlc[0][0], 4, 2);
2774 for(q=0; q<32; q++){
2783 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2784 for(i=0; i<rl->vlc.table_size; i++){
2785 int code= rl->vlc.table[i][0];
2786 int len = rl->vlc.table[i][1];
2789 if(len==0){ // illegal code
2792 }else if(len<0){ //more bits needed
2796 if(code==rl->n){ //esc
2800 run= rl->table_run [code] + 1;
2801 level= rl->table_level[code] * qmul + qadd;
2802 if(code >= rl->last) run+=192;
2805 rl->rl_vlc[q][i].len= len;
2806 rl->rl_vlc[q][i].level= level;
2807 rl->rl_vlc[q][i].run= run;
2814 /* XXX: find a better solution to handle static init */
2815 void h263_decode_init_vlc(MpegEncContext *s)
2817 static int done = 0;
2822 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2823 intra_MCBPC_bits, 1, 1,
2824 intra_MCBPC_code, 1, 1);
2825 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2826 inter_MCBPC_bits, 1, 1,
2827 inter_MCBPC_code, 1, 1);
2828 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2829 &cbpy_tab[0][1], 2, 1,
2830 &cbpy_tab[0][0], 2, 1);
2831 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2833 &mvtab[0][0], 2, 1);
2836 init_rl(&rvlc_rl_inter);
2837 init_rl(&rvlc_rl_intra);
2838 init_rl(&rl_intra_aic);
2839 init_vlc_rl(&rl_inter);
2840 init_vlc_rl(&rl_intra);
2841 init_vlc_rl(&rvlc_rl_inter);
2842 init_vlc_rl(&rvlc_rl_intra);
2843 init_vlc_rl(&rl_intra_aic);
2844 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2845 &DCtab_lum[0][1], 2, 1,
2846 &DCtab_lum[0][0], 2, 1);
2847 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2848 &DCtab_chrom[0][1], 2, 1,
2849 &DCtab_chrom[0][0], 2, 1);
2850 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2851 &sprite_trajectory_tab[0][1], 4, 2,
2852 &sprite_trajectory_tab[0][0], 4, 2);
2853 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2854 &mb_type_b_tab[0][1], 2, 1,
2855 &mb_type_b_tab[0][0], 2, 1);
2856 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2857 &h263_mbtype_b_tab[0][1], 2, 1,
2858 &h263_mbtype_b_tab[0][0], 2, 1);
2859 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2860 &cbpc_b_tab[0][1], 2, 1,
2861 &cbpc_b_tab[0][0], 2, 1);
2866 * Get the GOB height based on picture height.
2868 int ff_h263_get_gob_height(MpegEncContext *s){
2869 if (s->height <= 400)
2871 else if (s->height <= 800)
2877 int ff_h263_decode_mba(MpegEncContext *s)
2882 if(s->mb_num-1 <= ff_mba_max[i]) break;
2884 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2885 s->mb_x= mb_pos % s->mb_width;
2886 s->mb_y= mb_pos / s->mb_width;
2891 void ff_h263_encode_mba(MpegEncContext *s)
2896 if(s->mb_num-1 <= ff_mba_max[i]) break;
2898 mb_pos= s->mb_x + s->mb_width*s->mb_y;
2899 put_bits(&s->pb, ff_mba_length[i], mb_pos);
2903 * decodes the group of blocks header or slice header.
2904 * @return <0 if an error occured
2906 static int h263_decode_gob_header(MpegEncContext *s)
2908 unsigned int val, gfid, gob_number;
2911 /* Check for GOB Start Code */
2912 val = show_bits(&s->gb, 16);
2916 /* We have a GBSC probably with GSTUFF */
2917 skip_bits(&s->gb, 16); /* Drop the zeros */
2918 left= s->gb.size_in_bits - get_bits_count(&s->gb);
2919 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2920 for(;left>13; left--){
2921 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2926 if(s->h263_slice_structured){
2927 if(get_bits1(&s->gb)==0)
2930 ff_h263_decode_mba(s);
2932 if(s->mb_num > 1583)
2933 if(get_bits1(&s->gb)==0)
2936 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2937 if(get_bits1(&s->gb)==0)
2939 gfid = get_bits(&s->gb, 2); /* GFID */
2941 gob_number = get_bits(&s->gb, 5); /* GN */
2943 s->mb_y= s->gob_index* gob_number;
2944 gfid = get_bits(&s->gb, 2); /* GFID */
2945 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2948 if(s->mb_y >= s->mb_height)
2957 static inline void memsetw(short *tab, int val, int n)
2964 #ifdef CONFIG_ENCODERS
2966 void ff_mpeg4_init_partitions(MpegEncContext *s)
2968 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
2969 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE);
2972 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2974 const int pb2_len = put_bits_count(&s->pb2 );
2975 const int tex_pb_len= put_bits_count(&s->tex_pb);
2976 const int bits= put_bits_count(&s->pb);
2978 if(s->pict_type==I_TYPE){
2979 put_bits(&s->pb, 19, DC_MARKER);
2980 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2981 s->i_tex_bits+= tex_pb_len;
2983 put_bits(&s->pb, 17, MOTION_MARKER);
2984 s->misc_bits+=17 + pb2_len;
2985 s->mv_bits+= bits - s->last_bits;
2986 s->p_tex_bits+= tex_pb_len;
2989 flush_put_bits(&s->pb2);
2990 flush_put_bits(&s->tex_pb);
2992 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
2993 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2994 s->last_bits= put_bits_count(&s->pb);
2997 #endif //CONFIG_ENCODERS
2999 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3000 switch(s->pict_type){
3005 return s->f_code+15;
3007 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3013 #ifdef CONFIG_ENCODERS
3015 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3017 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3019 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3020 put_bits(&s->pb, 1, 1);
3022 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3023 put_bits(&s->pb, s->quant_precision, s->qscale);
3024 put_bits(&s->pb, 1, 0); /* no HEC */
3027 #endif //CONFIG_ENCODERS
3030 * check if the next stuff is a resync marker or the end.
3033 static inline int mpeg4_is_resync(MpegEncContext *s){
3034 const int bits_count= get_bits_count(&s->gb);
3036 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3040 if(bits_count + 8 >= s->gb.size_in_bits){
3041 int v= show_bits(&s->gb, 8);
3042 v|= 0x7F >> (7-(bits_count&7));
3047 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3049 GetBitContext gb= s->gb;
3051 skip_bits(&s->gb, 1);
3052 align_get_bits(&s->gb);
3054 for(len=0; len<32; len++){
3055 if(get_bits1(&s->gb)) break;
3060 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3068 * decodes the next video packet.
3069 * @return <0 if something went wrong
3071 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3073 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3074 int header_extension=0, mb_num, len;
3076 /* is there enough space left for a video packet + header */
3077 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3079 for(len=0; len<32; len++){
3080 if(get_bits1(&s->gb)) break;
3083 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3084 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3088 if(s->shape != RECT_SHAPE){
3089 header_extension= get_bits1(&s->gb);
3090 //FIXME more stuff here
3093 mb_num= get_bits(&s->gb, mb_num_bits);
3094 if(mb_num>=s->mb_num){
3095 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3098 if(s->pict_type == B_TYPE){
3099 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3100 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3103 s->mb_x= mb_num % s->mb_width;
3104 s->mb_y= mb_num / s->mb_width;
3106 if(s->shape != BIN_ONLY_SHAPE){
3107 int qscale= get_bits(&s->gb, s->quant_precision);
3109 s->chroma_qscale=s->qscale= qscale;
3112 if(s->shape == RECT_SHAPE){
3113 header_extension= get_bits1(&s->gb);
3115 if(header_extension){
3119 while (get_bits1(&s->gb) != 0)
3122 check_marker(&s->gb, "before time_increment in video packed header");
3123 time_increment= get_bits(&s->gb, s->time_increment_bits);
3124 check_marker(&s->gb, "before vop_coding_type in video packed header");
3126 skip_bits(&s->gb, 2); /* vop coding type */
3127 //FIXME not rect stuff here
3129 if(s->shape != BIN_ONLY_SHAPE){
3130 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3131 //FIXME dont just ignore everything
3132 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3133 mpeg4_decode_sprite_trajectory(s);
3134 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3137 //FIXME reduced res stuff here
3139 if (s->pict_type != I_TYPE) {
3140 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3142 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3145 if (s->pict_type == B_TYPE) {
3146 int b_code = get_bits(&s->gb, 3);
3148 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3153 //FIXME new-pred stuff
3155 //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));
3160 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3162 int c_wrap, c_xy, l_wrap, l_xy;
3164 l_wrap= s->block_wrap[0];
3165 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
3166 c_wrap= s->block_wrap[4];
3167 c_xy= s->mb_y*c_wrap + s->mb_x;
3171 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3172 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3173 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3177 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3178 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3179 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3182 // we cant clear the MVs as they might be needed by a b frame
3183 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3184 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3185 s->last_mv[0][0][0]=
3186 s->last_mv[0][0][1]=
3187 s->last_mv[1][0][0]=
3188 s->last_mv[1][0][1]= 0;
3192 * decodes the group of blocks / video packet header.
3193 * @return <0 if no resync found
3195 int ff_h263_resync(MpegEncContext *s){
3198 if(s->codec_id==CODEC_ID_MPEG4){
3200 align_get_bits(&s->gb);
3203 if(show_bits(&s->gb, 16)==0){
3204 if(s->codec_id==CODEC_ID_MPEG4)
3205 ret= mpeg4_decode_video_packet_header(s);
3207 ret= h263_decode_gob_header(s);
3211 //ok, its not where its supposed to be ...
3212 s->gb= s->last_resync_gb;
3213 align_get_bits(&s->gb);
3214 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3216 for(;left>16+1+5+5; left-=8){
3217 if(show_bits(&s->gb, 16)==0){
3218 GetBitContext bak= s->gb;
3220 if(s->codec_id==CODEC_ID_MPEG4)
3221 ret= mpeg4_decode_video_packet_header(s);
3223 ret= h263_decode_gob_header(s);
3229 skip_bits(&s->gb, 8);
3236 * gets the average motion vector for a GMC MB.
3237 * @param n either 0 for the x component or 1 for y
3238 * @returns the average MV for a GMC MB
3240 static inline int get_amv(MpegEncContext *s, int n){
3241 int x, y, mb_v, sum, dx, dy, shift;
3242 int len = 1 << (s->f_code + 4);
3243 const int a= s->sprite_warping_accuracy;
3245 if(s->real_sprite_warping_points==1){
3246 if(s->divx_version==500 && s->divx_build==413)
3247 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3249 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3251 dx= s->sprite_delta[n][0];
3252 dy= s->sprite_delta[n][1];
3253 shift= s->sprite_shift[0];
3254 if(n) dy -= 1<<(shift + a + 1);
3255 else dx -= 1<<(shift + a + 1);
3256 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3259 for(y=0; y<16; y++){
3263 //XXX FIXME optimize
3264 for(x=0; x<16; x++){
3269 sum= RSHIFT(sum, a+8-s->quarter_sample);
3272 if (sum < -len) sum= -len;
3273 else if (sum >= len) sum= len-1;
3279 * decodes first partition.
3280 * @return number of MBs decoded or <0 if an error occured
3282 static int mpeg4_decode_partition_a(MpegEncContext *s){
3284 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3286 /* decode first partition */
3288 s->first_slice_line=1;
3289 for(; s->mb_y<s->mb_height; s->mb_y++){
3290 ff_init_block_index(s);
3291 for(; s->mb_x<s->mb_width; s->mb_x++){
3292 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3297 ff_update_block_index(s);
3298 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3299 s->first_slice_line=0;
3301 if(s->pict_type==I_TYPE){
3304 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3309 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3311 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3316 s->cbp_table[xy]= cbpc & 3;
3317 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3321 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3323 s->current_picture.qscale_table[xy]= s->qscale;
3325 s->mbintra_table[xy]= 1;
3328 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3330 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3334 if(dc_pred_dir) dir|=1;
3336 s->pred_dir_table[xy]= dir;
3337 }else{ /* P/S_TYPE */
3338 int mx, my, pred_x, pred_y, bits;
3339 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3340 const int stride= s->block_wrap[0]*2;
3343 bits= show_bits(&s->gb, 17);
3344 if(bits==MOTION_MARKER){
3350 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3351 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3355 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3358 mot_val[0 ]= mot_val[2 ]=
3359 mot_val[0+stride]= mot_val[2+stride]= mx;
3360 mot_val[1 ]= mot_val[3 ]=
3361 mot_val[1+stride]= mot_val[3+stride]= my;
3363 if(s->mbintra_table[xy])
3364 ff_clean_intra_table_entries(s);
3368 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3370 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3373 // }while(cbpc == 20);
3375 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3377 s->mb_intra = ((cbpc & 4) != 0);
3380 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3381 s->mbintra_table[xy]= 1;
3382 mot_val[0 ]= mot_val[2 ]=
3383 mot_val[0+stride]= mot_val[2+stride]= 0;
3384 mot_val[1 ]= mot_val[3 ]=
3385 mot_val[1+stride]= mot_val[3+stride]= 0;
3387 if(s->mbintra_table[xy])
3388 ff_clean_intra_table_entries(s);
3390 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3391 s->mcsel= get_bits1(&s->gb);
3394 if ((cbpc & 16) == 0) {
3395 /* 16x16 motion prediction */
3397 h263_pred_motion(s, 0, &pred_x, &pred_y);
3399 mx = h263_decode_motion(s, pred_x, s->f_code);
3403 my = h263_decode_motion(s, pred_y, s->f_code);
3406 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3410 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3413 mot_val[0 ]= mot_val[2 ] =
3414 mot_val[0+stride]= mot_val[2+stride]= mx;
3415 mot_val[1 ]= mot_val[3 ]=
3416 mot_val[1+stride]= mot_val[3+stride]= my;
3419 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3421 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3422 mx = h263_decode_motion(s, pred_x, s->f_code);
3426 my = h263_decode_motion(s, pred_y, s->f_code);
3443 * decode second partition.
3444 * @return <0 if an error occured
3446 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3448 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3450 s->mb_x= s->resync_mb_x;
3451 s->first_slice_line=1;
3452 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3453 ff_init_block_index(s);
3454 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3455 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3458 ff_update_block_index(s);
3459 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3460 s->first_slice_line=0;
3462 if(s->pict_type==I_TYPE){
3463 int ac_pred= get_bits1(&s->gb);
3464 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3466 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3470 s->cbp_table[xy]|= cbpy<<2;
3471 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3472 }else{ /* P || S_TYPE */
3473 if(IS_INTRA(s->current_picture.mb_type[xy])){
3475 int ac_pred = get_bits1(&s->gb);
3476 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3479 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3483 if(s->cbp_table[xy] & 8) {
3484 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3486 s->current_picture.qscale_table[xy]= s->qscale;
3490 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3492 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3496 if(dc_pred_dir) dir|=1;
3498 s->cbp_table[xy]&= 3; //remove dquant
3499 s->cbp_table[xy]|= cbpy<<2;
3500 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3501 s->pred_dir_table[xy]= dir;
3502 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3503 s->current_picture.qscale_table[xy]= s->qscale;
3504 s->cbp_table[xy]= 0;
3506 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3509 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3513 if(s->cbp_table[xy] & 8) {
3514 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3516 s->current_picture.qscale_table[xy]= s->qscale;
3518 s->cbp_table[xy]&= 3; //remove dquant
3519 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3523 if(mb_num >= mb_count) return 0;
3530 * decodes the first & second partition
3531 * @return <0 if error (and sets error type in the error_status_table)
3533 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3536 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3537 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3539 mb_num= mpeg4_decode_partition_a(s);
3541 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3545 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3546 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3547 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3551 s->mb_num_left= mb_num;
3553 if(s->pict_type==I_TYPE){
3554 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3555 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3559 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3560 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3564 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3566 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3567 if(s->pict_type==P_TYPE)
3568 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3571 if(s->pict_type==P_TYPE)
3572 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3579 * decode partition C of one MB.
3580 * @return <0 if an error occured
3582 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3585 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3587 mb_type= s->current_picture.mb_type[xy];
3588 cbp = s->cbp_table[xy];
3590 if(s->current_picture.qscale_table[xy] != s->qscale){
3591 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3594 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3597 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3598 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3600 s->mb_intra = IS_INTRA(mb_type);
3602 if (IS_SKIP(mb_type)) {
3605 s->block_last_index[i] = -1;
3606 s->mv_dir = MV_DIR_FORWARD;
3607 s->mv_type = MV_TYPE_16X16;
3608 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3615 }else if(s->mb_intra){
3616 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3617 }else if(!s->mb_intra){
3618 // s->mcsel= 0; //FIXME do we need to init that
3620 s->mv_dir = MV_DIR_FORWARD;
3621 if (IS_8X8(mb_type)) {
3622 s->mv_type = MV_TYPE_8X8;
3624 s->mv_type = MV_TYPE_16X16;
3627 } else { /* I-Frame */
3629 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3632 if (!IS_SKIP(mb_type)) {
3634 /* decode each block */
3635 for (i = 0; i < 6; i++) {
3636 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3637 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3644 /* per-MB end of slice check */
3646 if(--s->mb_num_left <= 0){
3647 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3648 if(mpeg4_is_resync(s))
3653 if(mpeg4_is_resync(s)){
3654 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3655 if(s->cbp_table[xy+delta])
3663 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3665 static void preview_obmc(MpegEncContext *s){
3666 GetBitContext gb= s->gb;
3668 int cbpc, i, pred_x, pred_y, mx, my;
3670 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3671 const int stride= s->block_wrap[0]*2;
3674 s->block_index[i]+= 2;
3676 s->block_index[i]+= 1;
3679 assert(s->pict_type == P_TYPE);
3682 if (get_bits1(&s->gb)) {
3684 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3685 mot_val[0 ]= mot_val[2 ]=
3686 mot_val[0+stride]= mot_val[2+stride]= 0;
3687 mot_val[1 ]= mot_val[3 ]=
3688 mot_val[1+stride]= mot_val[3+stride]= 0;
3690 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3693 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3697 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3699 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3701 if(s->modified_quant){
3702 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3703 else skip_bits(&s->gb, 5);
3705 skip_bits(&s->gb, 2);
3708 if ((cbpc & 16) == 0) {
3709 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3710 /* 16x16 motion prediction */
3711 mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);
3713 mx = h263p_decode_umotion(s, pred_x);
3715 mx = h263_decode_motion(s, pred_x, 1);
3718 my = h263p_decode_umotion(s, pred_y);
3720 my = h263_decode_motion(s, pred_y, 1);
3722 mot_val[0 ]= mot_val[2 ]=
3723 mot_val[0+stride]= mot_val[2+stride]= mx;
3724 mot_val[1 ]= mot_val[3 ]=
3725 mot_val[1+stride]= mot_val[3+stride]= my;
3727 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3729 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3731 mx = h263p_decode_umotion(s, pred_x);
3733 mx = h263_decode_motion(s, pred_x, 1);
3736 my = h263p_decode_umotion(s, pred_y);
3738 my = h263_decode_motion(s, pred_y, 1);
3739 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3740 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3749 s->block_index[i]-= 2;
3751 s->block_index[i]-= 1;
3757 static void h263_decode_dquant(MpegEncContext *s){
3758 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3760 if(s->modified_quant){
3761 if(get_bits1(&s->gb))
3762 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3764 s->qscale= get_bits(&s->gb, 5);
3766 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3767 ff_set_qscale(s, s->qscale);
3770 int ff_h263_decode_mb(MpegEncContext *s,
3771 DCTELEM block[6][64])
3773 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3775 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3777 assert(!s->h263_pred);
3779 if (s->pict_type == P_TYPE) {
3781 if (get_bits1(&s->gb)) {
3785 s->block_last_index[i] = -1;
3786 s->mv_dir = MV_DIR_FORWARD;
3787 s->mv_type = MV_TYPE_16X16;
3788 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3791 s->mb_skiped = !(s->obmc | s->loop_filter);
3794 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3795 //fprintf(stderr, "\tCBPC: %d", cbpc);
3797 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3803 s->mb_intra = ((cbpc & 4) != 0);
3804 if (s->mb_intra) goto intra;
3806 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3808 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3811 cbp = (cbpc & 3) | (cbpy << 2);
3813 h263_decode_dquant(s);
3816 s->mv_dir = MV_DIR_FORWARD;
3817 if ((cbpc & 16) == 0) {
3818 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3819 /* 16x16 motion prediction */
3820 s->mv_type = MV_TYPE_16X16;
3821 h263_pred_motion(s, 0, &pred_x, &pred_y);
3823 mx = h263p_decode_umotion(s, pred_x);
3825 mx = h263_decode_motion(s, pred_x, 1);
3831 my = h263p_decode_umotion(s, pred_y);
3833 my = h263_decode_motion(s, pred_y, 1);
3837 s->mv[0][0][0] = mx;
3838 s->mv[0][0][1] = my;
3840 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3841 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3843 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3844 s->mv_type = MV_TYPE_8X8;
3846 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3848 mx = h263p_decode_umotion(s, pred_x);
3850 mx = h263_decode_motion(s, pred_x, 1);
3855 my = h263p_decode_umotion(s, pred_y);
3857 my = h263_decode_motion(s, pred_y, 1);
3860 s->mv[0][i][0] = mx;
3861 s->mv[0][i][1] = my;
3862 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3863 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3869 /* decode each block */
3870 for (i = 0; i < 6; i++) {
3871 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3877 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3880 } else if(s->pict_type==B_TYPE) {
3882 const int stride= s->b8_stride;
3883 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
3884 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
3885 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3888 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
3889 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
3890 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
3891 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
3894 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
3896 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
3900 mb_type= h263_mb_type_b_map[ mb_type ];
3903 s->mb_intra = IS_INTRA(mb_type);
3904 if(HAS_CBP(mb_type)){
3905 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
3907 dquant = IS_QUANT(mb_type);
3911 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3914 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3918 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3921 cbp = (cbpc & 3) | (cbpy << 2);
3925 assert(!s->mb_intra);
3927 if(IS_QUANT(mb_type)){
3928 h263_decode_dquant(s);
3931 if(IS_DIRECT(mb_type)){
3932 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3933 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
3936 s->mv_type= MV_TYPE_16X16;
3939 if(USES_LIST(mb_type, 0)){
3940 int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my);
3941 s->mv_dir = MV_DIR_FORWARD;
3943 mx = h263_decode_motion(s, mx, 1);
3944 my = h263_decode_motion(s, my, 1);
3946 s->mv[0][0][0] = mx;
3947 s->mv[0][0][1] = my;
3948 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3949 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3952 if(USES_LIST(mb_type, 1)){
3953 int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my);
3954 s->mv_dir |= MV_DIR_BACKWARD;
3956 mx = h263_decode_motion(s, mx, 1);
3957 my = h263_decode_motion(s, my, 1);
3959 s->mv[1][0][0] = mx;
3960 s->mv[1][0][1] = my;
3961 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
3962 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
3966 s->current_picture.mb_type[xy]= mb_type;
3968 /* decode each block */
3969 for (i = 0; i < 6; i++) {
3970 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3974 } else { /* I-Frame */
3976 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3978 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3986 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3988 s->ac_pred = get_bits1(&s->gb);
3990 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3992 s->h263_aic_dir = get_bits1(&s->gb);
3997 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3999 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4002 cbp = (cbpc & 3) | (cbpy << 2);
4004 h263_decode_dquant(s);
4007 /* decode each block */
4008 for (i = 0; i < 6; i++) {
4009 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4016 /* per-MB end of slice check */
4018 int v= show_bits(&s->gb, 16);
4020 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4021 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4031 int ff_mpeg4_decode_mb(MpegEncContext *s,
4032 DCTELEM block[6][64])
4034 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4036 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4037 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4039 assert(s->h263_pred);
4041 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4043 if (get_bits1(&s->gb)) {
4047 s->block_last_index[i] = -1;
4048 s->mv_dir = MV_DIR_FORWARD;
4049 s->mv_type = MV_TYPE_16X16;
4050 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4051 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4053 s->mv[0][0][0]= get_amv(s, 0);
4054 s->mv[0][0][1]= get_amv(s, 1);
4058 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4066 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4067 //fprintf(stderr, "\tCBPC: %d", cbpc);
4069 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4075 s->mb_intra = ((cbpc & 4) != 0);
4076 if (s->mb_intra) goto intra;
4078 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4079 s->mcsel= get_bits1(&s->gb);
4081 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4083 cbp = (cbpc & 3) | (cbpy << 2);
4085 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4087 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4088 s->interlaced_dct= get_bits1(&s->gb);
4090 s->mv_dir = MV_DIR_FORWARD;
4091 if ((cbpc & 16) == 0) {
4093 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4094 /* 16x16 global motion prediction */
4095 s->mv_type = MV_TYPE_16X16;
4098 s->mv[0][0][0] = mx;
4099 s->mv[0][0][1] = my;
4100 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4101 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4102 /* 16x8 field motion prediction */
4103 s->mv_type= MV_TYPE_FIELD;
4105 s->field_select[0][0]= get_bits1(&s->gb);
4106 s->field_select[0][1]= get_bits1(&s->gb);
4108 h263_pred_motion(s, 0, &pred_x, &pred_y);
4111 mx = h263_decode_motion(s, pred_x, s->f_code);
4115 my = h263_decode_motion(s, pred_y/2, s->f_code);
4119 s->mv[0][i][0] = mx;
4120 s->mv[0][i][1] = my;
4123 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4124 /* 16x16 motion prediction */
4125 s->mv_type = MV_TYPE_16X16;
4126 h263_pred_motion(s, 0, &pred_x, &pred_y);
4127 mx = h263_decode_motion(s, pred_x, s->f_code);
4132 my = h263_decode_motion(s, pred_y, s->f_code);
4136 s->mv[0][0][0] = mx;
4137 s->mv[0][0][1] = my;
4140 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4141 s->mv_type = MV_TYPE_8X8;
4143 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
4144 mx = h263_decode_motion(s, pred_x, s->f_code);
4148 my = h263_decode_motion(s, pred_y, s->f_code);
4151 s->mv[0][i][0] = mx;
4152 s->mv[0][i][1] = my;
4157 } else if(s->pict_type==B_TYPE) {
4158 int modb1; // first bit of modb
4159 int modb2; // second bit of modb
4162 s->mb_intra = 0; //B-frames never contain intra blocks
4163 s->mcsel=0; // ... true gmc blocks
4167 s->last_mv[i][0][0]=
4168 s->last_mv[i][0][1]=
4169 s->last_mv[i][1][0]=
4170 s->last_mv[i][1][1]= 0;
4174 /* if we skipped it in the future P Frame than skip it now too */
4175 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4180 s->block_last_index[i] = -1;
4182 s->mv_dir = MV_DIR_FORWARD;
4183 s->mv_type = MV_TYPE_16X16;
4188 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4192 modb1= get_bits1(&s->gb);
4194 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4197 modb2= get_bits1(&s->gb);
4198 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4200 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4203 mb_type= mb_type_b_map[ mb_type ];
4205 else cbp= get_bits(&s->gb, 6);
4207 if ((!IS_DIRECT(mb_type)) && cbp) {
4208 if(get_bits1(&s->gb)){
4209 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4213 if(!s->progressive_sequence){
4215 s->interlaced_dct= get_bits1(&s->gb);
4217 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4218 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4219 mb_type &= ~MB_TYPE_16x16;
4221 if(USES_LIST(mb_type, 0)){
4222 s->field_select[0][0]= get_bits1(&s->gb);
4223 s->field_select[0][1]= get_bits1(&s->gb);
4225 if(USES_LIST(mb_type, 1)){
4226 s->field_select[1][0]= get_bits1(&s->gb);
4227 s->field_select[1][1]= get_bits1(&s->gb);
4233 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4234 s->mv_type= MV_TYPE_16X16;
4236 if(USES_LIST(mb_type, 0)){
4237 s->mv_dir = MV_DIR_FORWARD;
4239 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4240 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4241 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4242 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4245 if(USES_LIST(mb_type, 1)){
4246 s->mv_dir |= MV_DIR_BACKWARD;
4248 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4249 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4250 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4251 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4253 }else if(!IS_DIRECT(mb_type)){
4254 s->mv_type= MV_TYPE_FIELD;
4256 if(USES_LIST(mb_type, 0)){
4257 s->mv_dir = MV_DIR_FORWARD;
4260 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4261 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4262 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4263 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4267 if(USES_LIST(mb_type, 1)){
4268 s->mv_dir |= MV_DIR_BACKWARD;
4271 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4272 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4273 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4274 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4280 if(IS_DIRECT(mb_type)){
4281 if(IS_SKIP(mb_type))
4284 mx = h263_decode_motion(s, 0, 1);
4285 my = h263_decode_motion(s, 0, 1);
4288 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4289 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4291 s->current_picture.mb_type[xy]= mb_type;
4292 } else { /* I-Frame */
4294 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4296 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4304 s->ac_pred = get_bits1(&s->gb);
4306 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4308 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4310 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4312 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4315 cbp = (cbpc & 3) | (cbpy << 2);
4317 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4320 if(!s->progressive_sequence)
4321 s->interlaced_dct= get_bits1(&s->gb);
4323 /* decode each block */
4324 for (i = 0; i < 6; i++) {
4325 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4332 /* decode each block */
4333 for (i = 0; i < 6; i++) {
4334 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4340 /* per-MB end of slice check */
4341 if(s->codec_id==CODEC_ID_MPEG4){
4342 if(mpeg4_is_resync(s)){
4343 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4344 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4353 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4355 int code, val, sign, shift, l;
4356 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4363 sign = get_bits1(&s->gb);
4367 val = (val - 1) << shift;
4368 val |= get_bits(&s->gb, shift);
4375 /* modulo decoding */
4376 if (!s->h263_long_vectors) {
4377 l = 1 << (f_code + 4);
4378 val = ((val + l)&(l*2-1)) - l;
4380 /* horrible h263 long vector mode */
4381 if (pred < -31 && val < -63)
4383 if (pred > 32 && val > 63)
4390 /* Decodes RVLC of H.263+ UMV */
4391 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4395 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4398 code = 2 + get_bits1(&s->gb);
4400 while (get_bits1(&s->gb))
4403 code += get_bits1(&s->gb);
4408 code = (sign) ? (pred - code) : (pred + code);
4410 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4416 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4419 int code, level, i, j, last, run;
4420 RLTable *rl = &rl_inter;
4421 const uint8_t *scan_table;
4422 GetBitContext gb= s->gb;
4424 scan_table = s->intra_scantable.permutated;
4425 if (s->h263_aic && s->mb_intra) {
4429 if (s->h263_aic_dir)
4430 scan_table = s->intra_v_scantable.permutated; /* left */
4432 scan_table = s->intra_h_scantable.permutated; /* top */
4434 } else if (s->mb_intra) {
4436 if(s->codec_id == CODEC_ID_RV10){
4437 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4438 int component, diff;
4439 component = (n <= 3 ? 0 : n - 4 + 1);
4440 level = s->last_dc[component];
4441 if (s->rv10_first_dc_coded[component]) {
4442 diff = rv_decode_dc(s, n);
4446 level = level & 0xff; /* handle wrap round */
4447 s->last_dc[component] = level;
4449 s->rv10_first_dc_coded[component] = 1;
4452 level = get_bits(&s->gb, 8);
4455 level = get_bits(&s->gb, 8);
4456 if((level&0x7F) == 0){
4457 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4458 if(s->error_resilience >= FF_ER_COMPLIANT)
4470 if (s->mb_intra && s->h263_aic)
4472 s->block_last_index[n] = i - 1;
4477 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4479 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4482 if (code == rl->n) {
4484 if (s->h263_flv > 1) {
4485 int is11 = get_bits1(&s->gb);
4486 last = get_bits1(&s->gb);
4487 run = get_bits(&s->gb, 6);
4489 level = get_sbits(&s->gb, 11);
4491 level = get_sbits(&s->gb, 7);
4494 last = get_bits1(&s->gb);
4495 run = get_bits(&s->gb, 6);
4496 level = (int8_t)get_bits(&s->gb, 8);
4498 if (s->codec_id == CODEC_ID_RV10) {
4499 /* XXX: should patch encoder too */
4500 level = get_sbits(&s->gb, 12);
4502 level = get_bits(&s->gb, 5);
4503 level |= get_sbits(&s->gb, 6)<<5;
4508 run = rl->table_run[code];
4509 level = rl->table_level[code];
4510 last = code >= rl->last;
4511 if (get_bits1(&s->gb))
4516 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4517 //looks like a hack but no, its the way its supposed to work ...
4521 memset(block, 0, sizeof(DCTELEM)*64);
4524 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4534 if (s->mb_intra && s->h263_aic) {
4535 h263_pred_acdc(s, block, n);
4538 s->block_last_index[n] = i;
4543 * decodes the dc value.
4544 * @param n block index (0-3 are luma, 4-5 are chroma)
4545 * @param dir_ptr the prediction direction will be stored here
4546 * @return the quantized dc
4548 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4550 int level, pred, code;
4554 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4556 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4557 if (code < 0 || code > 9 /* && s->nbit<9 */){
4558 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4566 level= 2*get_bits1(&s->gb)-1;
4568 if(get_bits1(&s->gb))
4569 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4571 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4574 level = get_xbits(&s->gb, code);
4578 if(get_bits1(&s->gb)==0){ /* marker */
4579 if(s->error_resilience>=2){
4580 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4586 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
4589 if(s->error_resilience>=3){
4590 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
4596 *dc_val = level * s->y_dc_scale;
4598 *dc_val = level * s->c_dc_scale;
4601 *dc_val = level * 8;
4603 if(s->error_resilience>=3){
4604 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
4605 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
4614 * @return <0 if an error occured
4616 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4617 int n, int coded, int intra, int rvlc)
4619 int level, i, last, run;
4622 RL_VLC_ELEM * rl_vlc;
4623 const uint8_t * scan_table;
4626 //Note intra & rvlc should be optimized away if this is inlined
4629 if(s->qscale < s->intra_dc_threshold){
4631 if(s->partitioned_frame){
4632 level = s->dc_val[0][ s->block_index[n] ];
4633 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4634 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4635 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4637 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4650 rl = &rvlc_rl_intra;
4651 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4654 rl_vlc = rl_intra.rl_vlc[0];
4657 if (dc_pred_dir == 0)
4658 scan_table = s->intra_v_scantable.permutated; /* left */
4660 scan_table = s->intra_h_scantable.permutated; /* top */
4662 scan_table = s->intra_scantable.permutated;
4669 s->block_last_index[n] = i;
4672 if(rvlc) rl = &rvlc_rl_inter;
4673 else rl = &rl_inter;
4675 scan_table = s->intra_scantable.permutated;
4681 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4683 rl_vlc = rl_inter.rl_vlc[0];
4686 qmul = s->qscale << 1;
4687 qadd = (s->qscale - 1) | 1;
4689 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4691 rl_vlc = rl_inter.rl_vlc[s->qscale];
4696 OPEN_READER(re, &s->gb);
4698 UPDATE_CACHE(re, &s->gb);
4699 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4703 if(SHOW_UBITS(re, &s->gb, 1)==0){
4704 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4706 }; SKIP_CACHE(re, &s->gb, 1);
4708 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4709 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4710 SKIP_COUNTER(re, &s->gb, 1+1+6);
4711 UPDATE_CACHE(re, &s->gb);
4713 if(SHOW_UBITS(re, &s->gb, 1)==0){
4714 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4716 }; SKIP_CACHE(re, &s->gb, 1);
4718 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4720 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4721 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4723 }; SKIP_CACHE(re, &s->gb, 5);
4725 level= level * qmul + qadd;
4726 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4727 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4733 cache= GET_CACHE(re, &s->gb);
4736 cache ^= 0xC0000000;
4738 if (cache&0x80000000) {
4739 if (cache&0x40000000) {
4741 SKIP_CACHE(re, &s->gb, 2);
4742 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4743 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4744 SKIP_COUNTER(re, &s->gb, 2+1+6);
4745 UPDATE_CACHE(re, &s->gb);
4748 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4750 if(SHOW_UBITS(re, &s->gb, 1)==0){
4751 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4753 }; SKIP_CACHE(re, &s->gb, 1);
4755 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4757 if(SHOW_UBITS(re, &s->gb, 1)==0){
4758 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4760 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4762 SKIP_COUNTER(re, &s->gb, 1+12+1);
4765 if(level*s->qscale>1024 || level*s->qscale<-1024){
4766 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4770 if(s->error_resilience >= FF_ER_COMPLIANT){
4771 const int abs_level= ABS(level);
4772 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4773 const int run1= run - rl->max_run[last][abs_level] - 1;
4774 if(abs_level <= rl->max_level[last][run]){
4775 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4778 if(s->error_resilience > FF_ER_COMPLIANT){
4779 if(abs_level <= rl->max_level[last][run]*2){
4780 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4783 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4784 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4791 if (level>0) level= level * qmul + qadd;
4792 else level= level * qmul - qadd;
4798 #if MIN_CACHE_BITS < 20
4799 LAST_SKIP_BITS(re, &s->gb, 2);
4800 UPDATE_CACHE(re, &s->gb);
4802 SKIP_BITS(re, &s->gb, 2);
4804 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4805 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4806 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4807 LAST_SKIP_BITS(re, &s->gb, 1);
4811 #if MIN_CACHE_BITS < 19
4812 LAST_SKIP_BITS(re, &s->gb, 1);
4813 UPDATE_CACHE(re, &s->gb);
4815 SKIP_BITS(re, &s->gb, 1);
4817 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4819 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4820 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4821 LAST_SKIP_BITS(re, &s->gb, 1);
4826 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4827 LAST_SKIP_BITS(re, &s->gb, 1);
4832 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4836 block[scan_table[i]] = level;
4840 block[scan_table[i]] = level;
4842 CLOSE_READER(re, &s->gb);
4846 if(s->qscale >= s->intra_dc_threshold){
4848 block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir);
4850 *dc_val = block[0] * s->y_dc_scale;
4852 *dc_val = block[0] * s->c_dc_scale;
4858 mpeg4_pred_ac(s, block, n, dc_pred_dir);
4860 i = 63; /* XXX: not optimal */
4863 s->block_last_index[n] = i;
4867 /* most is hardcoded. should extend to handle all h263 streams */
4868 int h263_decode_picture_header(MpegEncContext *s)
4870 int format, width, height, i;
4873 align_get_bits(&s->gb);
4875 startcode= get_bits(&s->gb, 22-8);
4877 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4878 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4880 if(startcode == 0x20)
4884 if (startcode != 0x20) {
4885 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
4888 /* temporal reference */
4889 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4891 /* PTYPE starts here */
4892 if (get_bits1(&s->gb) != 1) {
4894 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
4897 if (get_bits1(&s->gb) != 0) {
4898 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
4899 return -1; /* h263 id */
4901 skip_bits1(&s->gb); /* split screen off */
4902 skip_bits1(&s->gb); /* camera off */
4903 skip_bits1(&s->gb); /* freeze picture release off */
4905 format = get_bits(&s->gb, 3);
4910 7 extended PTYPE (PLUSPTYPE)
4913 if (format != 7 && format != 6) {
4916 width = h263_format[format][0];
4917 height = h263_format[format][1];
4921 s->pict_type = I_TYPE + get_bits1(&s->gb);
4923 s->h263_long_vectors = get_bits1(&s->gb);
4925 if (get_bits1(&s->gb) != 0) {
4926 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
4927 return -1; /* SAC: off */
4929 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4930 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
4932 if (get_bits1(&s->gb) != 0) {
4933 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
4934 return -1; /* not PB frame */
4936 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
4937 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4946 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4948 /* ufep other than 0 and 1 are reserved */
4951 format = get_bits(&s->gb, 3);
4952 dprintf("ufep=1, format: %d\n", format);
4953 skip_bits(&s->gb,1); /* Custom PCF */
4954 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4955 if (get_bits1(&s->gb) != 0) {
4956 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
4958 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
4959 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
4960 s->loop_filter= get_bits1(&s->gb);
4961 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
4963 s->h263_slice_structured= get_bits1(&s->gb);
4964 if (get_bits1(&s->gb) != 0) {
4965 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
4967 if (get_bits1(&s->gb) != 0) {
4968 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
4970 s->alt_inter_vlc= get_bits1(&s->gb);
4971 s->modified_quant= get_bits1(&s->gb);
4972 if(s->modified_quant)
4973 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
4975 skip_bits(&s->gb, 1); /* Prevent start code emulation */
4977 skip_bits(&s->gb, 3); /* Reserved */
4978 } else if (ufep != 0) {
4979 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
4984 s->pict_type = get_bits(&s->gb, 3);
4985 switch(s->pict_type){
4986 case 0: s->pict_type= I_TYPE;break;
4987 case 1: s->pict_type= P_TYPE;break;
4988 case 3: s->pict_type= B_TYPE;break;
4989 case 7: s->pict_type= I_TYPE;break; //ZYGO
4993 skip_bits(&s->gb, 2);
4994 s->no_rounding = get_bits1(&s->gb);
4995 skip_bits(&s->gb, 4);
4997 /* Get the picture dimensions */
5000 /* Custom Picture Format (CPFMT) */
5001 s->aspect_ratio_info = get_bits(&s->gb, 4);
5002 dprintf("aspect: %d\n", s->aspect_ratio_info);
5007 3 - 10:11 (525-type 4:3)
5008 4 - 16:11 (CIF 16:9)
5009 5 - 40:33 (525-type 16:9)
5012 width = (get_bits(&s->gb, 9) + 1) * 4;
5014 height = get_bits(&s->gb, 9) * 4;
5015 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5016 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5017 /* aspected dimensions */
5018 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5019 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5021 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5024 width = h263_format[format][0];
5025 height = h263_format[format][1];
5027 if ((width == 0) || (height == 0))
5032 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5035 if(s->h263_slice_structured){
5036 if (get_bits1(&s->gb) != 0) {
5037 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5039 if (get_bits1(&s->gb) != 0) {
5040 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5045 s->qscale = get_bits(&s->gb, 5);
5049 while (get_bits1(&s->gb) != 0) {
5050 skip_bits(&s->gb, 8);
5053 if(s->h263_slice_structured){
5054 if (get_bits1(&s->gb) != 1) {
5055 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5059 ff_h263_decode_mba(s);
5061 if (get_bits1(&s->gb) != 1) {
5062 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5069 s->y_dc_scale_table=
5070 s->c_dc_scale_table= ff_aic_dc_scale_table;
5072 s->y_dc_scale_table=
5073 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5076 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5077 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s\n",
5078 s->qscale, av_get_pict_type_char(s->pict_type),
5079 s->gb.size_in_bits, 1-s->no_rounding,
5080 s->obmc ? " AP" : "",
5081 s->umvplus ? " UMV" : "",
5082 s->h263_long_vectors ? " LONG" : "",
5083 s->h263_plus ? " +" : "",
5084 s->h263_aic ? " AIC" : "",
5085 s->alt_inter_vlc ? " AIV" : "",
5086 s->modified_quant ? " MQ" : "",
5087 s->loop_filter ? " LOOP" : "",
5088 s->h263_slice_structured ? " SS" : ""
5092 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5094 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5095 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5096 for(i=0; i<13; i++){
5098 int v= get_bits(&s->gb, 8);
5099 v |= get_sbits(&s->gb, 8)<<8;
5100 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5102 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5104 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5111 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
5114 int a= 2<<s->sprite_warping_accuracy;
5115 int rho= 3-s->sprite_warping_accuracy;
5117 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5118 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5119 int sprite_ref[4][2];
5120 int virtual_ref[2][2];
5122 int alpha=0, beta=0;
5127 for(i=0; i<s->num_sprite_warping_points; i++){
5131 length= get_vlc(&s->gb, &sprite_trajectory);
5133 x= get_xbits(&s->gb, length);
5135 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
5137 length= get_vlc(&s->gb, &sprite_trajectory);
5139 y=get_xbits(&s->gb, length);
5141 skip_bits1(&s->gb); /* marker bit */
5142 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5147 while((1<<alpha)<w) alpha++;
5148 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5152 // Note, the 4th point isnt used for GMC
5153 if(s->divx_version==500 && s->divx_build==413){
5154 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5155 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5156 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5157 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5158 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5159 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5161 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5162 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5163 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5164 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5165 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5166 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5168 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5169 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5171 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5172 // perhaps it should be reordered to be more readable ...
5173 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5174 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5175 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5176 + 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);
5177 virtual_ref[0][1]= 16*vop_ref[0][1]
5178 + 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);
5179 virtual_ref[1][0]= 16*vop_ref[0][0]
5180 + 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);
5181 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5182 + 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);
5184 switch(s->num_sprite_warping_points)
5187 s->sprite_offset[0][0]= 0;
5188 s->sprite_offset[0][1]= 0;
5189 s->sprite_offset[1][0]= 0;
5190 s->sprite_offset[1][1]= 0;
5191 s->sprite_delta[0][0]= a;
5192 s->sprite_delta[0][1]= 0;
5193 s->sprite_delta[1][0]= 0;
5194 s->sprite_delta[1][1]= a;
5195 s->sprite_shift[0]= 0;
5196 s->sprite_shift[1]= 0;
5199 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5200 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5201 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5202 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5203 s->sprite_delta[0][0]= a;
5204 s->sprite_delta[0][1]= 0;
5205 s->sprite_delta[1][0]= 0;
5206 s->sprite_delta[1][1]= a;
5207 s->sprite_shift[0]= 0;
5208 s->sprite_shift[1]= 0;
5211 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5212 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5213 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5214 + (1<<(alpha+rho-1));
5215 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5216 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5217 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5218 + (1<<(alpha+rho-1));
5219 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5220 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5221 +2*w2*r*sprite_ref[0][0]
5223 + (1<<(alpha+rho+1)));
5224 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5225 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5226 +2*w2*r*sprite_ref[0][1]
5228 + (1<<(alpha+rho+1)));
5229 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5230 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5231 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5232 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5234 s->sprite_shift[0]= alpha+rho;
5235 s->sprite_shift[1]= alpha+rho+2;
5238 min_ab= FFMIN(alpha, beta);
5241 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5242 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5243 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5244 + (1<<(alpha+beta+rho-min_ab-1));
5245 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5246 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5247 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5248 + (1<<(alpha+beta+rho-min_ab-1));
5249 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5250 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5251 + 2*w2*h3*r*sprite_ref[0][0]
5253 + (1<<(alpha+beta+rho-min_ab+1));
5254 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5255 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5256 + 2*w2*h3*r*sprite_ref[0][1]
5258 + (1<<(alpha+beta+rho-min_ab+1));
5259 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5260 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5261 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5262 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5264 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5265 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5268 /* try to simplify the situation */
5269 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5270 && s->sprite_delta[0][1] == 0
5271 && s->sprite_delta[1][0] == 0
5272 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5274 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5275 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5276 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5277 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5278 s->sprite_delta[0][0]= a;
5279 s->sprite_delta[0][1]= 0;
5280 s->sprite_delta[1][0]= 0;
5281 s->sprite_delta[1][1]= a;
5282 s->sprite_shift[0]= 0;
5283 s->sprite_shift[1]= 0;
5284 s->real_sprite_warping_points=1;
5287 int shift_y= 16 - s->sprite_shift[0];
5288 int shift_c= 16 - s->sprite_shift[1];
5289 //printf("shifts %d %d\n", shift_y, shift_c);
5291 s->sprite_offset[0][i]<<= shift_y;
5292 s->sprite_offset[1][i]<<= shift_c;
5293 s->sprite_delta[0][i]<<= shift_y;
5294 s->sprite_delta[1][i]<<= shift_y;
5295 s->sprite_shift[i]= 16;
5297 s->real_sprite_warping_points= s->num_sprite_warping_points;
5300 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5301 vop_ref[0][0], vop_ref[0][1],
5302 vop_ref[1][0], vop_ref[1][1],
5303 vop_ref[2][0], vop_ref[2][1],
5304 sprite_ref[0][0], sprite_ref[0][1],
5305 sprite_ref[1][0], sprite_ref[1][1],
5306 sprite_ref[2][0], sprite_ref[2][1],
5307 virtual_ref[0][0], virtual_ref[0][1],
5308 virtual_ref[1][0], virtual_ref[1][1]
5311 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5312 s->sprite_offset[0][0], s->sprite_offset[0][1],
5313 s->sprite_delta[0][0], s->sprite_delta[0][1],
5314 s->sprite_delta[1][0], s->sprite_delta[1][1],
5320 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5321 int hours, minutes, seconds;
5323 hours= get_bits(gb, 5);
5324 minutes= get_bits(gb, 6);
5326 seconds= get_bits(gb, 6);
5328 s->time_base= seconds + 60*(minutes + 60*hours);
5336 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5337 int width, height, vo_ver_id;
5340 skip_bits(gb, 1); /* random access */
5341 s->vo_type= get_bits(gb, 8);
5342 if (get_bits1(gb) != 0) { /* is_ol_id */
5343 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5344 skip_bits(gb, 3); /* vo_priority */
5348 //printf("vo type:%d\n",s->vo_type);
5349 s->aspect_ratio_info= get_bits(gb, 4);
5350 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5351 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5352 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5354 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5357 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5358 int chroma_format= get_bits(gb, 2);
5359 if(chroma_format!=1){
5360 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5362 s->low_delay= get_bits1(gb);
5363 if(get_bits1(gb)){ /* vbv parameters */
5364 get_bits(gb, 15); /* first_half_bitrate */
5365 skip_bits1(gb); /* marker */
5366 get_bits(gb, 15); /* latter_half_bitrate */
5367 skip_bits1(gb); /* marker */
5368 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5369 skip_bits1(gb); /* marker */
5370 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5371 get_bits(gb, 11); /* first_half_vbv_occupancy */
5372 skip_bits1(gb); /* marker */
5373 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5374 skip_bits1(gb); /* marker */
5377 // set low delay flag only once so the smart? low delay detection wont be overriden
5378 if(s->picture_number==0)
5382 s->shape = get_bits(gb, 2); /* vol shape */
5383 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5384 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5385 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5386 skip_bits(gb, 4); //video_object_layer_shape_extension
5389 check_marker(gb, "before time_increment_resolution");
5391 s->time_increment_resolution = get_bits(gb, 16);
5393 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
5394 if (s->time_increment_bits < 1)
5395 s->time_increment_bits = 1;
5397 check_marker(gb, "before fixed_vop_rate");
5399 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5400 skip_bits(gb, s->time_increment_bits);
5403 if (s->shape != BIN_ONLY_SHAPE) {
5404 if (s->shape == RECT_SHAPE) {
5405 skip_bits1(gb); /* marker */
5406 width = get_bits(gb, 13);
5407 skip_bits1(gb); /* marker */
5408 height = get_bits(gb, 13);
5409 skip_bits1(gb); /* marker */
5410 if(width && height){ /* they should be non zero but who knows ... */
5413 // printf("width/height: %d %d\n", width, height);
5417 s->progressive_sequence=
5418 s->progressive_frame= get_bits1(gb)^1;
5419 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5420 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5421 if (vo_ver_id == 1) {
5422 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5424 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5426 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5427 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5428 if(s->vol_sprite_usage==STATIC_SPRITE){
5429 s->sprite_width = get_bits(gb, 13);
5430 skip_bits1(gb); /* marker */
5431 s->sprite_height= get_bits(gb, 13);
5432 skip_bits1(gb); /* marker */
5433 s->sprite_left = get_bits(gb, 13);
5434 skip_bits1(gb); /* marker */
5435 s->sprite_top = get_bits(gb, 13);
5436 skip_bits1(gb); /* marker */
5438 s->num_sprite_warping_points= get_bits(gb, 6);
5439 s->sprite_warping_accuracy = get_bits(gb, 2);
5440 s->sprite_brightness_change= get_bits1(gb);
5441 if(s->vol_sprite_usage==STATIC_SPRITE)
5442 s->low_latency_sprite= get_bits1(gb);
5444 // FIXME sadct disable bit if verid!=1 && shape not rect
5446 if (get_bits1(gb) == 1) { /* not_8_bit */
5447 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5448 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5449 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precission %d\n", s->quant_precision);
5451 s->quant_precision = 5;
5454 // FIXME a bunch of grayscale shape things
5456 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5459 /* load default matrixes */
5460 for(i=0; i<64; i++){
5461 int j= s->dsp.idct_permutation[i];
5462 v= ff_mpeg4_default_intra_matrix[i];
5463 s->intra_matrix[j]= v;
5464 s->chroma_intra_matrix[j]= v;
5466 v= ff_mpeg4_default_non_intra_matrix[i];
5467 s->inter_matrix[j]= v;
5468 s->chroma_inter_matrix[j]= v;
5471 /* load custom intra matrix */
5474 for(i=0; i<64; i++){
5480 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5481 s->intra_matrix[j]= v;
5482 s->chroma_intra_matrix[j]= v;
5485 /* replicate last value */
5487 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5488 s->intra_matrix[j]= last;
5489 s->chroma_intra_matrix[j]= last;
5493 /* load custom non intra matrix */
5496 for(i=0; i<64; i++){
5502 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5503 s->inter_matrix[j]= v;
5504 s->chroma_inter_matrix[j]= v;
5507 /* replicate last value */
5509 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5510 s->inter_matrix[j]= last;
5511 s->chroma_inter_matrix[j]= last;
5515 // FIXME a bunch of grayscale shape things
5519 s->quarter_sample= get_bits1(gb);
5520 else s->quarter_sample=0;
5522 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5524 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5526 s->data_partitioning= get_bits1(gb);
5527 if(s->data_partitioning){
5528 s->rvlc= get_bits1(gb);
5531 if(vo_ver_id != 1) {
5532 s->new_pred= get_bits1(gb);
5534 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5535 skip_bits(gb, 2); /* requested upstream message type */
5536 skip_bits1(gb); /* newpred segment type */
5538 s->reduced_res_vop= get_bits1(gb);
5539 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5543 s->reduced_res_vop= 0;
5546 s->scalability= get_bits1(gb);
5548 if (s->scalability) {
5549 GetBitContext bak= *gb;
5551 int ref_layer_sampling_dir;
5552 int h_sampling_factor_n;
5553 int h_sampling_factor_m;
5554 int v_sampling_factor_n;
5555 int v_sampling_factor_m;
5557 s->hierachy_type= get_bits1(gb);
5558 ref_layer_id= get_bits(gb, 4);
5559 ref_layer_sampling_dir= get_bits1(gb);
5560 h_sampling_factor_n= get_bits(gb, 5);
5561 h_sampling_factor_m= get_bits(gb, 5);
5562 v_sampling_factor_n= get_bits(gb, 5);
5563 v_sampling_factor_m= get_bits(gb, 5);
5564 s->enhancement_type= get_bits1(gb);
5566 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5567 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5569 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5574 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5576 // bin shape stuff FIXME
5583 * decodes the user data stuff in the header.
5584 * allso inits divx/xvid/lavc_version/build
5586 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5590 int ver, build, ver2, ver3;
5593 buf[0]= show_bits(gb, 8);
5594 for(i=1; i<256; i++){
5595 buf[i]= show_bits(gb, 16)&0xFF;
5596 if(buf[i]==0) break;
5601 /* divx detection */
5602 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5604 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5606 s->divx_version= ver;
5607 s->divx_build= build;
5608 s->divx_packed= e==3 && last=='p';
5611 /* ffmpeg detection */
5612 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
5614 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5616 if(strcmp(buf, "ffmpeg")==0){
5617 s->ffmpeg_version= 0x000406;
5618 s->lavc_build= 4600;
5622 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
5623 s->lavc_build= build;
5626 /* xvid detection */
5627 e=sscanf(buf, "XviD%d", &build);
5629 s->xvid_build= build;
5632 //printf("User Data: %s\n", buf);
5636 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5637 int time_incr, time_increment;
5639 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5640 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5641 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set, but shouldnt, clearing it\n");
5645 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5646 if(s->partitioned_frame)
5647 s->decode_mb= mpeg4_decode_partitioned_mb;
5649 s->decode_mb= ff_mpeg4_decode_mb;
5651 if(s->time_increment_resolution==0){
5652 s->time_increment_resolution=1;
5653 // fprintf(stderr, "time_increment_resolution is illegal\n");
5656 while (get_bits1(gb) != 0)
5659 check_marker(gb, "before time_increment");
5661 if(s->time_increment_bits==0){
5662 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
5664 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5665 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5668 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5671 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5672 else time_increment= get_bits(gb, s->time_increment_bits);
5674 // printf("%d %X\n", s->time_increment_bits, time_increment);
5675 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
5676 if(s->pict_type!=B_TYPE){
5677 s->last_time_base= s->time_base;
5678 s->time_base+= time_incr;
5679 s->time= s->time_base*s->time_increment_resolution + time_increment;
5680 if(s->workaround_bugs&FF_BUG_UMP4){
5681 if(s->time < s->last_non_b_time){
5682 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5684 s->time+= s->time_increment_resolution;
5687 s->pp_time= s->time - s->last_non_b_time;
5688 s->last_non_b_time= s->time;
5690 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
5691 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5692 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5693 // printf("messed up order, seeking?, skiping current b frame\n");
5694 return FRAME_SKIPED;
5697 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
5698 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5699 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
5700 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5701 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5702 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5703 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5706 s->current_picture_ptr->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
5707 if(s->avctx->debug&FF_DEBUG_PTS)
5708 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts/(1000.0*1000.0));
5710 check_marker(gb, "before vop_coded");
5713 if (get_bits1(gb) != 1){
5714 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5715 return FRAME_SKIPED;
5717 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
5718 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5719 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5720 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5721 /* rounding type for motion estimation */
5722 s->no_rounding = get_bits1(gb);
5726 //FIXME reduced res stuff
5728 if (s->shape != RECT_SHAPE) {
5729 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5730 int width, height, hor_spat_ref, ver_spat_ref;
5732 width = get_bits(gb, 13);
5733 skip_bits1(gb); /* marker */
5734 height = get_bits(gb, 13);
5735 skip_bits1(gb); /* marker */
5736 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5737 skip_bits1(gb); /* marker */
5738 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5740 skip_bits1(gb); /* change_CR_disable */
5742 if (get_bits1(gb) != 0) {
5743 skip_bits(gb, 8); /* constant_alpha_value */
5746 //FIXME complexity estimation stuff
5748 if (s->shape != BIN_ONLY_SHAPE) {
5749 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5750 if(!s->progressive_sequence){
5751 s->top_field_first= get_bits1(gb);
5752 s->alternate_scan= get_bits1(gb);
5754 s->alternate_scan= 0;
5757 if(s->alternate_scan){
5758 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5759 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5760 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5761 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5763 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5764 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5765 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5766 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5769 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5770 mpeg4_decode_sprite_trajectory(s);
5771 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5772 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5775 if (s->shape != BIN_ONLY_SHAPE) {
5776 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5778 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5779 return -1; // makes no sense to continue, as there is nothing left from the image then
5782 if (s->pict_type != I_TYPE) {
5783 s->f_code = get_bits(gb, 3); /* fcode_for */
5785 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5786 return -1; // makes no sense to continue, as the MV decoding will break very quickly
5791 if (s->pict_type == B_TYPE) {
5792 s->b_code = get_bits(gb, 3);
5796 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5797 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",
5798 s->qscale, s->f_code, s->b_code,
5799 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5800 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5801 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5802 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5805 if(!s->scalability){
5806 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5807 skip_bits1(gb); // vop shape coding type
5810 if(s->enhancement_type){
5811 int load_backward_shape= get_bits1(gb);
5812 if(load_backward_shape){
5813 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isnt supported\n");
5816 skip_bits(gb, 2); //ref_select_code
5819 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
5820 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
5821 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5822 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5826 s->picture_number++; // better than pic number==0 allways ;)
5828 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5829 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5831 if(s->workaround_bugs&FF_BUG_EDGE){
5832 s->h_edge_pos= s->width;
5833 s->v_edge_pos= s->height;
5839 * decode mpeg4 headers
5840 * @return <0 if no VOP found (or a damaged one)
5841 * FRAME_SKIPPED if a not coded VOP is found
5842 * 0 if a VOP is found
5844 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
5848 /* search next start code */
5852 v = get_bits(gb, 8);
5853 startcode = ((startcode << 8) | v) & 0xffffffff;
5855 if(get_bits_count(gb) >= gb->size_in_bits){
5856 if(gb->size_in_bits==8 && s->divx_version){
5857 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
5858 return FRAME_SKIPED; //divx bug
5860 return -1; //end of stream
5863 if((startcode&0xFFFFFF00) != 0x100)
5864 continue; //no startcode
5866 if(s->avctx->debug&FF_DEBUG_STARTCODE){
5867 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
5868 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
5869 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
5870 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
5871 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
5872 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
5873 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
5874 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
5875 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
5876 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
5877 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
5878 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
5879 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
5880 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
5881 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
5882 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
5883 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
5884 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
5885 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
5886 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
5887 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Textutre Object start");
5888 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Spatial Layer start");
5889 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Textutre SNR Layer start");
5890 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Tile start");
5891 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Shape Layer start");
5892 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
5893 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
5894 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
5895 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
5898 if(startcode >= 0x120 && startcode <= 0x12F){
5899 if(decode_vol_header(s, gb) < 0)
5902 else if(startcode == USER_DATA_STARTCODE){
5903 decode_user_data(s, gb);
5905 else if(startcode == GOP_STARTCODE){
5906 mpeg4_decode_gop_header(s, gb);
5908 else if(startcode == VOP_STARTCODE){
5909 return decode_vop_header(s, gb);
5917 /* don't understand why they choose a different header ! */
5918 int intel_h263_decode_picture_header(MpegEncContext *s)
5922 /* picture header */
5923 if (get_bits_long(&s->gb, 22) != 0x20) {
5924 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5927 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5929 if (get_bits1(&s->gb) != 1) {
5930 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5931 return -1; /* marker */
5933 if (get_bits1(&s->gb) != 0) {
5934 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5935 return -1; /* h263 id */
5937 skip_bits1(&s->gb); /* split screen off */
5938 skip_bits1(&s->gb); /* camera off */
5939 skip_bits1(&s->gb); /* freeze picture release off */
5941 format = get_bits(&s->gb, 3);
5943 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
5948 s->pict_type = I_TYPE + get_bits1(&s->gb);
5950 s->unrestricted_mv = get_bits1(&s->gb);
5951 s->h263_long_vectors = s->unrestricted_mv;
5953 if (get_bits1(&s->gb) != 0) {
5954 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
5955 return -1; /* SAC: off */
5957 if (get_bits1(&s->gb) != 0) {
5959 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
5960 // return -1; /* advanced prediction mode: off */
5962 if (get_bits1(&s->gb) != 0) {
5963 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
5964 return -1; /* PB frame mode */
5967 /* skip unknown header garbage */
5968 skip_bits(&s->gb, 41);
5970 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5971 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5974 while (get_bits1(&s->gb) != 0) {
5975 skip_bits(&s->gb, 8);
5979 s->y_dc_scale_table=
5980 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5985 int flv_h263_decode_picture_header(MpegEncContext *s)
5987 int format, width, height;
5989 /* picture header */
5990 if (get_bits_long(&s->gb, 17) != 1) {
5991 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5994 format = get_bits(&s->gb, 5);
5995 if (format != 0 && format != 1) {
5996 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
5999 s->h263_flv = format+1;
6000 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6001 format = get_bits(&s->gb, 3);
6004 width = get_bits(&s->gb, 8);
6005 height = get_bits(&s->gb, 8);
6008 width = get_bits(&s->gb, 16);
6009 height = get_bits(&s->gb, 16);
6035 if ((width == 0) || (height == 0))
6040 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6041 if (s->pict_type > P_TYPE)
6042 s->pict_type = P_TYPE;
6043 skip_bits1(&s->gb); /* deblocking flag */
6044 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6048 s->unrestricted_mv = 1;
6049 s->h263_long_vectors = 0;
6052 while (get_bits1(&s->gb) != 0) {
6053 skip_bits(&s->gb, 8);
6057 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6058 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6059 av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6062 s->y_dc_scale_table=
6063 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;