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 tis 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->frame_rate_base) /
164 s->avctx->frame_rate) & 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->frame_rate_base*1800000LL + 500LL*s->avctx->frame_rate) / ((1000LL+i)*s->avctx->frame_rate);
212 div= clip(1, div, 127);
213 error= ABS(s->avctx->frame_rate_base*1800000LL - (1000LL+i)*s->avctx->frame_rate*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->frame_rate_base /
231 (coded_frame_rate_base * (int64_t)s->avctx->frame_rate);
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 isnt funny anymore, theres more code for handling this mpeg4 mess than
527 for the actual adaptive quantization */
529 for(i=0; i<s->mb_num; i++){
530 int mb_xy= s->mb_index2xy[i];
531 odd += qscale_table[mb_xy]&1;
534 if(2*odd > s->mb_num) odd=1;
537 for(i=0; i<s->mb_num; i++){
538 int mb_xy= s->mb_index2xy[i];
539 if((qscale_table[mb_xy]&1) != odd)
540 qscale_table[mb_xy]++;
541 if(qscale_table[mb_xy] > 31)
542 qscale_table[mb_xy]= 31;
545 for(i=1; i<s->mb_num; i++){
546 int mb_xy= s->mb_index2xy[i];
547 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
548 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
549 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
555 #endif //CONFIG_ENCODERS
558 * @return the mb_type
560 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
561 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
562 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
563 int xy= s->block_index[0];
564 uint16_t time_pp= s->pp_time;
565 uint16_t time_pb= s->pb_time;
568 //FIXME avoid divides
570 if(IS_8X8(colocated_mb_type)){
571 s->mv_type = MV_TYPE_8X8;
573 xy= s->block_index[i];
574 s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
575 s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
576 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
577 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
578 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1]
579 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
581 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
582 } else if(IS_INTERLACED(colocated_mb_type)){
583 s->mv_type = MV_TYPE_FIELD;
585 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
586 if(s->top_field_first){
587 time_pp= s->pp_field_time - field_select + i;
588 time_pb= s->pb_field_time - field_select + i;
590 time_pp= s->pp_field_time + field_select - i;
591 time_pb= s->pb_field_time + field_select - i;
593 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
594 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
595 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
596 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
597 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
598 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
600 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
602 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;
603 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;
604 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]
605 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
606 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]
607 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
608 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
609 s->mv_type= MV_TYPE_16X16;
611 s->mv_type= MV_TYPE_8X8;
612 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
616 void ff_h263_update_motion_val(MpegEncContext * s){
617 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
618 //FIXME a lot of thet is only needed for !low_delay
619 const int wrap = s->b8_stride;
620 const int xy = s->block_index[0];
622 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
624 if(s->mv_type != MV_TYPE_8X8){
625 int motion_x, motion_y;
629 } else if (s->mv_type == MV_TYPE_16X16) {
630 motion_x = s->mv[0][0][0];
631 motion_y = s->mv[0][0][1];
632 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
634 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
635 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
636 motion_x = (motion_x>>1) | (motion_x&1);
638 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
639 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
641 s->current_picture.ref_index[0][xy ]=
642 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
643 s->current_picture.ref_index[0][xy + wrap ]=
644 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
647 /* no update if 8X8 because it has been done during parsing */
648 s->current_picture.motion_val[0][xy][0] = motion_x;
649 s->current_picture.motion_val[0][xy][1] = motion_y;
650 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
651 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
652 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
653 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
654 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
655 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
658 if(s->encoding){ //FIXME encoding MUST be cleaned up
659 if (s->mv_type == MV_TYPE_8X8)
660 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
662 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
664 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
668 #ifdef CONFIG_ENCODERS
670 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
671 int l, bit_size, code;
676 bit_size = f_code - 1;
677 /* modulo encoding */
678 l= INT_BIT - 6 - bit_size;
681 code = (val >> bit_size) + 1;
683 return mvtab[code][1] + 1 + bit_size;
687 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
688 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
689 skip_put_bits(&s->pb,
690 h263_get_motion_length(s, x, f_code)
691 +h263_get_motion_length(s, y, f_code));
693 ff_h263_encode_motion(s, x, f_code);
694 ff_h263_encode_motion(s, y, f_code);
698 static inline int get_p_cbp(MpegEncContext * s,
699 DCTELEM block[6][64],
700 int motion_x, int motion_y){
703 if(s->flags & CODEC_FLAG_CBP_RD){
704 int best_cbpy_score= INT_MAX;
705 int best_cbpc_score= INT_MAX;
706 int cbpc = (-1), cbpy= (-1);
707 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
708 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
711 int score= inter_MCBPC_bits[i + offset] * lambda;
712 if(i&1) score += s->coded_score[5];
713 if(i&2) score += s->coded_score[4];
715 if(score < best_cbpc_score){
716 best_cbpc_score= score;
722 int score= cbpy_tab[i ^ 0xF][1] * lambda;
723 if(i&1) score += s->coded_score[3];
724 if(i&2) score += s->coded_score[2];
725 if(i&4) score += s->coded_score[1];
726 if(i&8) score += s->coded_score[0];
728 if(score < best_cbpy_score){
729 best_cbpy_score= score;
734 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
735 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
739 for (i = 0; i < 6; i++) {
740 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
741 s->block_last_index[i]= -1;
742 memset(s->block[i], 0, sizeof(DCTELEM)*64);
747 for (i = 0; i < 6; i++) {
748 if (s->block_last_index[i] >= 0)
755 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
756 int motion_x, int motion_y, int mb_type){
759 if(s->flags & CODEC_FLAG_CBP_RD){
761 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
764 if(s->coded_score[i] < 0){
765 score += s->coded_score[i];
772 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
773 zero_score-= 4; //2*MV + mb_type + cbp bit
777 if(zero_score <= score){
782 for (i = 0; i < 6; i++) {
783 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
784 s->block_last_index[i]= -1;
785 memset(s->block[i], 0, sizeof(DCTELEM)*64);
789 for (i = 0; i < 6; i++) {
790 if (s->block_last_index[i] >= 0)
797 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
798 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
802 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
803 for (i = 0; i < 6; i++) {
804 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
807 /* encode each block */
808 for (i = 0; i < 6; i++) {
809 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
813 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
814 for (i = 0; i < 6; i++) {
815 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
818 /* encode each block */
819 for (i = 0; i < 6; i++) {
820 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
826 void mpeg4_encode_mb(MpegEncContext * s,
827 DCTELEM block[6][64],
828 int motion_x, int motion_y)
830 int cbpc, cbpy, pred_x, pred_y;
831 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
832 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
833 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
834 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
835 const int dquant_code[5]= {1,0,9,2,3};
837 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
841 if(s->pict_type==B_TYPE){
842 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
843 int mb_type= mb_type_table[s->mv_dir];
850 s->last_mv[i][1][1]= 0;
854 assert(s->dquant>=-2 && s->dquant<=2);
855 assert((s->dquant&1)==0);
858 /* nothing to do if this MB was skiped in the next P Frame */
859 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
865 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
866 s->qscale -= s->dquant;
872 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
874 if ((cbp | motion_x | motion_y | mb_type) ==0) {
875 /* direct MB with MV={0,0} */
876 assert(s->dquant==0);
878 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
880 if(interleaved_stats){
888 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
889 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
890 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
891 if(cbp) put_bits(&s->pb, 6, cbp);
895 put_bits(&s->pb, 2, (s->dquant>>2)+3);
897 put_bits(&s->pb, 1, 0);
899 s->qscale -= s->dquant;
901 if(!s->progressive_sequence){
903 put_bits(&s->pb, 1, s->interlaced_dct);
904 if(mb_type) // not diect mode
905 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
908 if(interleaved_stats){
909 s->misc_bits+= get_bits_diff(s);
913 assert(s->mv_dir & MV_DIRECT);
914 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
918 assert(mb_type > 0 && mb_type < 4);
919 if(s->mv_type != MV_TYPE_FIELD){
920 if(s->mv_dir & MV_DIR_FORWARD){
921 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
922 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
923 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
924 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
927 if(s->mv_dir & MV_DIR_BACKWARD){
928 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
929 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
930 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
931 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
935 if(s->mv_dir & MV_DIR_FORWARD){
936 put_bits(&s->pb, 1, s->field_select[0][0]);
937 put_bits(&s->pb, 1, s->field_select[0][1]);
939 if(s->mv_dir & MV_DIR_BACKWARD){
940 put_bits(&s->pb, 1, s->field_select[1][0]);
941 put_bits(&s->pb, 1, s->field_select[1][1]);
943 if(s->mv_dir & MV_DIR_FORWARD){
945 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
946 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
947 s->last_mv[0][i][0]= s->mv[0][i][0];
948 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
952 if(s->mv_dir & MV_DIR_BACKWARD){
954 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
955 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
956 s->last_mv[1][i][0]= s->mv[1][i][0];
957 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
964 if(interleaved_stats){
965 s->mv_bits+= get_bits_diff(s);
968 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
970 if(interleaved_stats){
971 s->p_tex_bits+= get_bits_diff(s);
974 }else{ /* s->pict_type==B_TYPE */
975 cbp= get_p_cbp(s, block, motion_x, motion_y);
977 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
978 /* check if the B frames can skip it too, as we must skip it if we skip here
979 why didnt they just compress the skip-mb bits instead of reusing them ?! */
980 if(s->max_b_frames>0){
987 if(x+16 > s->width) x= s->width-16;
988 if(y+16 > s->height) y= s->height-16;
990 offset= x + y*s->linesize;
991 p_pic= s->new_picture.data[0] + offset;
994 for(i=0; i<s->max_b_frames; i++){
997 Picture *pic= s->reordered_input_picture[i+1];
999 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1001 b_pic= pic->data[0] + offset + 16; //FIXME +16
1002 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1003 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1011 if(s->mb_skiped==1){
1012 /* skip macroblock */
1013 put_bits(&s->pb, 1, 1);
1015 if(interleaved_stats){
1025 put_bits(&s->pb, 1, 0); /* mb coded */
1029 if(s->mv_type==MV_TYPE_16X16){
1030 if(s->dquant) cbpc+= 8;
1032 inter_MCBPC_bits[cbpc],
1033 inter_MCBPC_code[cbpc]);
1035 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1037 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1039 if(!s->progressive_sequence){
1041 put_bits(pb2, 1, s->interlaced_dct);
1042 put_bits(pb2, 1, 0);
1045 if(interleaved_stats){
1046 s->misc_bits+= get_bits_diff(s);
1049 /* motion vectors: 16x16 mode */
1050 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1052 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1053 motion_y - pred_y, s->f_code);
1054 }else if(s->mv_type==MV_TYPE_FIELD){
1055 if(s->dquant) cbpc+= 8;
1057 inter_MCBPC_bits[cbpc],
1058 inter_MCBPC_code[cbpc]);
1060 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1062 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1064 assert(!s->progressive_sequence);
1066 put_bits(pb2, 1, s->interlaced_dct);
1067 put_bits(pb2, 1, 1);
1069 if(interleaved_stats){
1070 s->misc_bits+= get_bits_diff(s);
1073 /* motion vectors: 16x8 interlaced mode */
1074 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1077 put_bits(&s->pb, 1, s->field_select[0][0]);
1078 put_bits(&s->pb, 1, s->field_select[0][1]);
1080 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1081 s->mv[0][0][1] - pred_y, s->f_code);
1082 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1083 s->mv[0][1][1] - pred_y, s->f_code);
1085 assert(s->mv_type==MV_TYPE_8X8);
1087 inter_MCBPC_bits[cbpc+16],
1088 inter_MCBPC_code[cbpc+16]);
1089 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1091 if(!s->progressive_sequence){
1093 put_bits(pb2, 1, s->interlaced_dct);
1096 if(interleaved_stats){
1097 s->misc_bits+= get_bits_diff(s);
1101 /* motion vectors: 8x8 mode*/
1102 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1104 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1105 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1109 if(interleaved_stats){
1110 s->mv_bits+= get_bits_diff(s);
1113 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1115 if(interleaved_stats){
1116 s->p_tex_bits+= get_bits_diff(s);
1122 int dc_diff[6]; //dc values with the dc prediction subtracted
1123 int dir[6]; //prediction direction
1124 int zigzag_last_index[6];
1125 uint8_t *scan_table[6];
1129 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1132 if(s->flags & CODEC_FLAG_AC_PRED){
1133 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1135 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1138 scan_table[i]= s->intra_scantable.permutated;
1143 for (i = 0; i < 6; i++) {
1144 if (s->block_last_index[i] >= 1)
1145 cbp |= 1 << (5 - i);
1149 if (s->pict_type == I_TYPE) {
1150 if(s->dquant) cbpc+=4;
1152 intra_MCBPC_bits[cbpc],
1153 intra_MCBPC_code[cbpc]);
1155 if(s->dquant) cbpc+=8;
1156 put_bits(&s->pb, 1, 0); /* mb coded */
1158 inter_MCBPC_bits[cbpc + 4],
1159 inter_MCBPC_code[cbpc + 4]);
1161 put_bits(pb2, 1, s->ac_pred);
1163 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1165 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1167 if(!s->progressive_sequence){
1168 put_bits(dc_pb, 1, s->interlaced_dct);
1171 if(interleaved_stats){
1172 s->misc_bits+= get_bits_diff(s);
1175 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1177 if(interleaved_stats){
1178 s->i_tex_bits+= get_bits_diff(s);
1182 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1184 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1188 void h263_encode_mb(MpegEncContext * s,
1189 DCTELEM block[6][64],
1190 int motion_x, int motion_y)
1192 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1194 int16_t rec_intradc[6];
1195 uint16_t *dc_ptr[6];
1196 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1197 const int dquant_code[5]= {1,0,9,2,3};
1199 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1202 cbp= get_p_cbp(s, block, motion_x, motion_y);
1204 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1205 /* skip macroblock */
1206 put_bits(&s->pb, 1, 1);
1207 if(interleaved_stats){
1215 put_bits(&s->pb, 1, 0); /* mb coded */
1219 if(s->alt_inter_vlc==0 || cbpc!=3)
1221 if(s->dquant) cbpc+= 8;
1222 if(s->mv_type==MV_TYPE_16X16){
1224 inter_MCBPC_bits[cbpc],
1225 inter_MCBPC_code[cbpc]);
1227 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1229 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1231 if(interleaved_stats){
1232 s->misc_bits+= get_bits_diff(s);
1235 /* motion vectors: 16x16 mode */
1236 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1239 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1240 motion_y - pred_y, 1);
1243 h263p_encode_umotion(s, motion_x - pred_x);
1244 h263p_encode_umotion(s, motion_y - pred_y);
1245 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1246 /* To prevent Start Code emulation */
1247 put_bits(&s->pb,1,1);
1251 inter_MCBPC_bits[cbpc+16],
1252 inter_MCBPC_code[cbpc+16]);
1253 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1255 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1257 if(interleaved_stats){
1258 s->misc_bits+= get_bits_diff(s);
1262 /* motion vectors: 8x8 mode*/
1263 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1265 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1266 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1268 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1269 motion_y - pred_y, 1);
1272 h263p_encode_umotion(s, motion_x - pred_x);
1273 h263p_encode_umotion(s, motion_y - pred_y);
1274 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1275 /* To prevent Start Code emulation */
1276 put_bits(&s->pb,1,1);
1281 if(interleaved_stats){
1282 s->mv_bits+= get_bits_diff(s);
1285 assert(s->mb_intra);
1290 for(i=0; i<6; i++) {
1291 int16_t level = block[i][0];
1294 if(i<4) scale= s->y_dc_scale;
1295 else scale= s->c_dc_scale;
1297 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1301 level = (level + (scale>>1))/scale;
1303 level = (level - (scale>>1))/scale;
1305 /* AIC can change CBP */
1306 if (level == 0 && s->block_last_index[i] == 0)
1307 s->block_last_index[i] = -1;
1309 if(!s->modified_quant){
1312 else if (level > 127)
1316 block[i][0] = level;
1317 /* Reconstruction */
1318 rec_intradc[i] = scale*level + pred_dc;
1320 rec_intradc[i] |= 1;
1321 //if ((rec_intradc[i] % 2) == 0)
1322 // rec_intradc[i]++;
1324 if (rec_intradc[i] < 0)
1326 else if (rec_intradc[i] > 2047)
1327 rec_intradc[i] = 2047;
1329 /* Update AC/DC tables */
1330 *dc_ptr[i] = rec_intradc[i];
1331 if (s->block_last_index[i] >= 0)
1332 cbp |= 1 << (5 - i);
1335 for(i=0; i<6; i++) {
1337 if (s->block_last_index[i] >= 1)
1338 cbp |= 1 << (5 - i);
1343 if (s->pict_type == I_TYPE) {
1344 if(s->dquant) cbpc+=4;
1346 intra_MCBPC_bits[cbpc],
1347 intra_MCBPC_code[cbpc]);
1349 if(s->dquant) cbpc+=8;
1350 put_bits(&s->pb, 1, 0); /* mb coded */
1352 inter_MCBPC_bits[cbpc + 4],
1353 inter_MCBPC_code[cbpc + 4]);
1356 /* XXX: currently, we do not try to use ac prediction */
1357 put_bits(&s->pb, 1, 0); /* no AC prediction */
1360 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1362 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1364 if(interleaved_stats){
1365 s->misc_bits+= get_bits_diff(s);
1369 for(i=0; i<6; i++) {
1370 /* encode each block */
1371 h263_encode_block(s, block[i], i);
1373 /* Update INTRADC for decoding */
1374 if (s->h263_aic && s->mb_intra) {
1375 block[i][0] = rec_intradc[i];
1380 if(interleaved_stats){
1382 s->p_tex_bits+= get_bits_diff(s);
1385 s->i_tex_bits+= get_bits_diff(s);
1392 void ff_h263_loop_filter(MpegEncContext * s){
1394 const int linesize = s->linesize;
1395 const int uvlinesize= s->uvlinesize;
1396 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1397 uint8_t *dest_y = s->dest[0];
1398 uint8_t *dest_cb= s->dest[1];
1399 uint8_t *dest_cr= s->dest[2];
1401 // if(s->pict_type==B_TYPE && !s->readable) return;
1407 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1409 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1410 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1415 int qp_dt, qp_t, qp_tc;
1417 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1420 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1428 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1429 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1430 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1432 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1433 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1437 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1440 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1443 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1446 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1447 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1448 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1449 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1455 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1456 if(s->mb_y + 1 == s->mb_height)
1457 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1462 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1465 qp_lc= s->current_picture.qscale_table[xy-1];
1468 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1469 if(s->mb_y + 1 == s->mb_height){
1470 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1471 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1472 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1473 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1479 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1481 int x, y, wrap, a, c, pred_dc, scale;
1482 int16_t *dc_val, *ac_val;
1484 /* find prediction */
1486 x = 2 * s->mb_x + (n & 1);
1487 y = 2 * s->mb_y + ((n & 2) >> 1);
1488 wrap = s->b8_stride;
1489 dc_val = s->dc_val[0];
1490 ac_val = s->ac_val[0][0];
1491 scale = s->y_dc_scale;
1495 wrap = s->mb_stride;
1496 dc_val = s->dc_val[n - 4 + 1];
1497 ac_val = s->ac_val[n - 4 + 1][0];
1498 scale = s->c_dc_scale;
1503 a = dc_val[(x - 1) + (y) * wrap];
1504 c = dc_val[(x) + (y - 1) * wrap];
1506 /* No prediction outside GOB boundary */
1507 if(s->first_slice_line && n!=3){
1509 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1512 /* just DC prediction */
1513 if (a != 1024 && c != 1024)
1514 pred_dc = (a + c) >> 1;
1520 /* we assume pred is positive */
1521 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1522 *dc_val_ptr = &dc_val[x + y * wrap];
1526 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1528 int x, y, wrap, a, c, pred_dc, scale, i;
1529 int16_t *dc_val, *ac_val, *ac_val1;
1531 /* find prediction */
1533 x = 2 * s->mb_x + (n & 1);
1534 y = 2 * s->mb_y + (n>> 1);
1535 wrap = s->b8_stride;
1536 dc_val = s->dc_val[0];
1537 ac_val = s->ac_val[0][0];
1538 scale = s->y_dc_scale;
1542 wrap = s->mb_stride;
1543 dc_val = s->dc_val[n - 4 + 1];
1544 ac_val = s->ac_val[n - 4 + 1][0];
1545 scale = s->c_dc_scale;
1548 ac_val += ((y) * wrap + (x)) * 16;
1554 a = dc_val[(x - 1) + (y) * wrap];
1555 c = dc_val[(x) + (y - 1) * wrap];
1557 /* No prediction outside GOB boundary */
1558 if(s->first_slice_line && n!=3){
1560 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1565 if (s->h263_aic_dir) {
1566 /* left prediction */
1570 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1575 /* top prediction */
1577 ac_val -= 16 * wrap;
1579 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1585 /* just DC prediction */
1586 if (a != 1024 && c != 1024)
1587 pred_dc = (a + c) >> 1;
1594 /* we assume pred is positive */
1595 block[0]=block[0]*scale + pred_dc;
1602 /* Update AC/DC tables */
1603 dc_val[(x) + (y) * wrap] = block[0];
1607 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1610 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1613 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1617 int16_t *A, *B, *C, (*mot_val)[2];
1618 static const int off[4]= {2, 1, 1, -1};
1620 wrap = s->b8_stride;
1621 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1624 /* special case for first (slice) line */
1625 if (s->first_slice_line && block<3) {
1626 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1627 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1628 if(block==0){ //most common case
1629 if(s->mb_x == s->resync_mb_x){ //rare
1631 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1632 C = mot_val[off[block] - wrap];
1637 *px = mid_pred(A[0], 0, C[0]);
1638 *py = mid_pred(A[1], 0, C[1]);
1645 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1646 C = mot_val[off[block] - wrap];
1647 *px = mid_pred(A[0], 0, C[0]);
1648 *py = mid_pred(A[1], 0, C[1]);
1653 }else{ /* block==2*/
1654 B = mot_val[ - wrap];
1655 C = mot_val[off[block] - wrap];
1656 if(s->mb_x == s->resync_mb_x) //rare
1659 *px = mid_pred(A[0], B[0], C[0]);
1660 *py = mid_pred(A[1], B[1], C[1]);
1663 B = mot_val[ - wrap];
1664 C = mot_val[off[block] - wrap];
1665 *px = mid_pred(A[0], B[0], C[0]);
1666 *py = mid_pred(A[1], B[1], C[1]);
1671 #ifdef CONFIG_ENCODERS
1672 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1674 int range, l, bit_size, sign, code, bits;
1679 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1681 bit_size = f_code - 1;
1682 range = 1 << bit_size;
1683 /* modulo encoding */
1684 l= INT_BIT - 6 - bit_size;
1687 val= (val^sign)-sign;
1691 code = (val >> bit_size) + 1;
1692 bits = val & (range - 1);
1694 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1696 put_bits(&s->pb, bit_size, bits);
1701 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1702 static void h263p_encode_umotion(MpegEncContext * s, int val)
1712 put_bits(&s->pb, 1, 1);
1714 put_bits(&s->pb, 3, 0);
1716 put_bits(&s->pb, 3, 2);
1719 sval = ((val < 0) ? (short)(-val):(short)val);
1722 while (temp_val != 0) {
1723 temp_val = temp_val >> 1;
1729 tcode = (sval & (1 << (i-1))) >> (i-1);
1730 tcode = (tcode << 1) | 1;
1731 code = (code << 2) | tcode;
1734 code = ((code << 1) | (val < 0)) << 1;
1735 put_bits(&s->pb, (2*n_bits)+1, code);
1736 //printf("\nVal = %d\tCode = %d", sval, code);
1740 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1745 if(mv_penalty==NULL)
1746 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1748 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1749 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1752 if(mv==0) len= mvtab[0][1];
1754 int val, bit_size, range, code;
1756 bit_size = f_code - 1;
1757 range = 1 << bit_size;
1763 code = (val >> bit_size) + 1;
1765 len= mvtab[code][1] + 1 + bit_size;
1767 len= mvtab[32][1] + 2 + bit_size;
1771 mv_penalty[f_code][mv+MAX_MV]= len;
1775 for(f_code=MAX_FCODE; f_code>0; f_code--){
1776 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1777 fcode_tab[mv+MAX_MV]= f_code;
1781 for(mv=0; mv<MAX_MV*2+1; mv++){
1782 umv_fcode_tab[mv]= 1;
1787 #ifdef CONFIG_ENCODERS
1789 static void init_uni_dc_tab(void)
1791 int level, uni_code, uni_len;
1793 for(level=-256; level<256; level++){
1795 /* find number of bits */
1804 l= (-level) ^ ((1 << size) - 1);
1809 uni_code= DCtab_lum[size][0];
1810 uni_len = DCtab_lum[size][1];
1813 uni_code<<=size; uni_code|=l;
1816 uni_code<<=1; uni_code|=1;
1820 uni_DCtab_lum_bits[level+256]= uni_code;
1821 uni_DCtab_lum_len [level+256]= uni_len;
1824 uni_code= DCtab_chrom[size][0];
1825 uni_len = DCtab_chrom[size][1];
1828 uni_code<<=size; uni_code|=l;
1831 uni_code<<=1; uni_code|=1;
1835 uni_DCtab_chrom_bits[level+256]= uni_code;
1836 uni_DCtab_chrom_len [level+256]= uni_len;
1841 #endif //CONFIG_ENCODERS
1843 #ifdef CONFIG_ENCODERS
1844 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1845 int slevel, run, last;
1847 assert(MAX_LEVEL >= 64);
1848 assert(MAX_RUN >= 63);
1850 for(slevel=-64; slevel<64; slevel++){
1851 if(slevel==0) continue;
1852 for(run=0; run<64; run++){
1853 for(last=0; last<=1; last++){
1854 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1855 int level= slevel < 0 ? -slevel : slevel;
1856 int sign= slevel < 0 ? 1 : 0;
1857 int bits, len, code;
1860 len_tab[index]= 100;
1863 code= get_rl_index(rl, last, run, level);
1864 bits= rl->table_vlc[code][0];
1865 len= rl->table_vlc[code][1];
1866 bits=bits*2+sign; len++;
1868 if(code!=rl->n && len < len_tab[index]){
1869 bits_tab[index]= bits;
1870 len_tab [index]= len;
1874 bits= rl->table_vlc[rl->n][0];
1875 len= rl->table_vlc[rl->n][1];
1876 bits=bits*2; len++; //esc1
1877 level1= level - rl->max_level[last][run];
1879 code= get_rl_index(rl, last, run, level1);
1880 bits<<= rl->table_vlc[code][1];
1881 len += rl->table_vlc[code][1];
1882 bits += rl->table_vlc[code][0];
1883 bits=bits*2+sign; len++;
1885 if(code!=rl->n && len < len_tab[index]){
1886 bits_tab[index]= bits;
1887 len_tab [index]= len;
1893 bits= rl->table_vlc[rl->n][0];
1894 len= rl->table_vlc[rl->n][1];
1895 bits=bits*4+2; len+=2; //esc2
1896 run1 = run - rl->max_run[last][level] - 1;
1898 code= get_rl_index(rl, last, run1, level);
1899 bits<<= rl->table_vlc[code][1];
1900 len += rl->table_vlc[code][1];
1901 bits += rl->table_vlc[code][0];
1902 bits=bits*2+sign; len++;
1904 if(code!=rl->n && len < len_tab[index]){
1905 bits_tab[index]= bits;
1906 len_tab [index]= len;
1911 bits= rl->table_vlc[rl->n][0];
1912 len = rl->table_vlc[rl->n][1];
1913 bits=bits*4+3; len+=2; //esc3
1914 bits=bits*2+last; len++;
1915 bits=bits*64+run; len+=6;
1916 bits=bits*2+1; len++; //marker
1917 bits=bits*4096+(slevel&0xfff); len+=12;
1918 bits=bits*2+1; len++; //marker
1920 if(len < len_tab[index]){
1921 bits_tab[index]= bits;
1922 len_tab [index]= len;
1929 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1930 int slevel, run, last;
1932 assert(MAX_LEVEL >= 64);
1933 assert(MAX_RUN >= 63);
1935 for(slevel=-64; slevel<64; slevel++){
1936 if(slevel==0) continue;
1937 for(run=0; run<64; run++){
1938 for(last=0; last<=1; last++){
1939 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1940 int level= slevel < 0 ? -slevel : slevel;
1941 int sign= slevel < 0 ? 1 : 0;
1942 int bits, len, code;
1944 len_tab[index]= 100;
1947 code= get_rl_index(rl, last, run, level);
1948 bits= rl->table_vlc[code][0];
1949 len= rl->table_vlc[code][1];
1950 bits=bits*2+sign; len++;
1952 if(code!=rl->n && len < len_tab[index]){
1953 if(bits_tab) bits_tab[index]= bits;
1954 len_tab [index]= len;
1957 bits= rl->table_vlc[rl->n][0];
1958 len = rl->table_vlc[rl->n][1];
1959 bits=bits*2+last; len++;
1960 bits=bits*64+run; len+=6;
1961 bits=bits*256+(level&0xff); len+=8;
1963 if(len < len_tab[index]){
1964 if(bits_tab) bits_tab[index]= bits;
1965 len_tab [index]= len;
1972 void h263_encode_init(MpegEncContext *s)
1974 static int done = 0;
1981 init_rl(&rl_inter, 1);
1982 init_rl(&rl_intra, 1);
1983 init_rl(&rl_intra_aic, 1);
1985 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1986 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1988 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1989 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
1991 init_mv_penalty_and_fcode(s);
1993 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1995 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
1996 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1998 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
1999 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2001 s->ac_esc_length= 7+1+6+8;
2003 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2004 switch(s->codec_id){
2005 case CODEC_ID_MPEG4:
2006 s->fcode_tab= fcode_tab;
2007 s->min_qcoeff= -2048;
2008 s->max_qcoeff= 2047;
2009 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2010 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2011 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2012 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2013 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2014 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2015 s->ac_esc_length= 7+2+1+6+1+12+1;
2016 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2017 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2019 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2021 s->avctx->extradata= av_malloc(1024);
2022 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2024 if(!(s->workaround_bugs & FF_BUG_MS))
2025 mpeg4_encode_visual_object_header(s);
2026 mpeg4_encode_vol_header(s, 0, 0);
2028 // ff_mpeg4_stuffing(&s->pb); ?
2029 flush_put_bits(&s->pb);
2030 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2034 case CODEC_ID_H263P:
2036 s->fcode_tab= umv_fcode_tab;
2037 if(s->modified_quant){
2038 s->min_qcoeff= -2047;
2039 s->max_qcoeff= 2047;
2041 s->min_qcoeff= -127;
2045 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2047 if (s->h263_flv > 1) {
2048 s->min_qcoeff= -1023;
2049 s->max_qcoeff= 1023;
2051 s->min_qcoeff= -127;
2054 s->y_dc_scale_table=
2055 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2057 default: //nothing needed default table allready set in mpegvideo.c
2058 s->min_qcoeff= -127;
2060 s->y_dc_scale_table=
2061 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2066 * encodes a 8x8 block.
2067 * @param block the 8x8 block
2068 * @param n block index (0-3 are luma, 4-5 are chroma)
2070 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2072 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2076 if (s->mb_intra && !s->h263_aic) {
2079 /* 255 cannot be represented, so we clamp */
2084 /* 0 cannot be represented also */
2085 else if (level < 1) {
2089 if (level == 128) //FIXME check rv10
2090 put_bits(&s->pb, 8, 0xff);
2092 put_bits(&s->pb, 8, level);
2096 if (s->h263_aic && s->mb_intra)
2099 if(s->alt_inter_vlc && !s->mb_intra){
2101 int inter_vlc_bits=0;
2105 last_index = s->block_last_index[n];
2106 last_non_zero = i - 1;
2107 for (; i <= last_index; i++) {
2108 j = s->intra_scantable.permutated[i];
2111 run = i - last_non_zero - 1;
2112 last = (i == last_index);
2114 if(level<0) level= -level;
2116 code = get_rl_index(rl, last, run, level);
2117 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2118 inter_vlc_bits += rl->table_vlc[code][1]+1;
2119 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2121 if (code == rl->n) {
2122 inter_vlc_bits += 1+6+8-1;
2124 if (aic_code == rl_intra_aic.n) {
2125 aic_vlc_bits += 1+6+8-1;
2126 wrong_pos += run + 1;
2128 wrong_pos += wrong_run[aic_code];
2133 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2139 last_index = s->block_last_index[n];
2140 last_non_zero = i - 1;
2141 for (; i <= last_index; i++) {
2142 j = s->intra_scantable.permutated[i];
2145 run = i - last_non_zero - 1;
2146 last = (i == last_index);
2153 code = get_rl_index(rl, last, run, level);
2154 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2155 if (code == rl->n) {
2156 if(s->h263_flv <= 1){
2157 put_bits(&s->pb, 1, last);
2158 put_bits(&s->pb, 6, run);
2160 assert(slevel != 0);
2163 put_bits(&s->pb, 8, slevel & 0xff);
2165 put_bits(&s->pb, 8, 128);
2166 put_bits(&s->pb, 5, slevel & 0x1f);
2167 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2170 if(level < 64) { // 7-bit level
2171 put_bits(&s->pb, 1, 0);
2172 put_bits(&s->pb, 1, last);
2173 put_bits(&s->pb, 6, run);
2175 put_bits(&s->pb, 7, slevel & 0x7f);
2178 put_bits(&s->pb, 1, 1);
2179 put_bits(&s->pb, 1, last);
2180 put_bits(&s->pb, 6, run);
2182 put_bits(&s->pb, 11, slevel & 0x7ff);
2186 put_bits(&s->pb, 1, sign);
2194 #ifdef CONFIG_ENCODERS
2196 /***************************************************/
2198 * add mpeg4 stuffing bits (01...1)
2200 void ff_mpeg4_stuffing(PutBitContext * pbc)
2203 put_bits(pbc, 1, 0);
2204 length= (-put_bits_count(pbc))&7;
2205 if(length) put_bits(pbc, length, (1<<length)-1);
2208 /* must be called before writing the header */
2209 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2210 int time_div, time_mod;
2212 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2213 s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2215 time_div= s->time/s->time_increment_resolution;
2216 time_mod= s->time%s->time_increment_resolution;
2218 if(s->pict_type==B_TYPE){
2219 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2220 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2222 s->last_time_base= s->time_base;
2223 s->time_base= time_div;
2224 s->pp_time= s->time - s->last_non_b_time;
2225 s->last_non_b_time= s->time;
2226 assert(picture_number==0 || s->pp_time > 0);
2230 static void mpeg4_encode_gop_header(MpegEncContext * s){
2231 int hours, minutes, seconds;
2234 put_bits(&s->pb, 16, 0);
2235 put_bits(&s->pb, 16, GOP_STARTCODE);
2237 time= s->current_picture_ptr->pts;
2238 if(s->reordered_input_picture[1])
2239 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2240 time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
2242 seconds= time/s->time_increment_resolution;
2243 minutes= seconds/60; seconds %= 60;
2244 hours= minutes/60; minutes %= 60;
2247 put_bits(&s->pb, 5, hours);
2248 put_bits(&s->pb, 6, minutes);
2249 put_bits(&s->pb, 1, 1);
2250 put_bits(&s->pb, 6, seconds);
2252 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2253 put_bits(&s->pb, 1, 0); //broken link == NO
2255 s->last_time_base= time / s->time_increment_resolution;
2257 ff_mpeg4_stuffing(&s->pb);
2260 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2261 int profile_and_level_indication;
2264 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2265 profile_and_level_indication = s->avctx->profile << 4;
2266 }else if(s->max_b_frames || s->quarter_sample){
2267 profile_and_level_indication= 0xF0; // adv simple
2269 profile_and_level_indication= 0x00; // simple
2272 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2273 profile_and_level_indication |= s->avctx->level;
2275 profile_and_level_indication |= 1; //level 1
2278 if(profile_and_level_indication>>4 == 0xF){
2286 put_bits(&s->pb, 16, 0);
2287 put_bits(&s->pb, 16, VOS_STARTCODE);
2289 put_bits(&s->pb, 8, profile_and_level_indication);
2291 put_bits(&s->pb, 16, 0);
2292 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2294 put_bits(&s->pb, 1, 1);
2295 put_bits(&s->pb, 4, vo_ver_id);
2296 put_bits(&s->pb, 3, 1); //priority
2298 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2300 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2302 ff_mpeg4_stuffing(&s->pb);
2305 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2309 if(s->max_b_frames || s->quarter_sample){
2311 s->vo_type= ADV_SIMPLE_VO_TYPE;
2314 s->vo_type= SIMPLE_VO_TYPE;
2317 put_bits(&s->pb, 16, 0);
2318 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2319 put_bits(&s->pb, 16, 0);
2320 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2322 put_bits(&s->pb, 1, 0); /* random access vol */
2323 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2324 if(s->workaround_bugs & FF_BUG_MS) {
2325 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2327 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2328 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2329 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2332 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2334 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2335 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2336 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2337 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2340 if(s->workaround_bugs & FF_BUG_MS) { //
2341 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2343 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2344 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2345 put_bits(&s->pb, 1, s->low_delay);
2346 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2349 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2350 put_bits(&s->pb, 1, 1); /* marker bit */
2352 put_bits(&s->pb, 16, s->time_increment_resolution);
2353 if (s->time_increment_bits < 1)
2354 s->time_increment_bits = 1;
2355 put_bits(&s->pb, 1, 1); /* marker bit */
2356 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2357 put_bits(&s->pb, 1, 1); /* marker bit */
2358 put_bits(&s->pb, 13, s->width); /* vol width */
2359 put_bits(&s->pb, 1, 1); /* marker bit */
2360 put_bits(&s->pb, 13, s->height); /* vol height */
2361 put_bits(&s->pb, 1, 1); /* marker bit */
2362 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2363 put_bits(&s->pb, 1, 1); /* obmc disable */
2364 if (vo_ver_id == 1) {
2365 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2367 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2370 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2371 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2374 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2375 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2379 put_bits(&s->pb, 1, s->quarter_sample);
2380 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2381 s->resync_marker= s->rtp_mode;
2382 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2383 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2384 if(s->data_partitioning){
2385 put_bits(&s->pb, 1, 0); /* no rvlc */
2388 if (vo_ver_id != 1){
2389 put_bits(&s->pb, 1, 0); /* newpred */
2390 put_bits(&s->pb, 1, 0); /* reduced res vop */
2392 put_bits(&s->pb, 1, 0); /* scalability */
2394 ff_mpeg4_stuffing(&s->pb);
2397 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2398 put_bits(&s->pb, 16, 0);
2399 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2400 put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2404 /* write mpeg4 VOP header */
2405 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2408 int time_div, time_mod;
2410 if(s->pict_type==I_TYPE){
2411 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2412 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2413 mpeg4_encode_visual_object_header(s);
2414 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2415 mpeg4_encode_vol_header(s, 0, 0);
2417 if(!(s->workaround_bugs & FF_BUG_MS))
2418 mpeg4_encode_gop_header(s);
2421 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2423 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
2425 put_bits(&s->pb, 16, 0); /* vop header */
2426 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2427 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2429 time_div= s->time/s->time_increment_resolution;
2430 time_mod= s->time%s->time_increment_resolution;
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 cant 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 skiped 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 dont 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 cant 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, its 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 /* decode each block */
3757 for (i = 0; i < 6; i++) {
3758 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3759 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3766 /* per-MB end of slice check */
3768 if(--s->mb_num_left <= 0){
3769 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3770 if(mpeg4_is_resync(s))
3775 if(mpeg4_is_resync(s)){
3776 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3777 if(s->cbp_table[xy+delta])
3785 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3787 static void preview_obmc(MpegEncContext *s){
3788 GetBitContext gb= s->gb;
3790 int cbpc, i, pred_x, pred_y, mx, my;
3792 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3793 const int stride= s->b8_stride*2;
3796 s->block_index[i]+= 2;
3798 s->block_index[i]+= 1;
3801 assert(s->pict_type == P_TYPE);
3804 if (get_bits1(&s->gb)) {
3806 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3807 mot_val[0 ]= mot_val[2 ]=
3808 mot_val[0+stride]= mot_val[2+stride]= 0;
3809 mot_val[1 ]= mot_val[3 ]=
3810 mot_val[1+stride]= mot_val[3+stride]= 0;
3812 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3815 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3819 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3821 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3823 if(s->modified_quant){
3824 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3825 else skip_bits(&s->gb, 5);
3827 skip_bits(&s->gb, 2);
3830 if ((cbpc & 16) == 0) {
3831 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3832 /* 16x16 motion prediction */
3833 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3835 mx = h263p_decode_umotion(s, pred_x);
3837 mx = h263_decode_motion(s, pred_x, 1);
3840 my = h263p_decode_umotion(s, pred_y);
3842 my = h263_decode_motion(s, pred_y, 1);
3844 mot_val[0 ]= mot_val[2 ]=
3845 mot_val[0+stride]= mot_val[2+stride]= mx;
3846 mot_val[1 ]= mot_val[3 ]=
3847 mot_val[1+stride]= mot_val[3+stride]= my;
3849 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3851 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3853 mx = h263p_decode_umotion(s, pred_x);
3855 mx = h263_decode_motion(s, pred_x, 1);
3858 my = h263p_decode_umotion(s, pred_y);
3860 my = h263_decode_motion(s, pred_y, 1);
3861 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3862 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3871 s->block_index[i]-= 2;
3873 s->block_index[i]-= 1;
3879 static void h263_decode_dquant(MpegEncContext *s){
3880 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3882 if(s->modified_quant){
3883 if(get_bits1(&s->gb))
3884 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3886 s->qscale= get_bits(&s->gb, 5);
3888 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3889 ff_set_qscale(s, s->qscale);
3892 int ff_h263_decode_mb(MpegEncContext *s,
3893 DCTELEM block[6][64])
3895 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3897 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3899 assert(!s->h263_pred);
3901 if (s->pict_type == P_TYPE) {
3903 if (get_bits1(&s->gb)) {
3907 s->block_last_index[i] = -1;
3908 s->mv_dir = MV_DIR_FORWARD;
3909 s->mv_type = MV_TYPE_16X16;
3910 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3913 s->mb_skiped = !(s->obmc | s->loop_filter);
3916 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3917 //fprintf(stderr, "\tCBPC: %d", cbpc);
3919 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3925 s->mb_intra = ((cbpc & 4) != 0);
3926 if (s->mb_intra) goto intra;
3928 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3930 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3933 cbp = (cbpc & 3) | (cbpy << 2);
3935 h263_decode_dquant(s);
3938 s->mv_dir = MV_DIR_FORWARD;
3939 if ((cbpc & 16) == 0) {
3940 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3941 /* 16x16 motion prediction */
3942 s->mv_type = MV_TYPE_16X16;
3943 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3945 mx = h263p_decode_umotion(s, pred_x);
3947 mx = h263_decode_motion(s, pred_x, 1);
3953 my = h263p_decode_umotion(s, pred_y);
3955 my = h263_decode_motion(s, pred_y, 1);
3959 s->mv[0][0][0] = mx;
3960 s->mv[0][0][1] = my;
3962 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3963 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3965 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3966 s->mv_type = MV_TYPE_8X8;
3968 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3970 mx = h263p_decode_umotion(s, pred_x);
3972 mx = h263_decode_motion(s, pred_x, 1);
3977 my = h263p_decode_umotion(s, pred_y);
3979 my = h263_decode_motion(s, pred_y, 1);
3982 s->mv[0][i][0] = mx;
3983 s->mv[0][i][1] = my;
3984 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3985 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3991 /* decode each block */
3992 for (i = 0; i < 6; i++) {
3993 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3999 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4002 } else if(s->pict_type==B_TYPE) {
4004 const int stride= s->b8_stride;
4005 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4006 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4007 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4010 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4011 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4012 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4013 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4016 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4018 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4022 mb_type= h263_mb_type_b_map[ mb_type ];
4025 s->mb_intra = IS_INTRA(mb_type);
4026 if(HAS_CBP(mb_type)){
4027 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4029 dquant = IS_QUANT(mb_type);
4033 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4036 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4040 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4043 cbp = (cbpc & 3) | (cbpy << 2);
4047 assert(!s->mb_intra);
4049 if(IS_QUANT(mb_type)){
4050 h263_decode_dquant(s);
4053 if(IS_DIRECT(mb_type)){
4054 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4055 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4058 s->mv_type= MV_TYPE_16X16;
4061 if(USES_LIST(mb_type, 0)){
4062 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4063 s->mv_dir = MV_DIR_FORWARD;
4065 mx = h263_decode_motion(s, mx, 1);
4066 my = h263_decode_motion(s, my, 1);
4068 s->mv[0][0][0] = mx;
4069 s->mv[0][0][1] = my;
4070 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4071 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4074 if(USES_LIST(mb_type, 1)){
4075 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4076 s->mv_dir |= MV_DIR_BACKWARD;
4078 mx = h263_decode_motion(s, mx, 1);
4079 my = h263_decode_motion(s, my, 1);
4081 s->mv[1][0][0] = mx;
4082 s->mv[1][0][1] = my;
4083 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4084 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4088 s->current_picture.mb_type[xy]= mb_type;
4090 /* decode each block */
4091 for (i = 0; i < 6; i++) {
4092 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4096 } else { /* I-Frame */
4098 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4100 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4108 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4110 s->ac_pred = get_bits1(&s->gb);
4112 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4114 s->h263_aic_dir = get_bits1(&s->gb);
4119 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4121 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4124 cbp = (cbpc & 3) | (cbpy << 2);
4126 h263_decode_dquant(s);
4129 /* decode each block */
4130 for (i = 0; i < 6; i++) {
4131 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4138 /* per-MB end of slice check */
4140 int v= show_bits(&s->gb, 16);
4142 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4143 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4153 int ff_mpeg4_decode_mb(MpegEncContext *s,
4154 DCTELEM block[6][64])
4156 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4158 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4159 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4161 assert(s->h263_pred);
4163 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4165 if (get_bits1(&s->gb)) {