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