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 * ac prediction encoding, B-frame support, error resilience, optimizations,
9 * qpel decoding, gmc decoding, interlaced decoding
10 * by Michael Niedermayer <michaelni@gmx.at>
12 * This file is part of FFmpeg.
14 * FFmpeg is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
19 * FFmpeg is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with FFmpeg; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
39 #include "mpegvideo.h"
41 #include "mpeg4data.h"
46 #define INTRA_MCBPC_VLC_BITS 6
47 #define INTER_MCBPC_VLC_BITS 7
48 #define CBPY_VLC_BITS 6
51 #define SPRITE_TRAJ_VLC_BITS 6
52 #define MB_TYPE_B_VLC_BITS 4
53 #define TEX_VLC_BITS 9
54 #define H263_MBTYPE_B_VLC_BITS 6
55 #define CBPC_B_VLC_BITS 3
57 #ifdef CONFIG_ENCODERS
58 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
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);
64 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
69 static int h263p_decode_umotion(MpegEncContext * s, int pred);
70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
74 int n, int coded, int intra, int rvlc);
75 #ifdef CONFIG_ENCODERS
76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
77 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
79 #endif //CONFIG_ENCODERS
80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
83 #ifdef CONFIG_ENCODERS
84 static uint8_t uni_DCtab_lum_len[512];
85 static uint8_t uni_DCtab_chrom_len[512];
86 static uint16_t uni_DCtab_lum_bits[512];
87 static uint16_t uni_DCtab_chrom_bits[512];
89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
90 static uint8_t fcode_tab[MAX_MV*2+1];
91 static uint8_t umv_fcode_tab[MAX_MV*2+1];
93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
94 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
96 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
97 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
98 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
117 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
122 int h263_get_picture_format(int width, int height)
126 if (width == 128 && height == 96)
128 else if (width == 176 && height == 144)
130 else if (width == 352 && height == 288)
132 else if (width == 704 && height == 576)
134 else if (width == 1408 && height == 1152)
141 static void show_pict_info(MpegEncContext *s){
142 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
143 s->qscale, av_get_pict_type_char(s->pict_type),
144 s->gb.size_in_bits, 1-s->no_rounding,
145 s->obmc ? " AP" : "",
146 s->umvplus ? " UMV" : "",
147 s->h263_long_vectors ? " LONG" : "",
148 s->h263_plus ? " +" : "",
149 s->h263_aic ? " AIC" : "",
150 s->alt_inter_vlc ? " AIV" : "",
151 s->modified_quant ? " MQ" : "",
152 s->loop_filter ? " LOOP" : "",
153 s->h263_slice_structured ? " SS" : "",
154 s->avctx->time_base.den, s->avctx->time_base.num
158 #ifdef CONFIG_ENCODERS
160 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
163 if(aspect.num==0) aspect= (AVRational){1,1};
166 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
167 s->aspect_ratio_info=i;
172 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
175 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
179 align_put_bits(&s->pb);
181 put_bits(&s->pb, 17, 1);
182 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
183 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
184 s->avctx->time_base.den) & 0xff); /* TemporalReference */
185 if (s->width == 352 && s->height == 288)
187 else if (s->width == 176 && s->height == 144)
189 else if (s->width == 128 && s->height == 96)
191 else if (s->width == 320 && s->height == 240)
193 else if (s->width == 160 && s->height == 120)
195 else if (s->width <= 255 && s->height <= 255)
196 format = 0; /* use 1 byte width & height */
198 format = 1; /* use 2 bytes width & height */
199 put_bits(&s->pb, 3, format); /* PictureSize */
201 put_bits(&s->pb, 8, s->width);
202 put_bits(&s->pb, 8, s->height);
203 } else if (format == 1) {
204 put_bits(&s->pb, 16, s->width);
205 put_bits(&s->pb, 16, s->height);
207 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
208 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
209 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
210 put_bits(&s->pb, 1, 0); /* ExtraInformation */
214 s->c_dc_scale_table= ff_aic_dc_scale_table;
217 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
221 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
223 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
224 int best_clock_code=1;
226 int best_error= INT_MAX;
231 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
232 div= av_clip(div, 1, 127);
233 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
234 if(error < best_error){
241 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
242 coded_frame_rate= 1800000;
243 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
245 align_put_bits(&s->pb);
247 /* Update the pointer to last GOB */
248 s->ptr_lastgob = pbBufPtr(&s->pb);
249 put_bits(&s->pb, 22, 0x20); /* PSC */
250 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
251 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
252 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
254 put_bits(&s->pb, 1, 1); /* marker */
255 put_bits(&s->pb, 1, 0); /* h263 id */
256 put_bits(&s->pb, 1, 0); /* split screen off */
257 put_bits(&s->pb, 1, 0); /* camera off */
258 put_bits(&s->pb, 1, 0); /* freeze picture release off */
260 format = h263_get_picture_format(s->width, s->height);
263 put_bits(&s->pb, 3, format);
264 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
265 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
266 of H.263v1 UMV implies to check the predicted MV after
267 calculation of the current MB to see if we're on the limits */
268 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
269 put_bits(&s->pb, 1, 0); /* SAC: off */
270 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
271 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
272 put_bits(&s->pb, 5, s->qscale);
273 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
277 /* H.263 Plus PTYPE */
279 put_bits(&s->pb, 3, 7);
280 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
282 put_bits(&s->pb,3,6); /* Custom Source Format */
284 put_bits(&s->pb, 3, format);
286 put_bits(&s->pb,1, s->custom_pcf);
287 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
288 put_bits(&s->pb,1,0); /* SAC: off */
289 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
290 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
291 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
292 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
293 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
294 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
295 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
296 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298 put_bits(&s->pb,3,0); /* Reserved */
300 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
302 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
303 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
304 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
305 put_bits(&s->pb,2,0); /* Reserved */
306 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
308 /* This should be here if PLUSPTYPE */
309 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
312 /* Custom Picture Format (CPFMT) */
313 aspect_to_info(s, s->avctx->sample_aspect_ratio);
315 put_bits(&s->pb,4,s->aspect_ratio_info);
316 put_bits(&s->pb,9,(s->width >> 2) - 1);
317 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
318 put_bits(&s->pb,9,(s->height >> 2));
319 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
320 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
326 put_bits(&s->pb, 1, best_clock_code);
327 put_bits(&s->pb, 7, best_divisor);
329 put_bits(&s->pb, 2, (temp_ref>>8)&3);
332 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
334 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
335 //FIXME check actual requested range
336 put_bits(&s->pb,2,1); /* unlimited */
337 if(s->h263_slice_structured)
338 put_bits(&s->pb,2,0); /* no weird submodes */
340 put_bits(&s->pb, 5, s->qscale);
343 put_bits(&s->pb, 1, 0); /* no PEI */
345 if(s->h263_slice_structured){
346 put_bits(&s->pb, 1, 1);
348 assert(s->mb_x == 0 && s->mb_y == 0);
349 ff_h263_encode_mba(s);
351 put_bits(&s->pb, 1, 1);
356 s->c_dc_scale_table= ff_aic_dc_scale_table;
359 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
364 * Encodes a group of blocks header.
366 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
368 put_bits(&s->pb, 17, 1); /* GBSC */
370 if(s->h263_slice_structured){
371 put_bits(&s->pb, 1, 1);
373 ff_h263_encode_mba(s);
376 put_bits(&s->pb, 1, 1);
377 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
378 put_bits(&s->pb, 1, 1);
379 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
381 int gob_number= mb_line / s->gob_index;
383 put_bits(&s->pb, 5, gob_number); /* GN */
384 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
385 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
394 for(j=1; j<=block_last_index; j++){
395 const int index= scantable[j];
396 int level= block[index];
399 if((level&(~127)) == 0){
400 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
401 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
403 rate += s->ac_esc_length;
413 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
417 int8_t * const qscale_table= s->current_picture.qscale_table;
419 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
422 int16_t *ac_val, *ac_val1;
424 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
426 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
429 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
431 ac_val-= s->block_wrap[n]*16;
432 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
435 const int level= block[n][s->dsp.idct_permutation[i ]];
436 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
437 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
441 /* different qscale, we must rescale */
443 const int level= block[n][s->dsp.idct_permutation[i ]];
444 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
445 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
449 st[n]= s->intra_h_scantable.permutated;
451 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
452 /* left prediction */
454 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
457 const int level= block[n][s->dsp.idct_permutation[i<<3]];
458 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
460 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
463 /* different qscale, we must rescale */
465 const int level= block[n][s->dsp.idct_permutation[i<<3]];
466 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
468 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
471 st[n]= s->intra_v_scantable.permutated;
474 for(i=63; i>0; i--) //FIXME optimize
475 if(block[n][ st[n][i] ]) break;
476 s->block_last_index[n]= i;
478 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
484 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
487 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
490 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
492 st[n]= s->intra_scantable.permutated;
496 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
499 /* left prediction */
501 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
508 * init s->current_picture.qscale_table from s->lambda_table
510 static void ff_init_qscale_tab(MpegEncContext *s){
511 int8_t * const qscale_table= s->current_picture.qscale_table;
514 for(i=0; i<s->mb_num; i++){
515 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
516 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
517 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
522 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
524 void ff_clean_h263_qscales(MpegEncContext *s){
526 int8_t * const qscale_table= s->current_picture.qscale_table;
528 ff_init_qscale_tab(s);
530 for(i=1; i<s->mb_num; i++){
531 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
532 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
534 for(i=s->mb_num-2; i>=0; i--){
535 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
536 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
539 if(s->codec_id != CODEC_ID_H263P){
540 for(i=1; i<s->mb_num; i++){
541 int mb_xy= s->mb_index2xy[i];
543 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
544 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
551 * modify mb_type & qscale so that encoding is acually possible in mpeg4
553 void ff_clean_mpeg4_qscales(MpegEncContext *s){
555 int8_t * const qscale_table= s->current_picture.qscale_table;
557 ff_clean_h263_qscales(s);
559 if(s->pict_type== B_TYPE){
561 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
563 for(i=0; i<s->mb_num; i++){
564 int mb_xy= s->mb_index2xy[i];
565 odd += qscale_table[mb_xy]&1;
568 if(2*odd > s->mb_num) odd=1;
571 for(i=0; i<s->mb_num; i++){
572 int mb_xy= s->mb_index2xy[i];
573 if((qscale_table[mb_xy]&1) != odd)
574 qscale_table[mb_xy]++;
575 if(qscale_table[mb_xy] > 31)
576 qscale_table[mb_xy]= 31;
579 for(i=1; i<s->mb_num; i++){
580 int mb_xy= s->mb_index2xy[i];
581 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
582 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
588 #endif //CONFIG_ENCODERS
590 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
591 #define tab_bias (tab_size/2)
593 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
595 for(i=0; i<tab_size; i++){
596 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
597 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
601 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
602 int xy= s->block_index[i];
603 uint16_t time_pp= s->pp_time;
604 uint16_t time_pb= s->pb_time;
607 p_mx= s->next_picture.motion_val[0][xy][0];
608 if((unsigned)(p_mx + tab_bias) < tab_size){
609 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
610 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
611 : s->direct_scale_mv[1][p_mx + tab_bias];
613 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
614 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
615 : p_mx*(time_pb - time_pp)/time_pp;
617 p_my= s->next_picture.motion_val[0][xy][1];
618 if((unsigned)(p_my + tab_bias) < tab_size){
619 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
620 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
621 : s->direct_scale_mv[1][p_my + tab_bias];
623 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
624 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
625 : p_my*(time_pb - time_pp)/time_pp;
634 * @return the mb_type
636 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
637 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
638 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
639 uint16_t time_pp= s->pp_time;
640 uint16_t time_pb= s->pb_time;
643 //FIXME avoid divides
644 // try special case with shifts for 1 and 3 B-frames?
646 if(IS_8X8(colocated_mb_type)){
647 s->mv_type = MV_TYPE_8X8;
649 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
651 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
652 } else if(IS_INTERLACED(colocated_mb_type)){
653 s->mv_type = MV_TYPE_FIELD;
655 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
656 s->field_select[0][i]= field_select;
657 s->field_select[1][i]= i;
658 if(s->top_field_first){
659 time_pp= s->pp_field_time - field_select + i;
660 time_pb= s->pb_field_time - field_select + i;
662 time_pp= s->pp_field_time + field_select - i;
663 time_pb= s->pb_field_time + field_select - i;
665 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
666 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
667 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
668 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
669 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
670 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
672 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
674 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
675 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
676 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
677 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
678 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
679 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
680 s->mv_type= MV_TYPE_16X16;
682 s->mv_type= MV_TYPE_8X8;
683 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
687 void ff_h263_update_motion_val(MpegEncContext * s){
688 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
689 //FIXME a lot of that is only needed for !low_delay
690 const int wrap = s->b8_stride;
691 const int xy = s->block_index[0];
693 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
695 if(s->mv_type != MV_TYPE_8X8){
696 int motion_x, motion_y;
700 } else if (s->mv_type == MV_TYPE_16X16) {
701 motion_x = s->mv[0][0][0];
702 motion_y = s->mv[0][0][1];
703 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
705 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
706 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
707 motion_x = (motion_x>>1) | (motion_x&1);
709 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
710 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
712 s->current_picture.ref_index[0][xy ]=
713 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
714 s->current_picture.ref_index[0][xy + wrap ]=
715 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
718 /* no update if 8X8 because it has been done during parsing */
719 s->current_picture.motion_val[0][xy][0] = motion_x;
720 s->current_picture.motion_val[0][xy][1] = motion_y;
721 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
722 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
723 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
724 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
725 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
726 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
729 if(s->encoding){ //FIXME encoding MUST be cleaned up
730 if (s->mv_type == MV_TYPE_8X8)
731 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
733 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
735 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
739 #ifdef CONFIG_ENCODERS
741 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
742 int l, bit_size, code;
747 bit_size = f_code - 1;
748 /* modulo encoding */
749 l= INT_BIT - 6 - bit_size;
752 code = (val >> bit_size) + 1;
754 return mvtab[code][1] + 1 + bit_size;
758 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
759 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
760 skip_put_bits(&s->pb,
761 h263_get_motion_length(s, x, f_code)
762 +h263_get_motion_length(s, y, f_code));
764 ff_h263_encode_motion(s, x, f_code);
765 ff_h263_encode_motion(s, y, f_code);
769 static inline int get_p_cbp(MpegEncContext * s,
770 DCTELEM block[6][64],
771 int motion_x, int motion_y){
774 if(s->flags & CODEC_FLAG_CBP_RD){
775 int best_cbpy_score= INT_MAX;
776 int best_cbpc_score= INT_MAX;
777 int cbpc = (-1), cbpy= (-1);
778 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
779 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
782 int score= inter_MCBPC_bits[i + offset] * lambda;
783 if(i&1) score += s->coded_score[5];
784 if(i&2) score += s->coded_score[4];
786 if(score < best_cbpc_score){
787 best_cbpc_score= score;
793 int score= cbpy_tab[i ^ 0xF][1] * lambda;
794 if(i&1) score += s->coded_score[3];
795 if(i&2) score += s->coded_score[2];
796 if(i&4) score += s->coded_score[1];
797 if(i&8) score += s->coded_score[0];
799 if(score < best_cbpy_score){
800 best_cbpy_score= score;
805 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
806 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
810 for (i = 0; i < 6; i++) {
811 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
812 s->block_last_index[i]= -1;
813 memset(s->block[i], 0, sizeof(DCTELEM)*64);
818 for (i = 0; i < 6; i++) {
819 if (s->block_last_index[i] >= 0)
826 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
827 int motion_x, int motion_y, int mb_type){
830 if(s->flags & CODEC_FLAG_CBP_RD){
832 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
835 if(s->coded_score[i] < 0){
836 score += s->coded_score[i];
843 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
844 zero_score-= 4; //2*MV + mb_type + cbp bit
848 if(zero_score <= score){
853 for (i = 0; i < 6; i++) {
854 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
855 s->block_last_index[i]= -1;
856 memset(s->block[i], 0, sizeof(DCTELEM)*64);
860 for (i = 0; i < 6; i++) {
861 if (s->block_last_index[i] >= 0)
868 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
869 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
873 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
874 for (i = 0; i < 6; i++) {
875 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
878 /* encode each block */
879 for (i = 0; i < 6; i++) {
880 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
884 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
885 for (i = 0; i < 6; i++) {
886 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
889 /* encode each block */
890 for (i = 0; i < 6; i++) {
891 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
897 void mpeg4_encode_mb(MpegEncContext * s,
898 DCTELEM block[6][64],
899 int motion_x, int motion_y)
901 int cbpc, cbpy, pred_x, pred_y;
902 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
903 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
904 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
905 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
906 const int dquant_code[5]= {1,0,9,2,3};
908 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
912 if(s->pict_type==B_TYPE){
913 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
914 int mb_type= mb_type_table[s->mv_dir];
921 s->last_mv[i][1][1]= 0;
925 assert(s->dquant>=-2 && s->dquant<=2);
926 assert((s->dquant&1)==0);
929 /* nothing to do if this MB was skipped in the next P Frame */
930 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
936 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
937 s->qscale -= s->dquant;
943 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
945 if ((cbp | motion_x | motion_y | mb_type) ==0) {
946 /* direct MB with MV={0,0} */
947 assert(s->dquant==0);
949 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
951 if(interleaved_stats){
959 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
960 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
961 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
962 if(cbp) put_bits(&s->pb, 6, cbp);
966 put_bits(&s->pb, 2, (s->dquant>>2)+3);
968 put_bits(&s->pb, 1, 0);
970 s->qscale -= s->dquant;
972 if(!s->progressive_sequence){
974 put_bits(&s->pb, 1, s->interlaced_dct);
975 if(mb_type) // not direct mode
976 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
979 if(interleaved_stats){
980 s->misc_bits+= get_bits_diff(s);
984 assert(s->mv_dir & MV_DIRECT);
985 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
989 assert(mb_type > 0 && mb_type < 4);
990 if(s->mv_type != MV_TYPE_FIELD){
991 if(s->mv_dir & MV_DIR_FORWARD){
992 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
993 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
994 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
995 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
998 if(s->mv_dir & MV_DIR_BACKWARD){
999 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1000 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1001 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1002 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1006 if(s->mv_dir & MV_DIR_FORWARD){
1007 put_bits(&s->pb, 1, s->field_select[0][0]);
1008 put_bits(&s->pb, 1, s->field_select[0][1]);
1010 if(s->mv_dir & MV_DIR_BACKWARD){
1011 put_bits(&s->pb, 1, s->field_select[1][0]);
1012 put_bits(&s->pb, 1, s->field_select[1][1]);
1014 if(s->mv_dir & MV_DIR_FORWARD){
1016 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
1017 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1018 s->last_mv[0][i][0]= s->mv[0][i][0];
1019 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1023 if(s->mv_dir & MV_DIR_BACKWARD){
1025 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
1026 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1027 s->last_mv[1][i][0]= s->mv[1][i][0];
1028 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1035 if(interleaved_stats){
1036 s->mv_bits+= get_bits_diff(s);
1039 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1041 if(interleaved_stats){
1042 s->p_tex_bits+= get_bits_diff(s);
1045 }else{ /* s->pict_type==B_TYPE */
1046 cbp= get_p_cbp(s, block, motion_x, motion_y);
1048 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1049 /* check if the B frames can skip it too, as we must skip it if we skip here
1050 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1051 if(s->max_b_frames>0){
1058 if(x+16 > s->width) x= s->width-16;
1059 if(y+16 > s->height) y= s->height-16;
1061 offset= x + y*s->linesize;
1062 p_pic= s->new_picture.data[0] + offset;
1065 for(i=0; i<s->max_b_frames; i++){
1068 Picture *pic= s->reordered_input_picture[i+1];
1070 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1072 b_pic= pic->data[0] + offset;
1073 if(pic->type != FF_BUFFER_TYPE_SHARED)
1074 b_pic+= INPLACE_OFFSET;
1075 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1076 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1084 if(s->mb_skipped==1){
1085 /* skip macroblock */
1086 put_bits(&s->pb, 1, 1);
1088 if(interleaved_stats){
1098 put_bits(&s->pb, 1, 0); /* mb coded */
1102 if(s->mv_type==MV_TYPE_16X16){
1103 if(s->dquant) cbpc+= 8;
1105 inter_MCBPC_bits[cbpc],
1106 inter_MCBPC_code[cbpc]);
1108 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1110 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1112 if(!s->progressive_sequence){
1114 put_bits(pb2, 1, s->interlaced_dct);
1115 put_bits(pb2, 1, 0);
1118 if(interleaved_stats){
1119 s->misc_bits+= get_bits_diff(s);
1122 /* motion vectors: 16x16 mode */
1123 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1125 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1126 motion_y - pred_y, s->f_code);
1127 }else if(s->mv_type==MV_TYPE_FIELD){
1128 if(s->dquant) cbpc+= 8;
1130 inter_MCBPC_bits[cbpc],
1131 inter_MCBPC_code[cbpc]);
1133 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1135 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1137 assert(!s->progressive_sequence);
1139 put_bits(pb2, 1, s->interlaced_dct);
1140 put_bits(pb2, 1, 1);
1142 if(interleaved_stats){
1143 s->misc_bits+= get_bits_diff(s);
1146 /* motion vectors: 16x8 interlaced mode */
1147 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1150 put_bits(&s->pb, 1, s->field_select[0][0]);
1151 put_bits(&s->pb, 1, s->field_select[0][1]);
1153 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1154 s->mv[0][0][1] - pred_y, s->f_code);
1155 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1156 s->mv[0][1][1] - pred_y, s->f_code);
1158 assert(s->mv_type==MV_TYPE_8X8);
1160 inter_MCBPC_bits[cbpc+16],
1161 inter_MCBPC_code[cbpc+16]);
1162 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1164 if(!s->progressive_sequence){
1166 put_bits(pb2, 1, s->interlaced_dct);
1169 if(interleaved_stats){
1170 s->misc_bits+= get_bits_diff(s);
1174 /* motion vectors: 8x8 mode*/
1175 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1177 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1178 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1182 if(interleaved_stats){
1183 s->mv_bits+= get_bits_diff(s);
1186 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1188 if(interleaved_stats){
1189 s->p_tex_bits+= get_bits_diff(s);
1195 int dc_diff[6]; //dc values with the dc prediction subtracted
1196 int dir[6]; //prediction direction
1197 int zigzag_last_index[6];
1198 uint8_t *scan_table[6];
1202 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1205 if(s->flags & CODEC_FLAG_AC_PRED){
1206 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1208 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1211 scan_table[i]= s->intra_scantable.permutated;
1216 for (i = 0; i < 6; i++) {
1217 if (s->block_last_index[i] >= 1)
1218 cbp |= 1 << (5 - i);
1222 if (s->pict_type == I_TYPE) {
1223 if(s->dquant) cbpc+=4;
1225 intra_MCBPC_bits[cbpc],
1226 intra_MCBPC_code[cbpc]);
1228 if(s->dquant) cbpc+=8;
1229 put_bits(&s->pb, 1, 0); /* mb coded */
1231 inter_MCBPC_bits[cbpc + 4],
1232 inter_MCBPC_code[cbpc + 4]);
1234 put_bits(pb2, 1, s->ac_pred);
1236 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1238 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1240 if(!s->progressive_sequence){
1241 put_bits(dc_pb, 1, s->interlaced_dct);
1244 if(interleaved_stats){
1245 s->misc_bits+= get_bits_diff(s);
1248 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1250 if(interleaved_stats){
1251 s->i_tex_bits+= get_bits_diff(s);
1255 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1257 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1261 void h263_encode_mb(MpegEncContext * s,
1262 DCTELEM block[6][64],
1263 int motion_x, int motion_y)
1265 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1267 int16_t rec_intradc[6];
1269 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1270 const int dquant_code[5]= {1,0,9,2,3};
1272 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1275 cbp= get_p_cbp(s, block, motion_x, motion_y);
1277 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1278 /* skip macroblock */
1279 put_bits(&s->pb, 1, 1);
1280 if(interleaved_stats){
1288 put_bits(&s->pb, 1, 0); /* mb coded */
1292 if(s->alt_inter_vlc==0 || cbpc!=3)
1294 if(s->dquant) cbpc+= 8;
1295 if(s->mv_type==MV_TYPE_16X16){
1297 inter_MCBPC_bits[cbpc],
1298 inter_MCBPC_code[cbpc]);
1300 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1302 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1304 if(interleaved_stats){
1305 s->misc_bits+= get_bits_diff(s);
1308 /* motion vectors: 16x16 mode */
1309 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1312 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1313 motion_y - pred_y, 1);
1316 h263p_encode_umotion(s, motion_x - pred_x);
1317 h263p_encode_umotion(s, motion_y - pred_y);
1318 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1319 /* To prevent Start Code emulation */
1320 put_bits(&s->pb,1,1);
1324 inter_MCBPC_bits[cbpc+16],
1325 inter_MCBPC_code[cbpc+16]);
1326 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1328 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1330 if(interleaved_stats){
1331 s->misc_bits+= get_bits_diff(s);
1335 /* motion vectors: 8x8 mode*/
1336 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1338 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1339 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1341 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1342 motion_y - pred_y, 1);
1345 h263p_encode_umotion(s, motion_x - pred_x);
1346 h263p_encode_umotion(s, motion_y - pred_y);
1347 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1348 /* To prevent Start Code emulation */
1349 put_bits(&s->pb,1,1);
1354 if(interleaved_stats){
1355 s->mv_bits+= get_bits_diff(s);
1358 assert(s->mb_intra);
1363 for(i=0; i<6; i++) {
1364 int16_t level = block[i][0];
1367 if(i<4) scale= s->y_dc_scale;
1368 else scale= s->c_dc_scale;
1370 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1374 level = (level + (scale>>1))/scale;
1376 level = (level - (scale>>1))/scale;
1378 /* AIC can change CBP */
1379 if (level == 0 && s->block_last_index[i] == 0)
1380 s->block_last_index[i] = -1;
1382 if(!s->modified_quant){
1385 else if (level > 127)
1389 block[i][0] = level;
1390 /* Reconstruction */
1391 rec_intradc[i] = scale*level + pred_dc;
1393 rec_intradc[i] |= 1;
1394 //if ((rec_intradc[i] % 2) == 0)
1395 // rec_intradc[i]++;
1397 if (rec_intradc[i] < 0)
1399 else if (rec_intradc[i] > 2047)
1400 rec_intradc[i] = 2047;
1402 /* Update AC/DC tables */
1403 *dc_ptr[i] = rec_intradc[i];
1404 if (s->block_last_index[i] >= 0)
1405 cbp |= 1 << (5 - i);
1408 for(i=0; i<6; i++) {
1410 if (s->block_last_index[i] >= 1)
1411 cbp |= 1 << (5 - i);
1416 if (s->pict_type == I_TYPE) {
1417 if(s->dquant) cbpc+=4;
1419 intra_MCBPC_bits[cbpc],
1420 intra_MCBPC_code[cbpc]);
1422 if(s->dquant) cbpc+=8;
1423 put_bits(&s->pb, 1, 0); /* mb coded */
1425 inter_MCBPC_bits[cbpc + 4],
1426 inter_MCBPC_code[cbpc + 4]);
1429 /* XXX: currently, we do not try to use ac prediction */
1430 put_bits(&s->pb, 1, 0); /* no AC prediction */
1433 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1435 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1437 if(interleaved_stats){
1438 s->misc_bits+= get_bits_diff(s);
1442 for(i=0; i<6; i++) {
1443 /* encode each block */
1444 h263_encode_block(s, block[i], i);
1446 /* Update INTRADC for decoding */
1447 if (s->h263_aic && s->mb_intra) {
1448 block[i][0] = rec_intradc[i];
1453 if(interleaved_stats){
1455 s->p_tex_bits+= get_bits_diff(s);
1458 s->i_tex_bits+= get_bits_diff(s);
1465 void ff_h263_loop_filter(MpegEncContext * s){
1467 const int linesize = s->linesize;
1468 const int uvlinesize= s->uvlinesize;
1469 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1470 uint8_t *dest_y = s->dest[0];
1471 uint8_t *dest_cb= s->dest[1];
1472 uint8_t *dest_cr= s->dest[2];
1474 // if(s->pict_type==B_TYPE && !s->readable) return;
1480 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1482 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1483 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1488 int qp_dt, qp_t, qp_tc;
1490 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1493 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1501 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1502 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1503 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1505 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1506 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1510 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1513 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1516 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1519 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1520 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1521 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1522 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1528 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1529 if(s->mb_y + 1 == s->mb_height)
1530 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1535 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1538 qp_lc= s->current_picture.qscale_table[xy-1];
1541 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1542 if(s->mb_y + 1 == s->mb_height){
1543 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1544 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1545 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1546 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1552 #ifdef CONFIG_ENCODERS
1553 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1555 int x, y, wrap, a, c, pred_dc, scale;
1558 /* find prediction */
1560 x = 2 * s->mb_x + (n & 1);
1561 y = 2 * s->mb_y + ((n & 2) >> 1);
1562 wrap = s->b8_stride;
1563 dc_val = s->dc_val[0];
1564 scale = s->y_dc_scale;
1568 wrap = s->mb_stride;
1569 dc_val = s->dc_val[n - 4 + 1];
1570 scale = s->c_dc_scale;
1575 a = dc_val[(x - 1) + (y) * wrap];
1576 c = dc_val[(x) + (y - 1) * wrap];
1578 /* No prediction outside GOB boundary */
1579 if(s->first_slice_line && n!=3){
1581 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1584 /* just DC prediction */
1585 if (a != 1024 && c != 1024)
1586 pred_dc = (a + c) >> 1;
1592 /* we assume pred is positive */
1593 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1594 *dc_val_ptr = &dc_val[x + y * wrap];
1597 #endif /* CONFIG_ENCODERS */
1599 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1601 int x, y, wrap, a, c, pred_dc, scale, i;
1602 int16_t *dc_val, *ac_val, *ac_val1;
1604 /* find prediction */
1606 x = 2 * s->mb_x + (n & 1);
1607 y = 2 * s->mb_y + (n>> 1);
1608 wrap = s->b8_stride;
1609 dc_val = s->dc_val[0];
1610 ac_val = s->ac_val[0][0];
1611 scale = s->y_dc_scale;
1615 wrap = s->mb_stride;
1616 dc_val = s->dc_val[n - 4 + 1];
1617 ac_val = s->ac_val[n - 4 + 1][0];
1618 scale = s->c_dc_scale;
1621 ac_val += ((y) * wrap + (x)) * 16;
1627 a = dc_val[(x - 1) + (y) * wrap];
1628 c = dc_val[(x) + (y - 1) * wrap];
1630 /* No prediction outside GOB boundary */
1631 if(s->first_slice_line && n!=3){
1633 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1638 if (s->h263_aic_dir) {
1639 /* left prediction */
1643 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1648 /* top prediction */
1650 ac_val -= 16 * wrap;
1652 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1658 /* just DC prediction */
1659 if (a != 1024 && c != 1024)
1660 pred_dc = (a + c) >> 1;
1667 /* we assume pred is positive */
1668 block[0]=block[0]*scale + pred_dc;
1675 /* Update AC/DC tables */
1676 dc_val[(x) + (y) * wrap] = block[0];
1680 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1683 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1686 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1690 int16_t *A, *B, *C, (*mot_val)[2];
1691 static const int off[4]= {2, 1, 1, -1};
1693 wrap = s->b8_stride;
1694 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1697 /* special case for first (slice) line */
1698 if (s->first_slice_line && block<3) {
1699 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1700 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1701 if(block==0){ //most common case
1702 if(s->mb_x == s->resync_mb_x){ //rare
1704 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1705 C = mot_val[off[block] - wrap];
1710 *px = mid_pred(A[0], 0, C[0]);
1711 *py = mid_pred(A[1], 0, C[1]);
1718 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1719 C = mot_val[off[block] - wrap];
1720 *px = mid_pred(A[0], 0, C[0]);
1721 *py = mid_pred(A[1], 0, C[1]);
1726 }else{ /* block==2*/
1727 B = mot_val[ - wrap];
1728 C = mot_val[off[block] - wrap];
1729 if(s->mb_x == s->resync_mb_x) //rare
1732 *px = mid_pred(A[0], B[0], C[0]);
1733 *py = mid_pred(A[1], B[1], C[1]);
1736 B = mot_val[ - wrap];
1737 C = mot_val[off[block] - wrap];
1738 *px = mid_pred(A[0], B[0], C[0]);
1739 *py = mid_pred(A[1], B[1], C[1]);
1744 #ifdef CONFIG_ENCODERS
1745 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1747 int range, l, bit_size, sign, code, bits;
1752 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1754 bit_size = f_code - 1;
1755 range = 1 << bit_size;
1756 /* modulo encoding */
1757 l= INT_BIT - 6 - bit_size;
1760 val= (val^sign)-sign;
1764 code = (val >> bit_size) + 1;
1765 bits = val & (range - 1);
1767 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1769 put_bits(&s->pb, bit_size, bits);
1774 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1775 static void h263p_encode_umotion(MpegEncContext * s, int val)
1785 put_bits(&s->pb, 1, 1);
1787 put_bits(&s->pb, 3, 0);
1789 put_bits(&s->pb, 3, 2);
1792 sval = ((val < 0) ? (short)(-val):(short)val);
1795 while (temp_val != 0) {
1796 temp_val = temp_val >> 1;
1802 tcode = (sval & (1 << (i-1))) >> (i-1);
1803 tcode = (tcode << 1) | 1;
1804 code = (code << 2) | tcode;
1807 code = ((code << 1) | (val < 0)) << 1;
1808 put_bits(&s->pb, (2*n_bits)+1, code);
1809 //printf("\nVal = %d\tCode = %d", sval, code);
1813 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1818 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1819 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1822 if(mv==0) len= mvtab[0][1];
1824 int val, bit_size, range, code;
1826 bit_size = f_code - 1;
1827 range = 1 << bit_size;
1833 code = (val >> bit_size) + 1;
1835 len= mvtab[code][1] + 1 + bit_size;
1837 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1841 mv_penalty[f_code][mv+MAX_MV]= len;
1845 for(f_code=MAX_FCODE; f_code>0; f_code--){
1846 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1847 fcode_tab[mv+MAX_MV]= f_code;
1851 for(mv=0; mv<MAX_MV*2+1; mv++){
1852 umv_fcode_tab[mv]= 1;
1857 #ifdef CONFIG_ENCODERS
1859 static void init_uni_dc_tab(void)
1861 int level, uni_code, uni_len;
1863 for(level=-256; level<256; level++){
1865 /* find number of bits */
1874 l= (-level) ^ ((1 << size) - 1);
1879 uni_code= DCtab_lum[size][0];
1880 uni_len = DCtab_lum[size][1];
1883 uni_code<<=size; uni_code|=l;
1886 uni_code<<=1; uni_code|=1;
1890 uni_DCtab_lum_bits[level+256]= uni_code;
1891 uni_DCtab_lum_len [level+256]= uni_len;
1894 uni_code= DCtab_chrom[size][0];
1895 uni_len = DCtab_chrom[size][1];
1898 uni_code<<=size; uni_code|=l;
1901 uni_code<<=1; uni_code|=1;
1905 uni_DCtab_chrom_bits[level+256]= uni_code;
1906 uni_DCtab_chrom_len [level+256]= uni_len;
1911 #endif //CONFIG_ENCODERS
1913 #ifdef CONFIG_ENCODERS
1914 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1915 int slevel, run, last;
1917 assert(MAX_LEVEL >= 64);
1918 assert(MAX_RUN >= 63);
1920 for(slevel=-64; slevel<64; slevel++){
1921 if(slevel==0) continue;
1922 for(run=0; run<64; run++){
1923 for(last=0; last<=1; last++){
1924 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1925 int level= slevel < 0 ? -slevel : slevel;
1926 int sign= slevel < 0 ? 1 : 0;
1927 int bits, len, code;
1930 len_tab[index]= 100;
1933 code= get_rl_index(rl, last, run, level);
1934 bits= rl->table_vlc[code][0];
1935 len= rl->table_vlc[code][1];
1936 bits=bits*2+sign; len++;
1938 if(code!=rl->n && len < len_tab[index]){
1939 bits_tab[index]= bits;
1940 len_tab [index]= len;
1944 bits= rl->table_vlc[rl->n][0];
1945 len= rl->table_vlc[rl->n][1];
1946 bits=bits*2; len++; //esc1
1947 level1= level - rl->max_level[last][run];
1949 code= get_rl_index(rl, last, run, level1);
1950 bits<<= rl->table_vlc[code][1];
1951 len += rl->table_vlc[code][1];
1952 bits += rl->table_vlc[code][0];
1953 bits=bits*2+sign; len++;
1955 if(code!=rl->n && len < len_tab[index]){
1956 bits_tab[index]= bits;
1957 len_tab [index]= len;
1963 bits= rl->table_vlc[rl->n][0];
1964 len= rl->table_vlc[rl->n][1];
1965 bits=bits*4+2; len+=2; //esc2
1966 run1 = run - rl->max_run[last][level] - 1;
1968 code= get_rl_index(rl, last, run1, level);
1969 bits<<= rl->table_vlc[code][1];
1970 len += rl->table_vlc[code][1];
1971 bits += rl->table_vlc[code][0];
1972 bits=bits*2+sign; len++;
1974 if(code!=rl->n && len < len_tab[index]){
1975 bits_tab[index]= bits;
1976 len_tab [index]= len;
1981 bits= rl->table_vlc[rl->n][0];
1982 len = rl->table_vlc[rl->n][1];
1983 bits=bits*4+3; len+=2; //esc3
1984 bits=bits*2+last; len++;
1985 bits=bits*64+run; len+=6;
1986 bits=bits*2+1; len++; //marker
1987 bits=bits*4096+(slevel&0xfff); len+=12;
1988 bits=bits*2+1; len++; //marker
1990 if(len < len_tab[index]){
1991 bits_tab[index]= bits;
1992 len_tab [index]= len;
1999 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
2000 int slevel, run, last;
2002 assert(MAX_LEVEL >= 64);
2003 assert(MAX_RUN >= 63);
2005 for(slevel=-64; slevel<64; slevel++){
2006 if(slevel==0) continue;
2007 for(run=0; run<64; run++){
2008 for(last=0; last<=1; last++){
2009 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2010 int level= slevel < 0 ? -slevel : slevel;
2011 int sign= slevel < 0 ? 1 : 0;
2012 int bits, len, code;
2014 len_tab[index]= 100;
2017 code= get_rl_index(rl, last, run, level);
2018 bits= rl->table_vlc[code][0];
2019 len= rl->table_vlc[code][1];
2020 bits=bits*2+sign; len++;
2022 if(code!=rl->n && len < len_tab[index]){
2023 if(bits_tab) bits_tab[index]= bits;
2024 len_tab [index]= len;
2027 bits= rl->table_vlc[rl->n][0];
2028 len = rl->table_vlc[rl->n][1];
2029 bits=bits*2+last; len++;
2030 bits=bits*64+run; len+=6;
2031 bits=bits*256+(level&0xff); len+=8;
2033 if(len < len_tab[index]){
2034 if(bits_tab) bits_tab[index]= bits;
2035 len_tab [index]= len;
2042 void h263_encode_init(MpegEncContext *s)
2044 static int done = 0;
2051 init_rl(&rl_inter, static_rl_table_store[0]);
2052 init_rl(&rl_intra, static_rl_table_store[1]);
2053 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2055 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2056 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2058 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2059 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2061 init_mv_penalty_and_fcode(s);
2063 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2065 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2066 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2068 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2069 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2071 s->ac_esc_length= 7+1+6+8;
2073 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2074 switch(s->codec_id){
2075 case CODEC_ID_MPEG4:
2076 s->fcode_tab= fcode_tab;
2077 s->min_qcoeff= -2048;
2078 s->max_qcoeff= 2047;
2079 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2080 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2081 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2082 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2083 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2084 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2085 s->ac_esc_length= 7+2+1+6+1+12+1;
2086 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2087 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2089 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2091 s->avctx->extradata= av_malloc(1024);
2092 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2094 if(!(s->workaround_bugs & FF_BUG_MS))
2095 mpeg4_encode_visual_object_header(s);
2096 mpeg4_encode_vol_header(s, 0, 0);
2098 // ff_mpeg4_stuffing(&s->pb); ?
2099 flush_put_bits(&s->pb);
2100 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2104 case CODEC_ID_H263P:
2106 s->fcode_tab= umv_fcode_tab;
2107 if(s->modified_quant){
2108 s->min_qcoeff= -2047;
2109 s->max_qcoeff= 2047;
2111 s->min_qcoeff= -127;
2115 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2117 if (s->h263_flv > 1) {
2118 s->min_qcoeff= -1023;
2119 s->max_qcoeff= 1023;
2121 s->min_qcoeff= -127;
2124 s->y_dc_scale_table=
2125 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2127 default: //nothing needed - default table already set in mpegvideo.c
2128 s->min_qcoeff= -127;
2130 s->y_dc_scale_table=
2131 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2136 * encodes a 8x8 block.
2137 * @param block the 8x8 block
2138 * @param n block index (0-3 are luma, 4-5 are chroma)
2140 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2142 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2146 if (s->mb_intra && !s->h263_aic) {
2149 /* 255 cannot be represented, so we clamp */
2154 /* 0 cannot be represented also */
2155 else if (level < 1) {
2159 if (level == 128) //FIXME check rv10
2160 put_bits(&s->pb, 8, 0xff);
2162 put_bits(&s->pb, 8, level);
2166 if (s->h263_aic && s->mb_intra)
2169 if(s->alt_inter_vlc && !s->mb_intra){
2171 int inter_vlc_bits=0;
2175 last_index = s->block_last_index[n];
2176 last_non_zero = i - 1;
2177 for (; i <= last_index; i++) {
2178 j = s->intra_scantable.permutated[i];
2181 run = i - last_non_zero - 1;
2182 last = (i == last_index);
2184 if(level<0) level= -level;
2186 code = get_rl_index(rl, last, run, level);
2187 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2188 inter_vlc_bits += rl->table_vlc[code][1]+1;
2189 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2191 if (code == rl->n) {
2192 inter_vlc_bits += 1+6+8-1;
2194 if (aic_code == rl_intra_aic.n) {
2195 aic_vlc_bits += 1+6+8-1;
2196 wrong_pos += run + 1;
2198 wrong_pos += wrong_run[aic_code];
2203 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2209 last_index = s->block_last_index[n];
2210 last_non_zero = i - 1;
2211 for (; i <= last_index; i++) {
2212 j = s->intra_scantable.permutated[i];
2215 run = i - last_non_zero - 1;
2216 last = (i == last_index);
2223 code = get_rl_index(rl, last, run, level);
2224 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2225 if (code == rl->n) {
2226 if(s->h263_flv <= 1){
2227 put_bits(&s->pb, 1, last);
2228 put_bits(&s->pb, 6, run);
2230 assert(slevel != 0);
2233 put_bits(&s->pb, 8, slevel & 0xff);
2235 put_bits(&s->pb, 8, 128);
2236 put_bits(&s->pb, 5, slevel & 0x1f);
2237 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2240 if(level < 64) { // 7-bit level
2241 put_bits(&s->pb, 1, 0);
2242 put_bits(&s->pb, 1, last);
2243 put_bits(&s->pb, 6, run);
2245 put_bits(&s->pb, 7, slevel & 0x7f);
2248 put_bits(&s->pb, 1, 1);
2249 put_bits(&s->pb, 1, last);
2250 put_bits(&s->pb, 6, run);
2252 put_bits(&s->pb, 11, slevel & 0x7ff);
2256 put_bits(&s->pb, 1, sign);
2264 #ifdef CONFIG_ENCODERS
2266 /***************************************************/
2268 * add mpeg4 stuffing bits (01...1)
2270 void ff_mpeg4_stuffing(PutBitContext * pbc)
2273 put_bits(pbc, 1, 0);
2274 length= (-put_bits_count(pbc))&7;
2275 if(length) put_bits(pbc, length, (1<<length)-1);
2278 /* must be called before writing the header */
2279 void ff_set_mpeg4_time(MpegEncContext * s){
2280 if(s->pict_type==B_TYPE){
2281 ff_mpeg4_init_direct_mv(s);
2283 s->last_time_base= s->time_base;
2284 s->time_base= s->time/s->avctx->time_base.den;
2288 static void mpeg4_encode_gop_header(MpegEncContext * s){
2289 int hours, minutes, seconds;
2292 put_bits(&s->pb, 16, 0);
2293 put_bits(&s->pb, 16, GOP_STARTCODE);
2295 time= s->current_picture_ptr->pts;
2296 if(s->reordered_input_picture[1])
2297 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2298 time= time*s->avctx->time_base.num;
2300 seconds= time/s->avctx->time_base.den;
2301 minutes= seconds/60; seconds %= 60;
2302 hours= minutes/60; minutes %= 60;
2305 put_bits(&s->pb, 5, hours);
2306 put_bits(&s->pb, 6, minutes);
2307 put_bits(&s->pb, 1, 1);
2308 put_bits(&s->pb, 6, seconds);
2310 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2311 put_bits(&s->pb, 1, 0); //broken link == NO
2313 s->last_time_base= time / s->avctx->time_base.den;
2315 ff_mpeg4_stuffing(&s->pb);
2318 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2319 int profile_and_level_indication;
2322 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2323 profile_and_level_indication = s->avctx->profile << 4;
2324 }else if(s->max_b_frames || s->quarter_sample){
2325 profile_and_level_indication= 0xF0; // adv simple
2327 profile_and_level_indication= 0x00; // simple
2330 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2331 profile_and_level_indication |= s->avctx->level;
2333 profile_and_level_indication |= 1; //level 1
2336 if(profile_and_level_indication>>4 == 0xF){
2344 put_bits(&s->pb, 16, 0);
2345 put_bits(&s->pb, 16, VOS_STARTCODE);
2347 put_bits(&s->pb, 8, profile_and_level_indication);
2349 put_bits(&s->pb, 16, 0);
2350 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2352 put_bits(&s->pb, 1, 1);
2353 put_bits(&s->pb, 4, vo_ver_id);
2354 put_bits(&s->pb, 3, 1); //priority
2356 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2358 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2360 ff_mpeg4_stuffing(&s->pb);
2363 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2367 if (!ENABLE_MPEG4_ENCODER) return;
2369 if(s->max_b_frames || s->quarter_sample){
2371 s->vo_type= ADV_SIMPLE_VO_TYPE;
2374 s->vo_type= SIMPLE_VO_TYPE;
2377 put_bits(&s->pb, 16, 0);
2378 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2379 put_bits(&s->pb, 16, 0);
2380 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2382 put_bits(&s->pb, 1, 0); /* random access vol */
2383 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2384 if(s->workaround_bugs & FF_BUG_MS) {
2385 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2387 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2388 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2389 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2392 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2394 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2395 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2396 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2397 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2400 if(s->workaround_bugs & FF_BUG_MS) { //
2401 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2403 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2404 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2405 put_bits(&s->pb, 1, s->low_delay);
2406 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2409 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2410 put_bits(&s->pb, 1, 1); /* marker bit */
2412 put_bits(&s->pb, 16, s->avctx->time_base.den);
2413 if (s->time_increment_bits < 1)
2414 s->time_increment_bits = 1;
2415 put_bits(&s->pb, 1, 1); /* marker bit */
2416 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2417 put_bits(&s->pb, 1, 1); /* marker bit */
2418 put_bits(&s->pb, 13, s->width); /* vol width */
2419 put_bits(&s->pb, 1, 1); /* marker bit */
2420 put_bits(&s->pb, 13, s->height); /* vol height */
2421 put_bits(&s->pb, 1, 1); /* marker bit */
2422 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2423 put_bits(&s->pb, 1, 1); /* obmc disable */
2424 if (vo_ver_id == 1) {
2425 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2427 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2430 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2431 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2434 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2435 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2439 put_bits(&s->pb, 1, s->quarter_sample);
2440 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2441 s->resync_marker= s->rtp_mode;
2442 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2443 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2444 if(s->data_partitioning){
2445 put_bits(&s->pb, 1, 0); /* no rvlc */
2448 if (vo_ver_id != 1){
2449 put_bits(&s->pb, 1, 0); /* newpred */
2450 put_bits(&s->pb, 1, 0); /* reduced res vop */
2452 put_bits(&s->pb, 1, 0); /* scalability */
2454 ff_mpeg4_stuffing(&s->pb);
2457 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2458 put_bits(&s->pb, 16, 0);
2459 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2460 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2464 /* write mpeg4 VOP header */
2465 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2468 int time_div, time_mod;
2470 if(s->pict_type==I_TYPE){
2471 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2472 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2473 mpeg4_encode_visual_object_header(s);
2474 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2475 mpeg4_encode_vol_header(s, 0, 0);
2477 if(!(s->workaround_bugs & FF_BUG_MS))
2478 mpeg4_encode_gop_header(s);
2481 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2483 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2485 put_bits(&s->pb, 16, 0); /* vop header */
2486 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2487 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2490 time_div= s->time/s->avctx->time_base.den;
2491 time_mod= s->time%s->avctx->time_base.den;
2492 time_incr= time_div - s->last_time_base;
2493 assert(time_incr >= 0);
2495 put_bits(&s->pb, 1, 1);
2497 put_bits(&s->pb, 1, 0);
2499 put_bits(&s->pb, 1, 1); /* marker */
2500 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2501 put_bits(&s->pb, 1, 1); /* marker */
2502 put_bits(&s->pb, 1, 1); /* vop coded */
2503 if ( s->pict_type == P_TYPE
2504 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2505 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2507 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2508 if(!s->progressive_sequence){
2509 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2510 put_bits(&s->pb, 1, s->alternate_scan);
2512 //FIXME sprite stuff
2514 put_bits(&s->pb, 5, s->qscale);
2516 if (s->pict_type != I_TYPE)
2517 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2518 if (s->pict_type == B_TYPE)
2519 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2520 // printf("****frame %d\n", picture_number);
2523 #endif //CONFIG_ENCODERS
2527 * encoding quantized level -> quantized diff
2528 * decoding quantized diff -> quantized level
2529 * @param n block index (0-3 are luma, 4-5 are chroma)
2530 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2532 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2534 int a, b, c, wrap, pred, scale, ret;
2537 /* find prediction */
2539 scale = s->y_dc_scale;
2541 scale = s->c_dc_scale;
2546 wrap= s->block_wrap[n];
2547 dc_val = s->dc_val[0] + s->block_index[n];
2553 b = dc_val[ - 1 - wrap];
2554 c = dc_val[ - wrap];
2556 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2557 if(s->first_slice_line && n!=3){
2559 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2561 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2562 if(n==0 || n==4 || n==5)
2566 if (abs(a - b) < abs(b - c)) {
2568 *dir_ptr = 1; /* top */
2571 *dir_ptr = 0; /* left */
2573 /* we assume pred is positive */
2574 pred = FASTDIV((pred + (scale >> 1)), scale);
2581 if(s->error_resilience>=3){
2583 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2586 if(level*scale > 2048 + scale){
2587 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2596 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2606 * @param n block index (0-3 are luma, 4-5 are chroma)
2607 * @param dir the ac prediction direction
2609 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2613 int16_t *ac_val, *ac_val1;
2614 int8_t * const qscale_table= s->current_picture.qscale_table;
2616 /* find prediction */
2617 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2621 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2622 /* left prediction */
2625 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2628 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2631 /* different qscale, we must rescale */
2633 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2637 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2638 /* top prediction */
2639 ac_val -= 16 * s->block_wrap[n];
2641 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2644 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2647 /* different qscale, we must rescale */
2649 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2656 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2660 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2664 #ifdef CONFIG_ENCODERS
2667 * encodes the dc value.
2668 * @param n block index (0-3 are luma, 4-5 are chroma)
2670 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2673 // if(level<-255 || level>255) printf("dc overflow\n");
2677 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2680 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2684 /* find number of bits */
2694 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2697 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2700 /* encode remaining bits */
2703 level = (-level) ^ ((1 << size) - 1);
2704 put_bits(&s->pb, size, level);
2706 put_bits(&s->pb, 1, 1);
2711 static inline int mpeg4_get_dc_length(int level, int n){
2713 return uni_DCtab_lum_len[level + 256];
2715 return uni_DCtab_chrom_len[level + 256];
2720 * encodes a 8x8 block
2721 * @param n block index (0-3 are luma, 4-5 are chroma)
2723 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2724 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2726 int i, last_non_zero;
2727 #if 0 //variables for the outcommented version
2728 int code, sign, last;
2733 const int last_index = s->block_last_index[n];
2735 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2736 /* mpeg4 based DC predictor */
2737 mpeg4_encode_dc(dc_pb, intra_dc, n);
2738 if(last_index<1) return;
2741 bits_tab= uni_mpeg4_intra_rl_bits;
2742 len_tab = uni_mpeg4_intra_rl_len;
2744 if(last_index<0) return;
2747 bits_tab= uni_mpeg4_inter_rl_bits;
2748 len_tab = uni_mpeg4_inter_rl_len;
2752 last_non_zero = i - 1;
2754 for (; i < last_index; i++) {
2755 int level = block[ scan_table[i] ];
2757 int run = i - last_non_zero - 1;
2759 if((level&(~127)) == 0){
2760 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2761 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2763 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);
2768 /*if(i<=last_index)*/{
2769 int level = block[ scan_table[i] ];
2770 int run = i - last_non_zero - 1;
2772 if((level&(~127)) == 0){
2773 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2774 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2776 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2780 for (; i <= last_index; i++) {
2781 const int slevel = block[ scan_table[i] ];
2784 int run = i - last_non_zero - 1;
2785 last = (i == last_index);
2792 code = get_rl_index(rl, last, run, level);
2793 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2794 if (code == rl->n) {
2796 level1 = level - rl->max_level[last][run];
2799 code = get_rl_index(rl, last, run, level1);
2800 if (code == rl->n) {
2802 put_bits(ac_pb, 1, 1);
2803 if (level > MAX_LEVEL)
2805 run1 = run - rl->max_run[last][level] - 1;
2808 code = get_rl_index(rl, last, run1, level);
2809 if (code == rl->n) {
2812 put_bits(ac_pb, 1, 1);
2813 put_bits(ac_pb, 1, last);
2814 put_bits(ac_pb, 6, run);
2815 put_bits(ac_pb, 1, 1);
2816 put_bits(ac_pb, 12, slevel & 0xfff);
2817 put_bits(ac_pb, 1, 1);
2820 put_bits(ac_pb, 1, 0);
2821 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2822 put_bits(ac_pb, 1, sign);
2826 put_bits(ac_pb, 1, 0);
2827 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2828 put_bits(ac_pb, 1, sign);
2831 put_bits(ac_pb, 1, sign);
2839 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2840 uint8_t *scan_table)
2842 int i, last_non_zero;
2845 const int last_index = s->block_last_index[n];
2848 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2849 /* mpeg4 based DC predictor */
2850 len += mpeg4_get_dc_length(intra_dc, n);
2851 if(last_index<1) return len;
2854 len_tab = uni_mpeg4_intra_rl_len;
2856 if(last_index<0) return 0;
2859 len_tab = uni_mpeg4_inter_rl_len;
2863 last_non_zero = i - 1;
2864 for (; i < last_index; i++) {
2865 int level = block[ scan_table[i] ];
2867 int run = i - last_non_zero - 1;
2869 if((level&(~127)) == 0){
2870 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2871 len += len_tab[index];
2873 len += 7+2+1+6+1+12+1;
2878 /*if(i<=last_index)*/{
2879 int level = block[ scan_table[i] ];
2880 int run = i - last_non_zero - 1;
2882 if((level&(~127)) == 0){
2883 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2884 len += len_tab[index];
2886 len += 7+2+1+6+1+12+1;
2896 /***********************************************/
2899 static VLC intra_MCBPC_vlc;
2900 static VLC inter_MCBPC_vlc;
2901 static VLC cbpy_vlc;
2903 static VLC dc_lum, dc_chrom;
2904 static VLC sprite_trajectory;
2905 static VLC mb_type_b_vlc;
2906 static VLC h263_mbtype_b_vlc;
2907 static VLC cbpc_b_vlc;
2911 /* XXX: find a better solution to handle static init */
2912 void h263_decode_init_vlc(MpegEncContext *s)
2914 static int done = 0;
2919 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2920 intra_MCBPC_bits, 1, 1,
2921 intra_MCBPC_code, 1, 1, 1);
2922 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2923 inter_MCBPC_bits, 1, 1,
2924 inter_MCBPC_code, 1, 1, 1);
2925 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2926 &cbpy_tab[0][1], 2, 1,
2927 &cbpy_tab[0][0], 2, 1, 1);
2928 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2930 &mvtab[0][0], 2, 1, 1);
2931 init_rl(&rl_inter, static_rl_table_store[0]);
2932 init_rl(&rl_intra, static_rl_table_store[1]);
2933 init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2934 init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2935 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2936 init_vlc_rl(&rl_inter, 1);
2937 init_vlc_rl(&rl_intra, 1);
2938 init_vlc_rl(&rvlc_rl_inter, 1);
2939 init_vlc_rl(&rvlc_rl_intra, 1);
2940 init_vlc_rl(&rl_intra_aic, 1);
2941 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2942 &DCtab_lum[0][1], 2, 1,
2943 &DCtab_lum[0][0], 2, 1, 1);
2944 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2945 &DCtab_chrom[0][1], 2, 1,
2946 &DCtab_chrom[0][0], 2, 1, 1);
2947 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2948 &sprite_trajectory_tab[0][1], 4, 2,
2949 &sprite_trajectory_tab[0][0], 4, 2, 1);
2950 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2951 &mb_type_b_tab[0][1], 2, 1,
2952 &mb_type_b_tab[0][0], 2, 1, 1);
2953 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2954 &h263_mbtype_b_tab[0][1], 2, 1,
2955 &h263_mbtype_b_tab[0][0], 2, 1, 1);
2956 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2957 &cbpc_b_tab[0][1], 2, 1,
2958 &cbpc_b_tab[0][0], 2, 1, 1);
2963 * Get the GOB height based on picture height.
2965 int ff_h263_get_gob_height(MpegEncContext *s){
2966 if (s->height <= 400)
2968 else if (s->height <= 800)
2974 int ff_h263_decode_mba(MpegEncContext *s)
2979 if(s->mb_num-1 <= ff_mba_max[i]) break;
2981 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2982 s->mb_x= mb_pos % s->mb_width;
2983 s->mb_y= mb_pos / s->mb_width;
2988 void ff_h263_encode_mba(MpegEncContext *s)
2993 if(s->mb_num-1 <= ff_mba_max[i]) break;
2995 mb_pos= s->mb_x + s->mb_width*s->mb_y;
2996 put_bits(&s->pb, ff_mba_length[i], mb_pos);
3000 * decodes the group of blocks header or slice header.
3001 * @return <0 if an error occured
3003 static int h263_decode_gob_header(MpegEncContext *s)
3005 unsigned int val, gfid, gob_number;
3008 /* Check for GOB Start Code */
3009 val = show_bits(&s->gb, 16);
3013 /* We have a GBSC probably with GSTUFF */
3014 skip_bits(&s->gb, 16); /* Drop the zeros */
3015 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3016 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3017 for(;left>13; left--){
3018 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3023 if(s->h263_slice_structured){
3024 if(get_bits1(&s->gb)==0)
3027 ff_h263_decode_mba(s);
3029 if(s->mb_num > 1583)
3030 if(get_bits1(&s->gb)==0)
3033 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3034 if(get_bits1(&s->gb)==0)
3036 gfid = get_bits(&s->gb, 2); /* GFID */
3038 gob_number = get_bits(&s->gb, 5); /* GN */
3040 s->mb_y= s->gob_index* gob_number;
3041 gfid = get_bits(&s->gb, 2); /* GFID */
3042 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3045 if(s->mb_y >= s->mb_height)
3054 static inline void memsetw(short *tab, int val, int n)
3061 #ifdef CONFIG_ENCODERS
3063 void ff_mpeg4_init_partitions(MpegEncContext *s)
3065 uint8_t *start= pbBufPtr(&s->pb);
3066 uint8_t *end= s->pb.buf_end;
3067 int size= end - start;
3068 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3069 int tex_size= (size - 2*pb_size)&(~3);
3071 set_put_bits_buffer_size(&s->pb, pb_size);
3072 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3073 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3076 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3078 const int pb2_len = put_bits_count(&s->pb2 );
3079 const int tex_pb_len= put_bits_count(&s->tex_pb);
3080 const int bits= put_bits_count(&s->pb);
3082 if(s->pict_type==I_TYPE){
3083 put_bits(&s->pb, 19, DC_MARKER);
3084 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3085 s->i_tex_bits+= tex_pb_len;
3087 put_bits(&s->pb, 17, MOTION_MARKER);
3088 s->misc_bits+=17 + pb2_len;
3089 s->mv_bits+= bits - s->last_bits;
3090 s->p_tex_bits+= tex_pb_len;
3093 flush_put_bits(&s->pb2);
3094 flush_put_bits(&s->tex_pb);
3096 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3097 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3098 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3099 s->last_bits= put_bits_count(&s->pb);
3102 #endif //CONFIG_ENCODERS
3104 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3105 switch(s->pict_type){
3110 return s->f_code+15;
3112 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3118 #ifdef CONFIG_ENCODERS
3120 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3122 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3124 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3125 put_bits(&s->pb, 1, 1);
3127 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3128 put_bits(&s->pb, s->quant_precision, s->qscale);
3129 put_bits(&s->pb, 1, 0); /* no HEC */
3132 #endif //CONFIG_ENCODERS
3135 * check if the next stuff is a resync marker or the end.
3138 static inline int mpeg4_is_resync(MpegEncContext *s){
3139 int bits_count= get_bits_count(&s->gb);
3140 int v= show_bits(&s->gb, 16);
3142 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3147 if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3149 skip_bits(&s->gb, 8+s->pict_type);
3150 bits_count+= 8+s->pict_type;
3151 v= show_bits(&s->gb, 16);
3154 if(bits_count + 8 >= s->gb.size_in_bits){
3156 v|= 0x7F >> (7-(bits_count&7));
3161 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3163 GetBitContext gb= s->gb;
3165 skip_bits(&s->gb, 1);
3166 align_get_bits(&s->gb);
3168 for(len=0; len<32; len++){
3169 if(get_bits1(&s->gb)) break;
3174 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3182 * decodes the next video packet.
3183 * @return <0 if something went wrong
3185 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3187 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3188 int header_extension=0, mb_num, len;
3190 /* is there enough space left for a video packet + header */
3191 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3193 for(len=0; len<32; len++){
3194 if(get_bits1(&s->gb)) break;
3197 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3198 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3202 if(s->shape != RECT_SHAPE){
3203 header_extension= get_bits1(&s->gb);
3204 //FIXME more stuff here
3207 mb_num= get_bits(&s->gb, mb_num_bits);
3208 if(mb_num>=s->mb_num){
3209 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3212 if(s->pict_type == B_TYPE){
3213 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3214 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3217 s->mb_x= mb_num % s->mb_width;
3218 s->mb_y= mb_num / s->mb_width;
3220 if(s->shape != BIN_ONLY_SHAPE){
3221 int qscale= get_bits(&s->gb, s->quant_precision);
3223 s->chroma_qscale=s->qscale= qscale;
3226 if(s->shape == RECT_SHAPE){
3227 header_extension= get_bits1(&s->gb);
3229 if(header_extension){
3233 while (get_bits1(&s->gb) != 0)
3236 check_marker(&s->gb, "before time_increment in video packed header");
3237 time_increment= get_bits(&s->gb, s->time_increment_bits);
3238 check_marker(&s->gb, "before vop_coding_type in video packed header");
3240 skip_bits(&s->gb, 2); /* vop coding type */
3241 //FIXME not rect stuff here
3243 if(s->shape != BIN_ONLY_SHAPE){
3244 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3245 //FIXME don't just ignore everything
3246 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3247 mpeg4_decode_sprite_trajectory(s, &s->gb);
3248 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3251 //FIXME reduced res stuff here
3253 if (s->pict_type != I_TYPE) {
3254 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3256 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3259 if (s->pict_type == B_TYPE) {
3260 int b_code = get_bits(&s->gb, 3);
3262 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3267 //FIXME new-pred stuff
3269 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
3274 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3276 int c_wrap, c_xy, l_wrap, l_xy;
3278 l_wrap= s->b8_stride;
3279 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3280 c_wrap= s->mb_stride;
3281 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3285 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3286 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3287 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3291 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3292 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3293 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3296 // we can't clear the MVs as they might be needed by a b frame
3297 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3298 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3299 s->last_mv[0][0][0]=
3300 s->last_mv[0][0][1]=
3301 s->last_mv[1][0][0]=
3302 s->last_mv[1][0][1]= 0;
3306 * decodes the group of blocks / video packet header.
3307 * @return <0 if no resync found
3309 int ff_h263_resync(MpegEncContext *s){
3312 if(s->codec_id==CODEC_ID_MPEG4){
3314 align_get_bits(&s->gb);
3317 if(show_bits(&s->gb, 16)==0){
3318 if(s->codec_id==CODEC_ID_MPEG4)
3319 ret= mpeg4_decode_video_packet_header(s);
3321 ret= h263_decode_gob_header(s);
3325 //OK, it's not where it is supposed to be ...
3326 s->gb= s->last_resync_gb;
3327 align_get_bits(&s->gb);
3328 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3330 for(;left>16+1+5+5; left-=8){
3331 if(show_bits(&s->gb, 16)==0){
3332 GetBitContext bak= s->gb;
3334 if(s->codec_id==CODEC_ID_MPEG4)
3335 ret= mpeg4_decode_video_packet_header(s);
3337 ret= h263_decode_gob_header(s);
3343 skip_bits(&s->gb, 8);
3350 * gets the average motion vector for a GMC MB.
3351 * @param n either 0 for the x component or 1 for y
3352 * @returns the average MV for a GMC MB
3354 static inline int get_amv(MpegEncContext *s, int n){
3355 int x, y, mb_v, sum, dx, dy, shift;
3356 int len = 1 << (s->f_code + 4);
3357 const int a= s->sprite_warping_accuracy;
3359 if(s->workaround_bugs & FF_BUG_AMV)
3360 len >>= s->quarter_sample;
3362 if(s->real_sprite_warping_points==1){
3363 if(s->divx_version==500 && s->divx_build==413)
3364 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3366 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3368 dx= s->sprite_delta[n][0];
3369 dy= s->sprite_delta[n][1];
3370 shift= s->sprite_shift[0];
3371 if(n) dy -= 1<<(shift + a + 1);
3372 else dx -= 1<<(shift + a + 1);
3373 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3376 for(y=0; y<16; y++){
3380 //XXX FIXME optimize
3381 for(x=0; x<16; x++){
3386 sum= RSHIFT(sum, a+8-s->quarter_sample);
3389 if (sum < -len) sum= -len;
3390 else if (sum >= len) sum= len-1;
3396 * decodes first partition.
3397 * @return number of MBs decoded or <0 if an error occured
3399 static int mpeg4_decode_partition_a(MpegEncContext *s){
3401 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3403 /* decode first partition */
3405 s->first_slice_line=1;
3406 for(; s->mb_y<s->mb_height; s->mb_y++){
3407 ff_init_block_index(s);
3408 for(; s->mb_x<s->mb_width; s->mb_x++){
3409 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3414 ff_update_block_index(s);
3415 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3416 s->first_slice_line=0;
3418 if(s->pict_type==I_TYPE){
3422 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3426 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3428 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3433 s->cbp_table[xy]= cbpc & 3;
3434 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3438 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3440 s->current_picture.qscale_table[xy]= s->qscale;
3442 s->mbintra_table[xy]= 1;
3445 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3447 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3451 if(dc_pred_dir) dir|=1;
3453 s->pred_dir_table[xy]= dir;
3454 }else{ /* P/S_TYPE */
3455 int mx, my, pred_x, pred_y, bits;
3456 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3457 const int stride= s->b8_stride*2;
3460 bits= show_bits(&s->gb, 17);
3461 if(bits==MOTION_MARKER){
3467 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3468 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3472 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3475 mot_val[0 ]= mot_val[2 ]=
3476 mot_val[0+stride]= mot_val[2+stride]= mx;
3477 mot_val[1 ]= mot_val[3 ]=
3478 mot_val[1+stride]= mot_val[3+stride]= my;
3480 if(s->mbintra_table[xy])
3481 ff_clean_intra_table_entries(s);
3485 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3487 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3493 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3495 s->mb_intra = ((cbpc & 4) != 0);
3498 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499 s->mbintra_table[xy]= 1;
3500 mot_val[0 ]= mot_val[2 ]=
3501 mot_val[0+stride]= mot_val[2+stride]= 0;
3502 mot_val[1 ]= mot_val[3 ]=
3503 mot_val[1+stride]= mot_val[3+stride]= 0;
3505 if(s->mbintra_table[xy])
3506 ff_clean_intra_table_entries(s);
3508 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3509 s->mcsel= get_bits1(&s->gb);
3512 if ((cbpc & 16) == 0) {
3513 /* 16x16 motion prediction */
3515 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3517 mx = h263_decode_motion(s, pred_x, s->f_code);
3521 my = h263_decode_motion(s, pred_y, s->f_code);
3524 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3528 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3531 mot_val[0 ]= mot_val[2 ] =
3532 mot_val[0+stride]= mot_val[2+stride]= mx;
3533 mot_val[1 ]= mot_val[3 ]=
3534 mot_val[1+stride]= mot_val[3+stride]= my;
3537 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3539 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3540 mx = h263_decode_motion(s, pred_x, s->f_code);
3544 my = h263_decode_motion(s, pred_y, s->f_code);
3561 * decode second partition.
3562 * @return <0 if an error occured
3564 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3566 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3568 s->mb_x= s->resync_mb_x;
3569 s->first_slice_line=1;
3570 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3571 ff_init_block_index(s);
3572 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3573 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3576 ff_update_block_index(s);
3577 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3578 s->first_slice_line=0;
3580 if(s->pict_type==I_TYPE){
3581 int ac_pred= get_bits1(&s->gb);
3582 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3584 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3588 s->cbp_table[xy]|= cbpy<<2;
3589 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3590 }else{ /* P || S_TYPE */
3591 if(IS_INTRA(s->current_picture.mb_type[xy])){
3593 int ac_pred = get_bits1(&s->gb);
3594 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3597 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3601 if(s->cbp_table[xy] & 8) {
3602 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3604 s->current_picture.qscale_table[xy]= s->qscale;
3608 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3610 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3614 if(dc_pred_dir) dir|=1;
3616 s->cbp_table[xy]&= 3; //remove dquant
3617 s->cbp_table[xy]|= cbpy<<2;
3618 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3619 s->pred_dir_table[xy]= dir;
3620 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3621 s->current_picture.qscale_table[xy]= s->qscale;
3622 s->cbp_table[xy]= 0;
3624 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3627 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3631 if(s->cbp_table[xy] & 8) {
3632 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3634 s->current_picture.qscale_table[xy]= s->qscale;
3636 s->cbp_table[xy]&= 3; //remove dquant
3637 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3641 if(mb_num >= mb_count) return 0;
3648 * decodes the first & second partition
3649 * @return <0 if error (and sets error type in the error_status_table)
3651 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3654 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3655 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3657 mb_num= mpeg4_decode_partition_a(s);
3659 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3663 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3664 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3665 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3669 s->mb_num_left= mb_num;
3671 if(s->pict_type==I_TYPE){
3672 while(show_bits(&s->gb, 9) == 1)
3673 skip_bits(&s->gb, 9);
3674 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3675 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3679 while(show_bits(&s->gb, 10) == 1)
3680 skip_bits(&s->gb, 10);
3681 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3682 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3686 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3688 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3689 if(s->pict_type==P_TYPE)
3690 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3693 if(s->pict_type==P_TYPE)
3694 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3701 * decode partition C of one MB.
3702 * @return <0 if an error occured
3704 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3707 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3709 mb_type= s->current_picture.mb_type[xy];
3710 cbp = s->cbp_table[xy];
3712 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3714 if(s->current_picture.qscale_table[xy] != s->qscale){
3715 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3718 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3721 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3722 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3724 s->mb_intra = IS_INTRA(mb_type);
3726 if (IS_SKIP(mb_type)) {
3729 s->block_last_index[i] = -1;
3730 s->mv_dir = MV_DIR_FORWARD;
3731 s->mv_type = MV_TYPE_16X16;
3732 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3739 }else if(s->mb_intra){
3740 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3741 }else if(!s->mb_intra){
3742 // s->mcsel= 0; //FIXME do we need to init that
3744 s->mv_dir = MV_DIR_FORWARD;
3745 if (IS_8X8(mb_type)) {
3746 s->mv_type = MV_TYPE_8X8;
3748 s->mv_type = MV_TYPE_16X16;
3751 } else { /* I-Frame */
3753 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3756 if (!IS_SKIP(mb_type)) {
3758 s->dsp.clear_blocks(s->block[0]);
3759 /* decode each block */
3760 for (i = 0; i < 6; i++) {
3761 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3762 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3769 /* per-MB end of slice check */
3771 if(--s->mb_num_left <= 0){
3772 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3773 if(mpeg4_is_resync(s))
3778 if(mpeg4_is_resync(s)){
3779 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3780 if(s->cbp_table[xy+delta])
3788 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3790 static void preview_obmc(MpegEncContext *s){
3791 GetBitContext gb= s->gb;
3793 int cbpc, i, pred_x, pred_y, mx, my;
3795 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3796 const int stride= s->b8_stride*2;
3799 s->block_index[i]+= 2;
3801 s->block_index[i]+= 1;
3804 assert(s->pict_type == P_TYPE);
3807 if (get_bits1(&s->gb)) {
3809 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3810 mot_val[0 ]= mot_val[2 ]=
3811 mot_val[0+stride]= mot_val[2+stride]= 0;
3812 mot_val[1 ]= mot_val[3 ]=
3813 mot_val[1+stride]= mot_val[3+stride]= 0;
3815 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3818 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3822 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3824 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3826 if(s->modified_quant){
3827 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3828 else skip_bits(&s->gb, 5);
3830 skip_bits(&s->gb, 2);
3833 if ((cbpc & 16) == 0) {
3834 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3835 /* 16x16 motion prediction */
3836 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3838 mx = h263p_decode_umotion(s, pred_x);
3840 mx = h263_decode_motion(s, pred_x, 1);
3843 my = h263p_decode_umotion(s, pred_y);
3845 my = h263_decode_motion(s, pred_y, 1);
3847 mot_val[0 ]= mot_val[2 ]=
3848 mot_val[0+stride]= mot_val[2+stride]= mx;
3849 mot_val[1 ]= mot_val[3 ]=
3850 mot_val[1+stride]= mot_val[3+stride]= my;
3852 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3854 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3856 mx = h263p_decode_umotion(s, pred_x);
3858 mx = h263_decode_motion(s, pred_x, 1);
3861 my = h263p_decode_umotion(s, pred_y);
3863 my = h263_decode_motion(s, pred_y, 1);
3864 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3865 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3874 s->block_index[i]-= 2;
3876 s->block_index[i]-= 1;
3882 static void h263_decode_dquant(MpegEncContext *s){
3883 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3885 if(s->modified_quant){
3886 if(get_bits1(&s->gb))
3887 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3889 s->qscale= get_bits(&s->gb, 5);
3891 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3892 ff_set_qscale(s, s->qscale);
3895 int ff_h263_decode_mb(MpegEncContext *s,
3896 DCTELEM block[6][64])
3898 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3900 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3902 assert(!s->h263_pred);
3904 if (s->pict_type == P_TYPE) {
3906 if (get_bits1(&s->gb)) {
3910 s->block_last_index[i] = -1;
3911 s->mv_dir = MV_DIR_FORWARD;
3912 s->mv_type = MV_TYPE_16X16;
3913 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3916 s->mb_skipped = !(s->obmc | s->loop_filter);
3919 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3920 //fprintf(stderr, "\tCBPC: %d", cbpc);
3922 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3927 s->dsp.clear_blocks(s->block[0]);
3930 s->mb_intra = ((cbpc & 4) != 0);
3931 if (s->mb_intra) goto intra;
3933 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3935 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3938 cbp = (cbpc & 3) | (cbpy << 2);
3940 h263_decode_dquant(s);
3943 s->mv_dir = MV_DIR_FORWARD;
3944 if ((cbpc & 16) == 0) {
3945 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3946 /* 16x16 motion prediction */
3947 s->mv_type = MV_TYPE_16X16;
3948 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3950 mx = h263p_decode_umotion(s, pred_x);
3952 mx = h263_decode_motion(s, pred_x, 1);
3958 my = h263p_decode_umotion(s, pred_y);
3960 my = h263_decode_motion(s, pred_y, 1);
3964 s->mv[0][0][0] = mx;
3965 s->mv[0][0][1] = my;
3967 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3968 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3970 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3971 s->mv_type = MV_TYPE_8X8;
3973 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3975 mx = h263p_decode_umotion(s, pred_x);
3977 mx = h263_decode_motion(s, pred_x, 1);
3982 my = h263p_decode_umotion(s, pred_y);
3984 my = h263_decode_motion(s, pred_y, 1);
3987 s->mv[0][i][0] = mx;
3988 s->mv[0][i][1] = my;
3989 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3990 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3996 /* decode each block */
3997 for (i = 0; i < 6; i++) {
3998 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4004 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4007 } else if(s->pict_type==B_TYPE) {
4009 const int stride= s->b8_stride;
4010 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4011 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4012 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4015 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4016 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4017 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4018 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4021 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4023 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4027 mb_type= h263_mb_type_b_map[ mb_type ];
4030 s->mb_intra = IS_INTRA(mb_type);
4031 if(HAS_CBP(mb_type)){
4032 s->dsp.clear_blocks(s->block[0]);
4033 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4035 dquant = IS_QUANT(mb_type);
4039 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4042 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4046 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4049 cbp = (cbpc & 3) | (cbpy << 2);
4053 assert(!s->mb_intra);
4055 if(IS_QUANT(mb_type)){
4056 h263_decode_dquant(s);
4059 if(IS_DIRECT(mb_type)){
4060 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4061 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4064 s->mv_type= MV_TYPE_16X16;
4067 if(USES_LIST(mb_type, 0)){
4068 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4069 s->mv_dir = MV_DIR_FORWARD;
4071 mx = h263_decode_motion(s, mx, 1);
4072 my = h263_decode_motion(s, my, 1);
4074 s->mv[0][0][0] = mx;
4075 s->mv[0][0][1] = my;
4076 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4077 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4080 if(USES_LIST(mb_type, 1)){
4081 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4082 s->mv_dir |= MV_DIR_BACKWARD;
4084 mx = h263_decode_motion(s, mx, 1);
4085 my = h263_decode_motion(s, my, 1);
4087 s->mv[1][0][0] = mx;
4088 s->mv[1][0][1] = my;
4089 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4090 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4094 s->current_picture.mb_type[xy]= mb_type;
4096 /* decode each block */
4097 for (i = 0; i < 6; i++) {
4098 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4102 } else { /* I-Frame */
4104 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4106 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4111 s->dsp.clear_blocks(s->block[0]);
4116 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4118 s->ac_pred = get_bits1(&s->gb);
4120 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4122 s->h263_aic_dir = get_bits1(&s->gb);
4127 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4129 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4132 cbp = (cbpc & 3) | (cbpy << 2);
4134 h263_decode_dquant(s);
4137 /* decode each block */
4138 for (i = 0; i < 6; i++) {
4139 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4146 /* per-MB end of slice check */
4148 int v= show_bits(&s->gb, 16);
4150 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4151 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4161 int ff_mpeg4_decode_mb(MpegEncContext *s,
4162 DCTELEM block[6][64])
4164 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4166 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4167 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4169 assert(s->h263_pred);
4171 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4173 if (get_bits1(&s->gb)) {
4177 s->block_last_index[i] = -1;
4178 s->mv_dir = MV_DIR_FORWARD;
4179 s->mv_type = MV_TYPE_16X16;
4180 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4181 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4183 s->mv[0][0][0]= get_amv(s, 0);
4184 s->mv[0][0][1]= get_amv(s, 1);
4188 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4196 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4197 //fprintf(stderr, "\tCBPC: %d", cbpc);
4199 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4204 s->dsp.clear_blocks(s->block[0]);
4206 s->mb_intra = ((cbpc & 4) != 0);
4207 if (s->mb_intra) goto intra;
4209 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4210 s->mcsel= get_bits1(&s->gb);
4212 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4214 cbp = (cbpc & 3) | (cbpy << 2);
4216 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4218 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4219 s->interlaced_dct= get_bits1(&s->gb);
4221 s->mv_dir = MV_DIR_FORWARD;
4222 if ((cbpc & 16) == 0) {
4224 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4225 /* 16x16 global motion prediction */
4226 s->mv_type = MV_TYPE_16X16;
4229 s->mv[0][0][0] = mx;
4230 s->mv[0][0][1] = my;
4231 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4232 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4233 /* 16x8 field motion prediction */
4234 s->mv_type= MV_TYPE_FIELD;
4236 s->field_select[0][0]= get_bits1(&s->gb);
4237 s->field_select[0][1]= get_bits1(&s->gb);
4239 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4242 mx = h263_decode_motion(s, pred_x, s->f_code);
4246 my = h263_decode_motion(s, pred_y/2, s->f_code);
4250 s->mv[0][i][0] = mx;
4251 s->mv[0][i][1] = my;
4254 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4255 /* 16x16 motion prediction */
4256 s->mv_type = MV_TYPE_16X16;
4257 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4258 mx = h263_decode_motion(s, pred_x, s->f_code);
4263 my = h263_decode_motion(s, pred_y, s->f_code);
4267 s->mv[0][0][0] = mx;
4268 s->mv[0][0][1] = my;
4271 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4272 s->mv_type = MV_TYPE_8X8;
4274 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4275 mx = h263_decode_motion(s, pred_x, s->f_code);
4279 my = h263_decode_motion(s, pred_y, s->f_code);
4282 s->mv[0][i][0] = mx;
4283 s->mv[0][i][1] = my;
4288 } else if(s->pict_type==B_TYPE) {
4289 int modb1; // first bit of modb
4290 int modb2; // second bit of modb
4293 s->mb_intra = 0; //B-frames never contain intra blocks
4294 s->mcsel=0; // ... true gmc blocks
4298 s->last_mv[i][0][0]=
4299 s->last_mv[i][0][1]=
4300 s->last_mv[i][1][0]=
4301 s->last_mv[i][1][1]= 0;
4305 /* if we skipped it in the future P Frame than skip it now too */
4306 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4311 s->block_last_index[i] = -1;
4313 s->mv_dir = MV_DIR_FORWARD;
4314 s->mv_type = MV_TYPE_16X16;
4319 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4323 modb1= get_bits1(&s->gb);
4325 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4328 modb2= get_bits1(&s->gb);
4329 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4331 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4334 mb_type= mb_type_b_map[ mb_type ];
4337 s->dsp.clear_blocks(s->block[0]);
4338 cbp= get_bits(&s->gb, 6);
4341 if ((!IS_DIRECT(mb_type)) && cbp) {
4342 if(get_bits1(&s->gb)){
4343 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4347 if(!s->progressive_sequence){
4349 s->interlaced_dct= get_bits1(&s->gb);
4351 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4352 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4353 mb_type &= ~MB_TYPE_16x16;
4355 if(USES_LIST(mb_type, 0)){
4356 s->field_select[0][0]= get_bits1(&s->gb);
4357 s->field_select[0][1]= get_bits1(&s->gb);
4359 if(USES_LIST(mb_type, 1)){
4360 s->field_select[1][0]= get_bits1(&s->gb);
4361 s->field_select[1][1]= get_bits1(&s->gb);
4367 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4368 s->mv_type= MV_TYPE_16X16;
4370 if(USES_LIST(mb_type, 0)){
4371 s->mv_dir = MV_DIR_FORWARD;
4373 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4374 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4375 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4376 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4379 if(USES_LIST(mb_type, 1)){
4380 s->mv_dir |= MV_DIR_BACKWARD;
4382 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4383 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4384 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4385 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4387 }else if(!IS_DIRECT(mb_type)){
4388 s->mv_type= MV_TYPE_FIELD;
4390 if(USES_LIST(mb_type, 0)){
4391 s->mv_dir = MV_DIR_FORWARD;
4394 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4395 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4396 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4397 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4401 if(USES_LIST(mb_type, 1)){
4402 s->mv_dir |= MV_DIR_BACKWARD;
4405 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4406 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4407 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4408 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4414 if(IS_DIRECT(mb_type)){
4415 if(IS_SKIP(mb_type))
4418 mx = h263_decode_motion(s, 0, 1);
4419 my = h263_decode_motion(s, 0, 1);
4422 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4423 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4425 s->current_picture.mb_type[xy]= mb_type;
4426 } else { /* I-Frame */
4428 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4430 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4438 s->ac_pred = get_bits1(&s->gb);
4440 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4442 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4444 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4446 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4449 cbp = (cbpc & 3) | (cbpy << 2);
4451 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4454 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4457 if(!s->progressive_sequence)
4458 s->interlaced_dct= get_bits1(&s->gb);
4460 s->dsp.clear_blocks(s->block[0]);
4461 /* decode each block */
4462 for (i = 0; i < 6; i++) {
4463 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4470 /* decode each block */
4471 for (i = 0; i < 6; i++) {
4472 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4478 /* per-MB end of slice check */
4479 if(s->codec_id==CODEC_ID_MPEG4){
4480 if(mpeg4_is_resync(s)){
4481 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4482 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4491 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4493 int code, val, sign, shift, l;
4494 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4501 sign = get_bits1(&s->gb);
4505 val = (val - 1) << shift;
4506 val |= get_bits(&s->gb, shift);
4513 /* modulo decoding */
4514 if (!s->h263_long_vectors) {
4515 l = INT_BIT - 5 - f_code;
4518 /* horrible h263 long vector mode */
4519 if (pred < -31 && val < -63)
4521 if (pred > 32 && val > 63)
4528 /* Decodes RVLC of H.263+ UMV */
4529 static int h263p_decode_umotion(MpegEncContext * s, int pred)
4533 if (get_bits1(&s->gb)) /* Motion difference = 0 */
4536 code = 2 + get_bits1(&s->gb);
4538 while (get_bits1(&s->gb))
4541 code += get_bits1(&s->gb);
4546 code = (sign) ? (pred - code) : (pred + code);
4548 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4554 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4557 int code, level, i, j, last, run;
4558 RLTable *rl = &rl_inter;
4559 const uint8_t *scan_table;
4560 GetBitContext gb= s->gb;
4562 scan_table = s->intra_scantable.permutated;
4563 if (s->h263_aic && s->mb_intra) {
4567 if (s->h263_aic_dir)
4568 scan_table = s->intra_v_scantable.permutated; /* left */
4570 scan_table = s->intra_h_scantable.permutated; /* top */
4572 } else if (s->mb_intra) {
4574 if(s->codec_id == CODEC_ID_RV10){
4575 #ifdef CONFIG_RV10_DECODER
4576 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4577 int component, diff;
4578 component = (n <= 3 ? 0 : n - 4 + 1);
4579 level = s->last_dc[component];
4580 if (s->rv10_first_dc_coded[component]) {
4581 diff = rv_decode_dc(s, n);
4585 level = level & 0xff; /* handle wrap round */
4586 s->last_dc[component] = level;
4588 s->rv10_first_dc_coded[component] = 1;
4591 level = get_bits(&s->gb, 8);
4597 level = get_bits(&s->gb, 8);
4598 if((level&0x7F) == 0){
4599 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4600 if(s->error_resilience >= FF_ER_COMPLIANT)
4612 if (s->mb_intra && s->h263_aic)
4614 s->block_last_index[n] = i - 1;
4619 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4621 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4624 if (code == rl->n) {
4626 if (s->h263_flv > 1) {
4627 int is11 = get_bits1(&s->gb);
4628 last = get_bits1(&s->gb);
4629 run = get_bits(&s->gb, 6);
4631 level = get_sbits(&s->gb, 11);
4633 level = get_sbits(&s->gb, 7);
4636 last = get_bits1(&s->gb);
4637 run = get_bits(&s->gb, 6);
4638 level = (int8_t)get_bits(&s->gb, 8);
4640 if (s->codec_id == CODEC_ID_RV10) {
4641 /* XXX: should patch encoder too */
4642 level = get_sbits(&s->gb, 12);
4644 level = get_bits(&s->gb, 5);
4645 level |= get_sbits(&s->gb, 6)<<5;
4650 run = rl->table_run[code];
4651 level = rl->table_level[code];
4652 last = code >= rl->last;
4653 if (get_bits1(&s->gb))
4658 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4659 //Looks like a hack but no, it's the way it is supposed to work ...
4663 memset(block, 0, sizeof(DCTELEM)*64);
4666 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4676 if (s->mb_intra && s->h263_aic) {
4677 h263_pred_acdc(s, block, n);
4680 s->block_last_index[n] = i;
4685 * decodes the dc value.
4686 * @param n block index (0-3 are luma, 4-5 are chroma)
4687 * @param dir_ptr the prediction direction will be stored here
4688 * @return the quantized dc
4690 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4695 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4697 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4698 if (code < 0 || code > 9 /* && s->nbit<9 */){
4699 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4707 level= 2*get_bits1(&s->gb)-1;
4709 if(get_bits1(&s->gb))
4710 level = get_bits(&s->gb, code-1) + (1<<(code-1));
4712 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4715 level = get_xbits(&s->gb, code);
4719 if(get_bits1(&s->gb)==0){ /* marker */
4720 if(s->error_resilience>=2){
4721 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4728 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4733 * @return <0 if an error occured
4735 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4736 int n, int coded, int intra, int rvlc)
4738 int level, i, last, run;
4741 RL_VLC_ELEM * rl_vlc;
4742 const uint8_t * scan_table;
4745 //Note intra & rvlc should be optimized away if this is inlined
4748 if(s->use_intra_dc_vlc){
4750 if(s->partitioned_frame){
4751 level = s->dc_val[0][ s->block_index[n] ];
4752 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4753 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4754 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4756 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4764 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4770 rl = &rvlc_rl_intra;
4771 rl_vlc = rvlc_rl_intra.rl_vlc[0];
4774 rl_vlc = rl_intra.rl_vlc[0];
4777 if (dc_pred_dir == 0)
4778 scan_table = s->intra_v_scantable.permutated; /* left */
4780 scan_table = s->intra_h_scantable.permutated; /* top */
4782 scan_table = s->intra_scantable.permutated;
4789 s->block_last_index[n] = i;
4792 if(rvlc) rl = &rvlc_rl_inter;
4793 else rl = &rl_inter;
4795 scan_table = s->intra_scantable.permutated;
4801 rl_vlc = rvlc_rl_inter.rl_vlc[0];
4803 rl_vlc = rl_inter.rl_vlc[0];
4806 qmul = s->qscale << 1;
4807 qadd = (s->qscale - 1) | 1;
4809 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4811 rl_vlc = rl_inter.rl_vlc[s->qscale];
4816 OPEN_READER(re, &s->gb);
4818 UPDATE_CACHE(re, &s->gb);
4819 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4823 if(SHOW_UBITS(re, &s->gb, 1)==0){
4824 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4826 }; SKIP_CACHE(re, &s->gb, 1);
4828 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4829 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4830 SKIP_COUNTER(re, &s->gb, 1+1+6);
4831 UPDATE_CACHE(re, &s->gb);
4833 if(SHOW_UBITS(re, &s->gb, 1)==0){
4834 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4836 }; SKIP_CACHE(re, &s->gb, 1);
4838 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4840 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4841 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4843 }; SKIP_CACHE(re, &s->gb, 5);
4845 level= level * qmul + qadd;
4846 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4847 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4853 cache= GET_CACHE(re, &s->gb);
4856 cache ^= 0xC0000000;
4858 if (cache&0x80000000) {
4859 if (cache&0x40000000) {
4861 SKIP_CACHE(re, &s->gb, 2);
4862 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4863 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4864 SKIP_COUNTER(re, &s->gb, 2+1+6);
4865 UPDATE_CACHE(re, &s->gb);
4868 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4870 if(SHOW_UBITS(re, &s->gb, 1)==0){
4871 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4873 }; SKIP_CACHE(re, &s->gb, 1);
4875 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4877 if(SHOW_UBITS(re, &s->gb, 1)==0){
4878 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4880 }; LAST_SKIP_CACHE(re, &s->gb, 1);
4882 SKIP_COUNTER(re, &s->gb, 1+12+1);
4886 if(s->error_resilience >= FF_ER_COMPLIANT){
4887 const int abs_level= FFABS(level);
4888 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4889 const int run1= run - rl->max_run[last][abs_level] - 1;
4890 if(abs_level <= rl->max_level[last][run]){
4891 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4894 if(s->error_resilience > FF_ER_COMPLIANT){
4895 if(abs_level <= rl->max_level[last][run]*2){
4896 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4899 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4900 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4907 if (level>0) level= level * qmul + qadd;
4908 else level= level * qmul - qadd;
4910 if((unsigned)(level + 2048) > 4095){
4911 if(s->error_resilience > FF_ER_COMPLIANT){
4912 if(level > 2560 || level<-2560){
4913 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4917 level= level<0 ? -2048 : 2047;
4924 #if MIN_CACHE_BITS < 20
4925 LAST_SKIP_BITS(re, &s->gb, 2);
4926 UPDATE_CACHE(re, &s->gb);
4928 SKIP_BITS(re, &s->gb, 2);
4930 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4931 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4932 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4933 LAST_SKIP_BITS(re, &s->gb, 1);
4937 #if MIN_CACHE_BITS < 19
4938 LAST_SKIP_BITS(re, &s->gb, 1);
4939 UPDATE_CACHE(re, &s->gb);
4941 SKIP_BITS(re, &s->gb, 1);
4943 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4945 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4946 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4947 LAST_SKIP_BITS(re, &s->gb, 1);
4952 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4953 LAST_SKIP_BITS(re, &s->gb, 1);
4958 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4962 block[scan_table[i]] = level;
4966 block[scan_table[i]] = level;
4968 CLOSE_READER(re, &s->gb);
4972 if(!s->use_intra_dc_vlc){
4973 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
4975 i -= i>>31; //if(i == -1) i=0;
4978 mpeg4_pred_ac(s, block, n, dc_pred_dir);
4980 i = 63; /* XXX: not optimal */
4983 s->block_last_index[n] = i;
4987 /* most is hardcoded. should extend to handle all h263 streams */
4988 int h263_decode_picture_header(MpegEncContext *s)
4990 int format, width, height, i;
4993 align_get_bits(&s->gb);
4995 startcode= get_bits(&s->gb, 22-8);
4997 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4998 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
5000 if(startcode == 0x20)
5004 if (startcode != 0x20) {
5005 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5008 /* temporal reference */
5009 i = get_bits(&s->gb, 8); /* picture timestamp */
5010 if( (s->picture_number&~0xFF)+i < s->picture_number)
5012 s->current_picture_ptr->pts=
5013 s->picture_number= (s->picture_number&~0xFF) + i;
5015 /* PTYPE starts here */
5016 if (get_bits1(&s->gb) != 1) {
5018 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5021 if (get_bits1(&s->gb) != 0) {
5022 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5023 return -1; /* h263 id */
5025 skip_bits1(&s->gb); /* split screen off */
5026 skip_bits1(&s->gb); /* camera off */
5027 skip_bits1(&s->gb); /* freeze picture release off */
5029 format = get_bits(&s->gb, 3);
5034 7 extended PTYPE (PLUSPTYPE)
5037 if (format != 7 && format != 6) {
5040 width = h263_format[format][0];
5041 height = h263_format[format][1];
5045 s->pict_type = I_TYPE + get_bits1(&s->gb);
5047 s->h263_long_vectors = get_bits1(&s->gb);
5049 if (get_bits1(&s->gb) != 0) {
5050 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5051 return -1; /* SAC: off */
5053 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5054 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5056 if (get_bits1(&s->gb) != 0) {
5057 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5058 return -1; /* not PB frame */
5060 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5061 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5065 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5066 s->avctx->time_base= (AVRational){1001, 30000};
5072 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5074 /* ufep other than 0 and 1 are reserved */
5077 format = get_bits(&s->gb, 3);
5078 dprintf(s->avctx, "ufep=1, format: %d\n", format);
5079 s->custom_pcf= get_bits1(&s->gb);
5080 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
5081 if (get_bits1(&s->gb) != 0) {
5082 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5084 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5085 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5086 s->loop_filter= get_bits1(&s->gb);
5087 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5089 s->h263_slice_structured= get_bits1(&s->gb);
5090 if (get_bits1(&s->gb) != 0) {
5091 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5093 if (get_bits1(&s->gb) != 0) {
5094 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5096 s->alt_inter_vlc= get_bits1(&s->gb);
5097 s->modified_quant= get_bits1(&s->gb);
5098 if(s->modified_quant)
5099 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5101 skip_bits(&s->gb, 1); /* Prevent start code emulation */
5103 skip_bits(&s->gb, 3); /* Reserved */
5104 } else if (ufep != 0) {
5105 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5110 s->pict_type = get_bits(&s->gb, 3);
5111 switch(s->pict_type){
5112 case 0: s->pict_type= I_TYPE;break;
5113 case 1: s->pict_type= P_TYPE;break;
5114 case 3: s->pict_type= B_TYPE;break;
5115 case 7: s->pict_type= I_TYPE;break; //ZYGO
5119 skip_bits(&s->gb, 2);
5120 s->no_rounding = get_bits1(&s->gb);
5121 skip_bits(&s->gb, 4);
5123 /* Get the picture dimensions */
5126 /* Custom Picture Format (CPFMT) */
5127 s->aspect_ratio_info = get_bits(&s->gb, 4);
5128 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
5133 3 - 10:11 (525-type 4:3)
5134 4 - 16:11 (CIF 16:9)
5135 5 - 40:33 (525-type 16:9)
5138 width = (get_bits(&s->gb, 9) + 1) * 4;
5140 height = get_bits(&s->gb, 9) * 4;
5141 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
5142 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5143 /* aspected dimensions */
5144 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5145 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5147 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5150 width = h263_format[format][0];
5151 height = h263_format[format][1];
5152 s->avctx->sample_aspect_ratio= (AVRational){12,11};
5154 if ((width == 0) || (height == 0))
5161 s->avctx->time_base.den= 1800000;
5162 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5163 s->avctx->time_base.num*= get_bits(&s->gb, 7);
5164 if(s->avctx->time_base.num == 0){
5165 av_log(s, AV_LOG_ERROR, "zero framerate\n");
5168 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5169 s->avctx->time_base.den /= gcd;
5170 s->avctx->time_base.num /= gcd;
5171 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5173 s->avctx->time_base= (AVRational){1001, 30000};
5178 skip_bits(&s->gb, 2); //extended Temporal reference
5183 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5186 if(s->h263_slice_structured){
5187 if (get_bits1(&s->gb) != 0) {
5188 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5190 if (get_bits1(&s->gb) != 0) {
5191 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5196 s->qscale = get_bits(&s->gb, 5);
5199 s->mb_width = (s->width + 15) / 16;
5200 s->mb_height = (s->height + 15) / 16;
5201 s->mb_num = s->mb_width * s->mb_height;
5204 while (get_bits1(&s->gb) != 0) {
5205 skip_bits(&s->gb, 8);
5208 if(s->h263_slice_structured){
5209 if (get_bits1(&s->gb) != 1) {
5210 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5214 ff_h263_decode_mba(s);
5216 if (get_bits1(&s->gb) != 1) {
5217 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5224 s->y_dc_scale_table=
5225 s->c_dc_scale_table= ff_aic_dc_scale_table;
5227 s->y_dc_scale_table=
5228 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5231 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5235 if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){
5237 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5238 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5239 for(i=0; i<13; i++){
5241 int v= get_bits(&s->gb, 8);
5242 v |= get_sbits(&s->gb, 8)<<8;
5243 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5245 av_log(s->avctx, AV_LOG_DEBUG, "\n");
5247 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5254 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5257 int a= 2<<s->sprite_warping_accuracy;
5258 int rho= 3-s->sprite_warping_accuracy;
5260 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5261 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5262 int sprite_ref[4][2];
5263 int virtual_ref[2][2];
5265 int alpha=0, beta=0;
5270 for(i=0; i<s->num_sprite_warping_points; i++){
5274 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5276 x= get_xbits(gb, length);
5278 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5280 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5282 y=get_xbits(gb, length);
5284 skip_bits1(gb); /* marker bit */
5285 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5290 while((1<<alpha)<w) alpha++;
5291 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5295 // Note, the 4th point isn't used for GMC
5296 if(s->divx_version==500 && s->divx_build==413){
5297 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5298 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5299 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5300 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5301 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5302 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5304 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5305 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5306 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5307 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5308 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5309 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5311 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5312 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5314 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5315 // perhaps it should be reordered to be more readable ...
5316 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5317 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5318 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5319 + 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);
5320 virtual_ref[0][1]= 16*vop_ref[0][1]
5321 + 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);
5322 virtual_ref[1][0]= 16*vop_ref[0][0]
5323 + 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);
5324 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5325 + 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);
5327 switch(s->num_sprite_warping_points)
5330 s->sprite_offset[0][0]= 0;
5331 s->sprite_offset[0][1]= 0;
5332 s->sprite_offset[1][0]= 0;
5333 s->sprite_offset[1][1]= 0;
5334 s->sprite_delta[0][0]= a;
5335 s->sprite_delta[0][1]= 0;
5336 s->sprite_delta[1][0]= 0;
5337 s->sprite_delta[1][1]= a;
5338 s->sprite_shift[0]= 0;
5339 s->sprite_shift[1]= 0;
5342 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5343 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5344 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5345 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5346 s->sprite_delta[0][0]= a;
5347 s->sprite_delta[0][1]= 0;
5348 s->sprite_delta[1][0]= 0;
5349 s->sprite_delta[1][1]= a;
5350 s->sprite_shift[0]= 0;
5351 s->sprite_shift[1]= 0;
5354 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5355 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5356 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5357 + (1<<(alpha+rho-1));
5358 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5359 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5360 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5361 + (1<<(alpha+rho-1));
5362 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5363 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5364 +2*w2*r*sprite_ref[0][0]
5366 + (1<<(alpha+rho+1)));
5367 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5368 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5369 +2*w2*r*sprite_ref[0][1]
5371 + (1<<(alpha+rho+1)));
5372 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5373 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5374 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5375 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5377 s->sprite_shift[0]= alpha+rho;
5378 s->sprite_shift[1]= alpha+rho+2;
5381 min_ab= FFMIN(alpha, beta);
5384 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5385 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5386 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5387 + (1<<(alpha+beta+rho-min_ab-1));
5388 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5389 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5390 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5391 + (1<<(alpha+beta+rho-min_ab-1));
5392 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5393 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5394 + 2*w2*h3*r*sprite_ref[0][0]
5396 + (1<<(alpha+beta+rho-min_ab+1));
5397 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5398 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5399 + 2*w2*h3*r*sprite_ref[0][1]
5401 + (1<<(alpha+beta+rho-min_ab+1));
5402 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5403 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5404 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5405 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5407 s->sprite_shift[0]= alpha + beta + rho - min_ab;
5408 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5411 /* try to simplify the situation */
5412 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5413 && s->sprite_delta[0][1] == 0
5414 && s->sprite_delta[1][0] == 0
5415 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5417 s->sprite_offset[0][0]>>=s->sprite_shift[0];
5418 s->sprite_offset[0][1]>>=s->sprite_shift[0];
5419 s->sprite_offset[1][0]>>=s->sprite_shift[1];
5420 s->sprite_offset[1][1]>>=s->sprite_shift[1];
5421 s->sprite_delta[0][0]= a;
5422 s->sprite_delta[0][1]= 0;
5423 s->sprite_delta[1][0]= 0;
5424 s->sprite_delta[1][1]= a;
5425 s->sprite_shift[0]= 0;
5426 s->sprite_shift[1]= 0;
5427 s->real_sprite_warping_points=1;
5430 int shift_y= 16 - s->sprite_shift[0];
5431 int shift_c= 16 - s->sprite_shift[1];
5432 //printf("shifts %d %d\n", shift_y, shift_c);
5434 s->sprite_offset[0][i]<<= shift_y;
5435 s->sprite_offset[1][i]<<= shift_c;
5436 s->sprite_delta[0][i]<<= shift_y;
5437 s->sprite_delta[1][i]<<= shift_y;
5438 s->sprite_shift[i]= 16;
5440 s->real_sprite_warping_points= s->num_sprite_warping_points;
5443 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5444 vop_ref[0][0], vop_ref[0][1],
5445 vop_ref[1][0], vop_ref[1][1],
5446 vop_ref[2][0], vop_ref[2][1],
5447 sprite_ref[0][0], sprite_ref[0][1],
5448 sprite_ref[1][0], sprite_ref[1][1],
5449 sprite_ref[2][0], sprite_ref[2][1],
5450 virtual_ref[0][0], virtual_ref[0][1],
5451 virtual_ref[1][0], virtual_ref[1][1]
5454 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5455 s->sprite_offset[0][0], s->sprite_offset[0][1],
5456 s->sprite_delta[0][0], s->sprite_delta[0][1],
5457 s->sprite_delta[1][0], s->sprite_delta[1][1],
5463 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5464 int hours, minutes, seconds;
5466 hours= get_bits(gb, 5);
5467 minutes= get_bits(gb, 6);
5469 seconds= get_bits(gb, 6);
5471 s->time_base= seconds + 60*(minutes + 60*hours);
5479 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5480 int width, height, vo_ver_id;
5483 skip_bits(gb, 1); /* random access */
5484 s->vo_type= get_bits(gb, 8);
5485 if (get_bits1(gb) != 0) { /* is_ol_id */
5486 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5487 skip_bits(gb, 3); /* vo_priority */
5491 //printf("vo type:%d\n",s->vo_type);
5492 s->aspect_ratio_info= get_bits(gb, 4);
5493 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5494 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5495 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5497 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5500 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5501 int chroma_format= get_bits(gb, 2);
5502 if(chroma_format!=1){
5503 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5505 s->low_delay= get_bits1(gb);
5506 if(get_bits1(gb)){ /* vbv parameters */
5507 get_bits(gb, 15); /* first_half_bitrate */
5508 skip_bits1(gb); /* marker */
5509 get_bits(gb, 15); /* latter_half_bitrate */
5510 skip_bits1(gb); /* marker */
5511 get_bits(gb, 15); /* first_half_vbv_buffer_size */
5512 skip_bits1(gb); /* marker */
5513 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5514 get_bits(gb, 11); /* first_half_vbv_occupancy */
5515 skip_bits1(gb); /* marker */
5516 get_bits(gb, 15); /* latter_half_vbv_occupancy */
5517 skip_bits1(gb); /* marker */
5520 // set low delay flag only once the smartest? low delay detection won't be overriden
5521 if(s->picture_number==0)
5525 s->shape = get_bits(gb, 2); /* vol shape */
5526 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5527 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5528 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5529 skip_bits(gb, 4); //video_object_layer_shape_extension
5532 check_marker(gb, "before time_increment_resolution");
5534 s->avctx->time_base.den = get_bits(gb, 16);
5535 if(!s->avctx->time_base.den){
5536 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5540 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5541 if (s->time_increment_bits < 1)
5542 s->time_increment_bits = 1;
5544 check_marker(gb, "before fixed_vop_rate");
5546 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5547 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5549 s->avctx->time_base.num = 1;
5553 if (s->shape != BIN_ONLY_SHAPE) {
5554 if (s->shape == RECT_SHAPE) {
5555 skip_bits1(gb); /* marker */
5556 width = get_bits(gb, 13);
5557 skip_bits1(gb); /* marker */
5558 height = get_bits(gb, 13);
5559 skip_bits1(gb); /* marker */
5560 if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5563 // printf("width/height: %d %d\n", width, height);
5567 s->progressive_sequence=
5568 s->progressive_frame= get_bits1(gb)^1;
5569 s->interlaced_dct=0;
5570 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5571 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5572 if (vo_ver_id == 1) {
5573 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5575 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5577 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5578 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5579 if(s->vol_sprite_usage==STATIC_SPRITE){
5580 s->sprite_width = get_bits(gb, 13);
5581 skip_bits1(gb); /* marker */
5582 s->sprite_height= get_bits(gb, 13);
5583 skip_bits1(gb); /* marker */
5584 s->sprite_left = get_bits(gb, 13);
5585 skip_bits1(gb); /* marker */
5586 s->sprite_top = get_bits(gb, 13);
5587 skip_bits1(gb); /* marker */
5589 s->num_sprite_warping_points= get_bits(gb, 6);
5590 if(s->num_sprite_warping_points > 3){
5591 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
5592 s->num_sprite_warping_points= 0;
5595 s->sprite_warping_accuracy = get_bits(gb, 2);
5596 s->sprite_brightness_change= get_bits1(gb);
5597 if(s->vol_sprite_usage==STATIC_SPRITE)
5598 s->low_latency_sprite= get_bits1(gb);
5600 // FIXME sadct disable bit if verid!=1 && shape not rect
5602 if (get_bits1(gb) == 1) { /* not_8_bit */
5603 s->quant_precision = get_bits(gb, 4); /* quant_precision */
5604 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5605 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5607 s->quant_precision = 5;
5610 // FIXME a bunch of grayscale shape things
5612 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5615 /* load default matrixes */
5616 for(i=0; i<64; i++){
5617 int j= s->dsp.idct_permutation[i];
5618 v= ff_mpeg4_default_intra_matrix[i];
5619 s->intra_matrix[j]= v;
5620 s->chroma_intra_matrix[j]= v;
5622 v= ff_mpeg4_default_non_intra_matrix[i];
5623 s->inter_matrix[j]= v;
5624 s->chroma_inter_matrix[j]= v;
5627 /* load custom intra matrix */
5630 for(i=0; i<64; i++){
5636 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5637 s->intra_matrix[j]= v;
5638 s->chroma_intra_matrix[j]= v;
5641 /* replicate last value */
5643 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5644 s->intra_matrix[j]= last;
5645 s->chroma_intra_matrix[j]= last;
5649 /* load custom non intra matrix */
5652 for(i=0; i<64; i++){
5658 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5659 s->inter_matrix[j]= v;
5660 s->chroma_inter_matrix[j]= v;
5663 /* replicate last value */
5665 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5666 s->inter_matrix[j]= last;
5667 s->chroma_inter_matrix[j]= last;
5671 // FIXME a bunch of grayscale shape things
5675 s->quarter_sample= get_bits1(gb);
5676 else s->quarter_sample=0;
5678 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5680 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5682 s->data_partitioning= get_bits1(gb);
5683 if(s->data_partitioning){
5684 s->rvlc= get_bits1(gb);
5687 if(vo_ver_id != 1) {
5688 s->new_pred= get_bits1(gb);
5690 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5691 skip_bits(gb, 2); /* requested upstream message type */
5692 skip_bits1(gb); /* newpred segment type */
5694 s->reduced_res_vop= get_bits1(gb);
5695 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5699 s->reduced_res_vop= 0;
5702 s->scalability= get_bits1(gb);
5704 if (s->scalability) {
5705 GetBitContext bak= *gb;
5707 int ref_layer_sampling_dir;
5708 int h_sampling_factor_n;
5709 int h_sampling_factor_m;
5710 int v_sampling_factor_n;
5711 int v_sampling_factor_m;
5713 s->hierachy_type= get_bits1(gb);
5714 ref_layer_id= get_bits(gb, 4);
5715 ref_layer_sampling_dir= get_bits1(gb);
5716 h_sampling_factor_n= get_bits(gb, 5);
5717 h_sampling_factor_m= get_bits(gb, 5);
5718 v_sampling_factor_n= get_bits(gb, 5);
5719 v_sampling_factor_m= get_bits(gb, 5);
5720 s->enhancement_type= get_bits1(gb);
5722 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5723 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
5725 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5730 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5732 // bin shape stuff FIXME
5739 * decodes the user data stuff in the header.
5740 * allso inits divx/xvid/lavc_version/build
5742 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5746 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5749 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5750 if(show_bits(gb, 23) == 0) break;
5751 buf[i]= get_bits(gb, 8);
5755 /* divx detection */
5756 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5758 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5760 s->divx_version= ver;
5761 s->divx_build= build;
5762 s->divx_packed= e==3 && last=='p';
5765 /* ffmpeg detection */
5766 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5768 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5770 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5772 build= (ver<<16) + (ver2<<8) + ver3;
5775 if(strcmp(buf, "ffmpeg")==0){
5776 s->lavc_build= 4600;
5780 s->lavc_build= build;
5783 /* xvid detection */
5784 e=sscanf(buf, "XviD%d", &build);
5786 s->xvid_build= build;
5789 //printf("User Data: %s\n", buf);
5793 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5794 int time_incr, time_increment;
5796 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5797 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5798 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5802 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5803 if(s->partitioned_frame)
5804 s->decode_mb= mpeg4_decode_partitioned_mb;
5806 s->decode_mb= ff_mpeg4_decode_mb;
5809 while (get_bits1(gb) != 0)
5812 check_marker(gb, "before time_increment");
5814 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5815 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5817 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5818 if(show_bits(gb, s->time_increment_bits+1)&1) break;
5821 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5824 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5825 else time_increment= get_bits(gb, s->time_increment_bits);
5827 // printf("%d %X\n", s->time_increment_bits, time_increment);
5828 //av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame);
5829 if(s->pict_type!=B_TYPE){
5830 s->last_time_base= s->time_base;
5831 s->time_base+= time_incr;
5832 s->time= s->time_base*s->avctx->time_base.den + time_increment;
5833 if(s->workaround_bugs&FF_BUG_UMP4){
5834 if(s->time < s->last_non_b_time){
5835 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5837 s->time+= s->avctx->time_base.den;
5840 s->pp_time= s->time - s->last_non_b_time;
5841 s->last_non_b_time= s->time;
5843 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5844 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5845 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5846 // printf("messed up order, maybe after seeking? skipping current b frame\n");
5847 return FRAME_SKIPPED;
5849 ff_mpeg4_init_direct_mv(s);
5851 if(s->t_frame==0) s->t_frame= s->pb_time;
5852 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5853 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5854 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5855 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5856 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5857 if(!s->progressive_sequence){
5858 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
5859 return FRAME_SKIPPED;
5862 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time);
5864 if(s->avctx->time_base.num)
5865 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5867 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5868 if(s->avctx->debug&FF_DEBUG_PTS)
5869 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5871 check_marker(gb, "before vop_coded");
5874 if (get_bits1(gb) != 1){
5875 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5876 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5877 return FRAME_SKIPPED;
5879 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5880 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5881 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5882 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5883 /* rounding type for motion estimation */
5884 s->no_rounding = get_bits1(gb);
5888 //FIXME reduced res stuff
5890 if (s->shape != RECT_SHAPE) {
5891 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5892 int width, height, hor_spat_ref, ver_spat_ref;
5894 width = get_bits(gb, 13);
5895 skip_bits1(gb); /* marker */
5896 height = get_bits(gb, 13);
5897 skip_bits1(gb); /* marker */
5898 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5899 skip_bits1(gb); /* marker */
5900 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5902 skip_bits1(gb); /* change_CR_disable */
5904 if (get_bits1(gb) != 0) {
5905 skip_bits(gb, 8); /* constant_alpha_value */
5908 //FIXME complexity estimation stuff
5910 if (s->shape != BIN_ONLY_SHAPE) {
5911 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5912 if(!s->progressive_sequence){
5913 s->top_field_first= get_bits1(gb);
5914 s->alternate_scan= get_bits1(gb);
5916 s->alternate_scan= 0;
5919 if(s->alternate_scan){
5920 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5921 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5922 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5923 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5925 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5926 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5927 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5928 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5931 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5932 mpeg4_decode_sprite_trajectory(s, gb);
5933 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5934 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5937 if (s->shape != BIN_ONLY_SHAPE) {
5938 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5940 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5941 return -1; // makes no sense to continue, as there is nothing left from the image then
5944 if (s->pict_type != I_TYPE) {
5945 s->f_code = get_bits(gb, 3); /* fcode_for */
5947 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5948 return -1; // makes no sense to continue, as the MV decoding will break very quickly
5953 if (s->pict_type == B_TYPE) {
5954 s->b_code = get_bits(gb, 3);
5958 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5959 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",
5960 s->qscale, s->f_code, s->b_code,
5961 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5962 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5963 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5964 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5967 if(!s->scalability){
5968 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5969 skip_bits1(gb); // vop shape coding type
5972 if(s->enhancement_type){
5973 int load_backward_shape= get_bits1(gb);
5974 if(load_backward_shape){
5975 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
5978 skip_bits(gb, 2); //ref_select_code
5981 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
5982 // note we cannot detect divx5 without b-frames easily (although it's buggy too)
5983 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5984 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5988 s->picture_number++; // better than pic number==0 always ;)
5990 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5991 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5993 if(s->workaround_bugs&FF_BUG_EDGE){
5994 s->h_edge_pos= s->width;
5995 s->v_edge_pos= s->height;
6001 * decode mpeg4 headers
6002 * @return <0 if no VOP found (or a damaged one)
6003 * FRAME_SKIPPED if a not coded VOP is found
6004 * 0 if a VOP is found
6006 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6010 /* search next start code */
6013 if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6015 if(get_bits(gb, 8) == 0xF0)
6016 return decode_vop_header(s, gb);
6021 if(get_bits_count(gb) >= gb->size_in_bits){
6022 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6023 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6024 return FRAME_SKIPPED; //divx bug
6026 return -1; //end of stream
6029 /* use the bits after the test */
6030 v = get_bits(gb, 8);
6031 startcode = ((startcode << 8) | v) & 0xffffffff;
6033 if((startcode&0xFFFFFF00) != 0x100)
6034 continue; //no startcode
6036 if(s->avctx->debug&FF_DEBUG_STARTCODE){
6037 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6038 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6039 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6040 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6041 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6042 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6043 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6044 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6045 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6046 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6047 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6048 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6049 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6050 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6051 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6052 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6053 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6054 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6055 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6056 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6057 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6058 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6059 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6060 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6061 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6062 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6063 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6064 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6065 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6068 if(startcode >= 0x120 && startcode <= 0x12F){
6069 if(decode_vol_header(s, gb) < 0)
6072 else if(startcode == USER_DATA_STARTCODE){
6073 decode_user_data(s, gb);
6075 else if(startcode == GOP_STARTCODE){
6076 mpeg4_decode_gop_header(s, gb);
6078 else if(startcode == VOP_STARTCODE){
6079 return decode_vop_header(s, gb);
6087 /* don't understand why they choose a different header ! */
6088 int intel_h263_decode_picture_header(MpegEncContext *s)
6092 /* picture header */
6093 if (get_bits_long(&s->gb, 22) != 0x20) {
6094 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6097 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6099 if (get_bits1(&s->gb) != 1) {
6100 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6101 return -1; /* marker */
6103 if (get_bits1(&s->gb) != 0) {
6104 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6105 return -1; /* h263 id */
6107 skip_bits1(&s->gb); /* split screen off */
6108 skip_bits1(&s->gb); /* camera off */
6109 skip_bits1(&s->gb); /* freeze picture release off */
6111 format = get_bits(&s->gb, 3);
6113 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6118 s->pict_type = I_TYPE + get_bits1(&s->gb);
6120 s->unrestricted_mv = get_bits1(&s->gb);
6121 s->h263_long_vectors = s->unrestricted_mv;
6123 if (get_bits1(&s->gb) != 0) {
6124 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6125 return -1; /* SAC: off */
6127 s->obmc= get_bits1(&s->gb);
6128 if (get_bits1(&s->gb) != 0) {
6129 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6130 return -1; /* PB frame mode */
6133 /* skip unknown header garbage */
6134 skip_bits(&s->gb, 41);
6136 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6137 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6140 while (get_bits1(&s->gb) != 0) {
6141 skip_bits(&s->gb, 8);
6145 s->y_dc_scale_table=
6146 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6148 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
6154 int flv_h263_decode_picture_header(MpegEncContext *s)
6156 int format, width, height;
6158 /* picture header */
6159 if (get_bits_long(&s->gb, 17) != 1) {
6160 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6163 format = get_bits(&s->gb, 5);
6164 if (format != 0 && format != 1) {
6165 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6168 s->h263_flv = format+1;
6169 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6170 format = get_bits(&s->gb, 3);
6173 width = get_bits(&s->gb, 8);
6174 height = get_bits(&s->gb, 8);
6177 width = get_bits(&s->gb, 16);
6178 height = get_bits(&s->gb, 16);
6204 if(avcodec_check_dimensions(s->avctx, width, height))
6209 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6210 s->dropable= s->pict_type > P_TYPE;
6212 s->pict_type = P_TYPE;
6214 skip_bits1(&s->gb); /* deblocking flag */
6215 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6219 s->unrestricted_mv = 1;
6220 s->h263_long_vectors = 0;
6223 while (get_bits1(&s->gb) != 0) {
6224 skip_bits(&s->gb, 8);
6228 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6229 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6230 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6233 s->y_dc_scale_table=
6234 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;