2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
5 * Copyright (c) 2001 Juan J. Sierralta P.
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8 * ac prediction encoding, B-frame support, error resilience, optimizations,
9 * qpel decoding, gmc decoding, interlaced decoding
10 * by Michael Niedermayer <michaelni@gmx.at>
12 * This file is part of FFmpeg.
14 * FFmpeg is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
19 * FFmpeg is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with FFmpeg; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
39 #include "mpegvideo.h"
41 #include "mpeg4data.h"
46 #define INTRA_MCBPC_VLC_BITS 6
47 #define INTER_MCBPC_VLC_BITS 7
48 #define CBPY_VLC_BITS 6
51 #define SPRITE_TRAJ_VLC_BITS 6
52 #define MB_TYPE_B_VLC_BITS 4
53 #define TEX_VLC_BITS 9
54 #define H263_MBTYPE_B_VLC_BITS 6
55 #define CBPC_B_VLC_BITS 3
57 #ifdef CONFIG_ENCODERS
58 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
60 static void h263p_encode_umotion(MpegEncContext * s, int val);
61 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
62 int n, int dc, uint8_t *scan_table,
63 PutBitContext *dc_pb, PutBitContext *ac_pb);
64 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
69 static int h263p_decode_umotion(MpegEncContext * s, int pred);
70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
74 int n, int coded, int intra, int rvlc);
75 #ifdef CONFIG_ENCODERS
76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
77 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
79 #endif //CONFIG_ENCODERS
80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
83 #ifdef CONFIG_ENCODERS
84 static uint8_t uni_DCtab_lum_len[512];
85 static uint8_t uni_DCtab_chrom_len[512];
86 static uint16_t uni_DCtab_lum_bits[512];
87 static uint16_t uni_DCtab_chrom_bits[512];
89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
90 static uint8_t fcode_tab[MAX_MV*2+1];
91 static uint8_t umv_fcode_tab[MAX_MV*2+1];
93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
94 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
96 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
97 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
98 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
117 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
122 int h263_get_picture_format(int width, int height)
126 if (width == 128 && height == 96)
128 else if (width == 176 && height == 144)
130 else if (width == 352 && height == 288)
132 else if (width == 704 && height == 576)
134 else if (width == 1408 && height == 1152)
141 static void show_pict_info(MpegEncContext *s){
142 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
143 s->qscale, av_get_pict_type_char(s->pict_type),
144 s->gb.size_in_bits, 1-s->no_rounding,
145 s->obmc ? " AP" : "",
146 s->umvplus ? " UMV" : "",
147 s->h263_long_vectors ? " LONG" : "",
148 s->h263_plus ? " +" : "",
149 s->h263_aic ? " AIC" : "",
150 s->alt_inter_vlc ? " AIV" : "",
151 s->modified_quant ? " MQ" : "",
152 s->loop_filter ? " LOOP" : "",
153 s->h263_slice_structured ? " SS" : "",
154 s->avctx->time_base.den, s->avctx->time_base.num
158 #ifdef CONFIG_ENCODERS
160 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
163 if(aspect.num==0) aspect= (AVRational){1,1};
166 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
167 s->aspect_ratio_info=i;
172 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
175 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
179 align_put_bits(&s->pb);
181 put_bits(&s->pb, 17, 1);
182 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
183 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
184 s->avctx->time_base.den) & 0xff); /* TemporalReference */
185 if (s->width == 352 && s->height == 288)
187 else if (s->width == 176 && s->height == 144)
189 else if (s->width == 128 && s->height == 96)
191 else if (s->width == 320 && s->height == 240)
193 else if (s->width == 160 && s->height == 120)
195 else if (s->width <= 255 && s->height <= 255)
196 format = 0; /* use 1 byte width & height */
198 format = 1; /* use 2 bytes width & height */
199 put_bits(&s->pb, 3, format); /* PictureSize */
201 put_bits(&s->pb, 8, s->width);
202 put_bits(&s->pb, 8, s->height);
203 } else if (format == 1) {
204 put_bits(&s->pb, 16, s->width);
205 put_bits(&s->pb, 16, s->height);
207 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
208 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
209 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
210 put_bits(&s->pb, 1, 0); /* ExtraInformation */
214 s->c_dc_scale_table= ff_aic_dc_scale_table;
217 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
221 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
223 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
224 int best_clock_code=1;
226 int best_error= INT_MAX;
231 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
232 div= av_clip(div, 1, 127);
233 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
234 if(error < best_error){
241 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
242 coded_frame_rate= 1800000;
243 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
245 align_put_bits(&s->pb);
247 /* Update the pointer to last GOB */
248 s->ptr_lastgob = pbBufPtr(&s->pb);
249 put_bits(&s->pb, 22, 0x20); /* PSC */
250 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
251 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
252 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
254 put_bits(&s->pb, 1, 1); /* marker */
255 put_bits(&s->pb, 1, 0); /* h263 id */
256 put_bits(&s->pb, 1, 0); /* split screen off */
257 put_bits(&s->pb, 1, 0); /* camera off */
258 put_bits(&s->pb, 1, 0); /* freeze picture release off */
260 format = h263_get_picture_format(s->width, s->height);
263 put_bits(&s->pb, 3, format);
264 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
265 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
266 of H.263v1 UMV implies to check the predicted MV after
267 calculation of the current MB to see if we're on the limits */
268 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
269 put_bits(&s->pb, 1, 0); /* SAC: off */
270 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
271 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
272 put_bits(&s->pb, 5, s->qscale);
273 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
277 /* H.263 Plus PTYPE */
279 put_bits(&s->pb, 3, 7);
280 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
282 put_bits(&s->pb,3,6); /* Custom Source Format */
284 put_bits(&s->pb, 3, format);
286 put_bits(&s->pb,1, s->custom_pcf);
287 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
288 put_bits(&s->pb,1,0); /* SAC: off */
289 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
290 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
291 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
292 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
293 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
294 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
295 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
296 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298 put_bits(&s->pb,3,0); /* Reserved */
300 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
302 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
303 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
304 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
305 put_bits(&s->pb,2,0); /* Reserved */
306 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
308 /* This should be here if PLUSPTYPE */
309 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
312 /* Custom Picture Format (CPFMT) */
313 aspect_to_info(s, s->avctx->sample_aspect_ratio);
315 put_bits(&s->pb,4,s->aspect_ratio_info);
316 put_bits(&s->pb,9,(s->width >> 2) - 1);
317 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
318 put_bits(&s->pb,9,(s->height >> 2));
319 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
320 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
326 put_bits(&s->pb, 1, best_clock_code);
327 put_bits(&s->pb, 7, best_divisor);
329 put_bits(&s->pb, 2, (temp_ref>>8)&3);
332 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
334 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
335 //FIXME check actual requested range
336 put_bits(&s->pb,2,1); /* unlimited */
337 if(s->h263_slice_structured)
338 put_bits(&s->pb,2,0); /* no weird submodes */
340 put_bits(&s->pb, 5, s->qscale);
343 put_bits(&s->pb, 1, 0); /* no PEI */
345 if(s->h263_slice_structured){
346 put_bits(&s->pb, 1, 1);
348 assert(s->mb_x == 0 && s->mb_y == 0);
349 ff_h263_encode_mba(s);
351 put_bits(&s->pb, 1, 1);
356 s->c_dc_scale_table= ff_aic_dc_scale_table;
359 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
364 * Encodes a group of blocks header.
366 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
368 put_bits(&s->pb, 17, 1); /* GBSC */
370 if(s->h263_slice_structured){
371 put_bits(&s->pb, 1, 1);
373 ff_h263_encode_mba(s);
376 put_bits(&s->pb, 1, 1);
377 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
378 put_bits(&s->pb, 1, 1);
379 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
381 int gob_number= mb_line / s->gob_index;
383 put_bits(&s->pb, 5, gob_number); /* GN */
384 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
385 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
394 for(j=1; j<=block_last_index; j++){
395 const int index= scantable[j];
396 int level= block[index];
399 if((level&(~127)) == 0){
400 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
401 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
403 rate += s->ac_esc_length;
413 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
417 int8_t * const qscale_table= s->current_picture.qscale_table;
419 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
422 int16_t *ac_val, *ac_val1;
424 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
426 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
429 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
431 ac_val-= s->block_wrap[n]*16;
432 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
435 const int level= block[n][s->dsp.idct_permutation[i ]];
436 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
437 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
441 /* different qscale, we must rescale */
443 const int level= block[n][s->dsp.idct_permutation[i ]];
444 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
445 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
449 st[n]= s->intra_h_scantable.permutated;
451 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
452 /* left prediction */
454 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
457 const int level= block[n][s->dsp.idct_permutation[i<<3]];
458 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
460 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
463 /* different qscale, we must rescale */
465 const int level= block[n][s->dsp.idct_permutation[i<<3]];
466 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
468 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
471 st[n]= s->intra_v_scantable.permutated;
474 for(i=63; i>0; i--) //FIXME optimize
475 if(block[n][ st[n][i] ]) break;
476 s->block_last_index[n]= i;
478 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
484 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
487 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
490 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
492 st[n]= s->intra_scantable.permutated;
496 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
499 /* left prediction */
501 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
508 * init s->current_picture.qscale_table from s->lambda_table
510 static void ff_init_qscale_tab(MpegEncContext *s){
511 int8_t * const qscale_table= s->current_picture.qscale_table;
514 for(i=0; i<s->mb_num; i++){
515 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
516 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
517 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
522 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
524 void ff_clean_h263_qscales(MpegEncContext *s){
526 int8_t * const qscale_table= s->current_picture.qscale_table;
528 ff_init_qscale_tab(s);
530 for(i=1; i<s->mb_num; i++){
531 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
532 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
534 for(i=s->mb_num-2; i>=0; i--){
535 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
536 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
539 if(s->codec_id != CODEC_ID_H263P){
540 for(i=1; i<s->mb_num; i++){
541 int mb_xy= s->mb_index2xy[i];
543 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
544 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
551 * modify mb_type & qscale so that encoding is acually possible in mpeg4
553 void ff_clean_mpeg4_qscales(MpegEncContext *s){
555 int8_t * const qscale_table= s->current_picture.qscale_table;
557 ff_clean_h263_qscales(s);
559 if(s->pict_type== B_TYPE){
561 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
563 for(i=0; i<s->mb_num; i++){
564 int mb_xy= s->mb_index2xy[i];
565 odd += qscale_table[mb_xy]&1;
568 if(2*odd > s->mb_num) odd=1;
571 for(i=0; i<s->mb_num; i++){
572 int mb_xy= s->mb_index2xy[i];
573 if((qscale_table[mb_xy]&1) != odd)
574 qscale_table[mb_xy]++;
575 if(qscale_table[mb_xy] > 31)
576 qscale_table[mb_xy]= 31;
579 for(i=1; i<s->mb_num; i++){
580 int mb_xy= s->mb_index2xy[i];
581 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
582 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
588 #endif //CONFIG_ENCODERS
590 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
591 #define tab_bias (tab_size/2)
593 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
595 for(i=0; i<tab_size; i++){
596 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
597 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
601 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
602 int xy= s->block_index[i];
603 uint16_t time_pp= s->pp_time;
604 uint16_t time_pb= s->pb_time;
607 p_mx= s->next_picture.motion_val[0][xy][0];
608 if((unsigned)(p_mx + tab_bias) < tab_size){
609 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
610 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
611 : s->direct_scale_mv[1][p_mx + tab_bias];
613 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
614 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
615 : p_mx*(time_pb - time_pp)/time_pp;
617 p_my= s->next_picture.motion_val[0][xy][1];
618 if((unsigned)(p_my + tab_bias) < tab_size){
619 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
620 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
621 : s->direct_scale_mv[1][p_my + tab_bias];
623 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
624 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
625 : p_my*(time_pb - time_pp)/time_pp;
634 * @return the mb_type
636 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
637 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
638 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
639 uint16_t time_pp= s->pp_time;
640 uint16_t time_pb= s->pb_time;
643 //FIXME avoid divides
644 // try special case with shifts for 1 and 3 B-frames?
646 if(IS_8X8(colocated_mb_type)){
647 s->mv_type = MV_TYPE_8X8;
649 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
651 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
652 } else if(IS_INTERLACED(colocated_mb_type)){
653 s->mv_type = MV_TYPE_FIELD;
655 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
656 s->field_select[0][i]= field_select;
657 s->field_select[1][i]= i;
658 if(s->top_field_first){
659 time_pp= s->pp_field_time - field_select + i;
660 time_pb= s->pb_field_time - field_select + i;
662 time_pp= s->pp_field_time + field_select - i;
663 time_pb= s->pb_field_time + field_select - i;
665 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
666 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
667 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
668 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
669 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
670 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
672 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
674 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
675 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
676 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
677 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
678 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
679 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
680 s->mv_type= MV_TYPE_16X16;
682 s->mv_type= MV_TYPE_8X8;
683 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
687 void ff_h263_update_motion_val(MpegEncContext * s){
688 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
689 //FIXME a lot of that is only needed for !low_delay
690 const int wrap = s->b8_stride;
691 const int xy = s->block_index[0];
693 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
695 if(s->mv_type != MV_TYPE_8X8){
696 int motion_x, motion_y;
700 } else if (s->mv_type == MV_TYPE_16X16) {
701 motion_x = s->mv[0][0][0];
702 motion_y = s->mv[0][0][1];
703 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
705 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
706 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
707 motion_x = (motion_x>>1) | (motion_x&1);
709 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
710 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
712 s->current_picture.ref_index[0][xy ]=
713 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
714 s->current_picture.ref_index[0][xy + wrap ]=
715 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
718 /* no update if 8X8 because it has been done during parsing */
719 s->current_picture.motion_val[0][xy][0] = motion_x;
720 s->current_picture.motion_val[0][xy][1] = motion_y;
721 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
722 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
723 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
724 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
725 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
726 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
729 if(s->encoding){ //FIXME encoding MUST be cleaned up
730 if (s->mv_type == MV_TYPE_8X8)
731 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
733 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
735 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
739 #ifdef CONFIG_ENCODERS
741 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
742 int l, bit_size, code;
747 bit_size = f_code - 1;
748 /* modulo encoding */
749 l= INT_BIT - 6 - bit_size;
752 code = (val >> bit_size) + 1;
754 return mvtab[code][1] + 1 + bit_size;
758 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
759 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
760 skip_put_bits(&s->pb,
761 h263_get_motion_length(s, x, f_code)
762 +h263_get_motion_length(s, y, f_code));
764 ff_h263_encode_motion(s, x, f_code);
765 ff_h263_encode_motion(s, y, f_code);
769 static inline int get_p_cbp(MpegEncContext * s,
770 DCTELEM block[6][64],
771 int motion_x, int motion_y){
774 if(s->flags & CODEC_FLAG_CBP_RD){
775 int best_cbpy_score= INT_MAX;
776 int best_cbpc_score= INT_MAX;
777 int cbpc = (-1), cbpy= (-1);
778 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
779 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
782 int score= inter_MCBPC_bits[i + offset] * lambda;
783 if(i&1) score += s->coded_score[5];
784 if(i&2) score += s->coded_score[4];
786 if(score < best_cbpc_score){
787 best_cbpc_score= score;
793 int score= cbpy_tab[i ^ 0xF][1] * lambda;
794 if(i&1) score += s->coded_score[3];
795 if(i&2) score += s->coded_score[2];
796 if(i&4) score += s->coded_score[1];
797 if(i&8) score += s->coded_score[0];
799 if(score < best_cbpy_score){
800 best_cbpy_score= score;
805 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
806 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
810 for (i = 0; i < 6; i++) {
811 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
812 s->block_last_index[i]= -1;
813 memset(s->block[i], 0, sizeof(DCTELEM)*64);
818 for (i = 0; i < 6; i++) {
819 if (s->block_last_index[i] >= 0)
826 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
827 int motion_x, int motion_y, int mb_type){
830 if(s->flags & CODEC_FLAG_CBP_RD){
832 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
835 if(s->coded_score[i] < 0){
836 score += s->coded_score[i];
843 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
844 zero_score-= 4; //2*MV + mb_type + cbp bit
848 if(zero_score <= score){
853 for (i = 0; i < 6; i++) {
854 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
855 s->block_last_index[i]= -1;
856 memset(s->block[i], 0, sizeof(DCTELEM)*64);
860 for (i = 0; i < 6; i++) {
861 if (s->block_last_index[i] >= 0)
868 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
869 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
873 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
874 for (i = 0; i < 6; i++) {
875 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
878 /* encode each block */
879 for (i = 0; i < 6; i++) {
880 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
884 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
885 for (i = 0; i < 6; i++) {
886 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
889 /* encode each block */
890 for (i = 0; i < 6; i++) {
891 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
897 void mpeg4_encode_mb(MpegEncContext * s,
898 DCTELEM block[6][64],
899 int motion_x, int motion_y)
901 int cbpc, cbpy, pred_x, pred_y;
902 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
903 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
904 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
905 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
906 const int dquant_code[5]= {1,0,9,2,3};
908 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
912 if(s->pict_type==B_TYPE){
913 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
914 int mb_type= mb_type_table[s->mv_dir];
921 s->last_mv[i][1][1]= 0;
925 assert(s->dquant>=-2 && s->dquant<=2);
926 assert((s->dquant&1)==0);
929 /* nothing to do if this MB was skipped in the next P Frame */
930 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
936 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
937 s->qscale -= s->dquant;
943 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
945 if ((cbp | motion_x | motion_y | mb_type) ==0) {
946 /* direct MB with MV={0,0} */
947 assert(s->dquant==0);
949 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
951 if(interleaved_stats){
959 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
960 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
961 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
962 if(cbp) put_bits(&s->pb, 6, cbp);
966 put_bits(&s->pb, 2, (s->dquant>>2)+3);
968 put_bits(&s->pb, 1, 0);
970 s->qscale -= s->dquant;
972 if(!s->progressive_sequence){
974 put_bits(&s->pb, 1, s->interlaced_dct);
975 if(mb_type) // not direct mode
976 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
979 if(interleaved_stats){
980 s->misc_bits+= get_bits_diff(s);
984 assert(s->mv_dir & MV_DIRECT);
985 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
989 assert(mb_type > 0 && mb_type < 4);
990 if(s->mv_type != MV_TYPE_FIELD){
991 if(s->mv_dir & MV_DIR_FORWARD){
992 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
993 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
994 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
995 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
998 if(s->mv_dir & MV_DIR_BACKWARD){
999 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1000 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1001 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1002 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1006 if(s->mv_dir & MV_DIR_FORWARD){
1007 put_bits(&s->pb, 1, s->field_select[0][0]);
1008 put_bits(&s->pb, 1, s->field_select[0][1]);
1010 if(s->mv_dir & MV_DIR_BACKWARD){
1011 put_bits(&s->pb, 1, s->field_select[1][0]);
1012 put_bits(&s->pb, 1, s->field_select[1][1]);
1014 if(s->mv_dir & MV_DIR_FORWARD){
1016 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
1017 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1018 s->last_mv[0][i][0]= s->mv[0][i][0];
1019 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1023 if(s->mv_dir & MV_DIR_BACKWARD){
1025 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
1026 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1027 s->last_mv[1][i][0]= s->mv[1][i][0];
1028 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1035 if(interleaved_stats){
1036 s->mv_bits+= get_bits_diff(s);
1039 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1041 if(interleaved_stats){
1042 s->p_tex_bits+= get_bits_diff(s);
1045 }else{ /* s->pict_type==B_TYPE */
1046 cbp= get_p_cbp(s, block, motion_x, motion_y);
1048 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1049 /* check if the B frames can skip it too, as we must skip it if we skip here
1050 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1051 if(s->max_b_frames>0){
1058 if(x+16 > s->width) x= s->width-16;
1059 if(y+16 > s->height) y= s->height-16;
1061 offset= x + y*s->linesize;
1062 p_pic= s->new_picture.data[0] + offset;
1065 for(i=0; i<s->max_b_frames; i++){
1068 Picture *pic= s->reordered_input_picture[i+1];
1070 if(pic==NULL || pic->pict_type!=B_TYPE) break;
1072 b_pic= pic->data[0] + offset;
1073 if(pic->type != FF_BUFFER_TYPE_SHARED)
1074 b_pic+= INPLACE_OFFSET;
1075 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1076 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1084 if(s->mb_skipped==1){
1085 /* skip macroblock */
1086 put_bits(&s->pb, 1, 1);
1088 if(interleaved_stats){
1098 put_bits(&s->pb, 1, 0); /* mb coded */
1102 if(s->mv_type==MV_TYPE_16X16){
1103 if(s->dquant) cbpc+= 8;
1105 inter_MCBPC_bits[cbpc],
1106 inter_MCBPC_code[cbpc]);
1108 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1110 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1112 if(!s->progressive_sequence){
1114 put_bits(pb2, 1, s->interlaced_dct);
1115 put_bits(pb2, 1, 0);
1118 if(interleaved_stats){
1119 s->misc_bits+= get_bits_diff(s);
1122 /* motion vectors: 16x16 mode */
1123 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1125 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1126 motion_y - pred_y, s->f_code);
1127 }else if(s->mv_type==MV_TYPE_FIELD){
1128 if(s->dquant) cbpc+= 8;
1130 inter_MCBPC_bits[cbpc],
1131 inter_MCBPC_code[cbpc]);
1133 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1135 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1137 assert(!s->progressive_sequence);
1139 put_bits(pb2, 1, s->interlaced_dct);
1140 put_bits(pb2, 1, 1);
1142 if(interleaved_stats){
1143 s->misc_bits+= get_bits_diff(s);
1146 /* motion vectors: 16x8 interlaced mode */
1147 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1150 put_bits(&s->pb, 1, s->field_select[0][0]);
1151 put_bits(&s->pb, 1, s->field_select[0][1]);
1153 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1154 s->mv[0][0][1] - pred_y, s->f_code);
1155 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1156 s->mv[0][1][1] - pred_y, s->f_code);
1158 assert(s->mv_type==MV_TYPE_8X8);
1160 inter_MCBPC_bits[cbpc+16],
1161 inter_MCBPC_code[cbpc+16]);
1162 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1164 if(!s->progressive_sequence){
1166 put_bits(pb2, 1, s->interlaced_dct);
1169 if(interleaved_stats){
1170 s->misc_bits+= get_bits_diff(s);
1174 /* motion vectors: 8x8 mode*/
1175 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1177 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1178 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1182 if(interleaved_stats){
1183 s->mv_bits+= get_bits_diff(s);
1186 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1188 if(interleaved_stats){
1189 s->p_tex_bits+= get_bits_diff(s);
1195 int dc_diff[6]; //dc values with the dc prediction subtracted
1196 int dir[6]; //prediction direction
1197 int zigzag_last_index[6];
1198 uint8_t *scan_table[6];
1202 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1205 if(s->flags & CODEC_FLAG_AC_PRED){
1206 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1208 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1211 scan_table[i]= s->intra_scantable.permutated;
1216 for (i = 0; i < 6; i++) {
1217 if (s->block_last_index[i] >= 1)
1218 cbp |= 1 << (5 - i);
1222 if (s->pict_type == I_TYPE) {
1223 if(s->dquant) cbpc+=4;
1225 intra_MCBPC_bits[cbpc],
1226 intra_MCBPC_code[cbpc]);
1228 if(s->dquant) cbpc+=8;
1229 put_bits(&s->pb, 1, 0); /* mb coded */
1231 inter_MCBPC_bits[cbpc + 4],
1232 inter_MCBPC_code[cbpc + 4]);
1234 put_bits(pb2, 1, s->ac_pred);
1236 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1238 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1240 if(!s->progressive_sequence){
1241 put_bits(dc_pb, 1, s->interlaced_dct);
1244 if(interleaved_stats){
1245 s->misc_bits+= get_bits_diff(s);
1248 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1250 if(interleaved_stats){
1251 s->i_tex_bits+= get_bits_diff(s);
1255 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1257 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1261 void h263_encode_mb(MpegEncContext * s,
1262 DCTELEM block[6][64],
1263 int motion_x, int motion_y)
1265 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1267 int16_t rec_intradc[6];
1269 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1270 const int dquant_code[5]= {1,0,9,2,3};
1272 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1275 cbp= get_p_cbp(s, block, motion_x, motion_y);
1277 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1278 /* skip macroblock */
1279 put_bits(&s->pb, 1, 1);
1280 if(interleaved_stats){
1288 put_bits(&s->pb, 1, 0); /* mb coded */
1292 if(s->alt_inter_vlc==0 || cbpc!=3)
1294 if(s->dquant) cbpc+= 8;
1295 if(s->mv_type==MV_TYPE_16X16){
1297 inter_MCBPC_bits[cbpc],
1298 inter_MCBPC_code[cbpc]);
1300 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1302 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1304 if(interleaved_stats){
1305 s->misc_bits+= get_bits_diff(s);
1308 /* motion vectors: 16x16 mode */
1309 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1312 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1313 motion_y - pred_y, 1);
1316 h263p_encode_umotion(s, motion_x - pred_x);
1317 h263p_encode_umotion(s, motion_y - pred_y);
1318 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1319 /* To prevent Start Code emulation */
1320 put_bits(&s->pb,1,1);
1324 inter_MCBPC_bits[cbpc+16],
1325 inter_MCBPC_code[cbpc+16]);
1326 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1328 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1330 if(interleaved_stats){
1331 s->misc_bits+= get_bits_diff(s);
1335 /* motion vectors: 8x8 mode*/
1336 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1338 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1339 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1341 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1342 motion_y - pred_y, 1);
1345 h263p_encode_umotion(s, motion_x - pred_x);
1346 h263p_encode_umotion(s, motion_y - pred_y);
1347 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1348 /* To prevent Start Code emulation */
1349 put_bits(&s->pb,1,1);
1354 if(interleaved_stats){
1355 s->mv_bits+= get_bits_diff(s);
1358 assert(s->mb_intra);
1363 for(i=0; i<6; i++) {
1364 int16_t level = block[i][0];
1367 if(i<4) scale= s->y_dc_scale;
1368 else scale= s->c_dc_scale;
1370 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1374 level = (level + (scale>>1))/scale;
1376 level = (level - (scale>>1))/scale;
1378 /* AIC can change CBP */
1379 if (level == 0 && s->block_last_index[i] == 0)
1380 s->block_last_index[i] = -1;
1382 if(!s->modified_quant){
1385 else if (level > 127)
1389 block[i][0] = level;
1390 /* Reconstruction */
1391 rec_intradc[i] = scale*level + pred_dc;
1393 rec_intradc[i] |= 1;
1394 //if ((rec_intradc[i] % 2) == 0)
1395 // rec_intradc[i]++;
1397 if (rec_intradc[i] < 0)
1399 else if (rec_intradc[i] > 2047)
1400 rec_intradc[i] = 2047;
1402 /* Update AC/DC tables */
1403 *dc_ptr[i] = rec_intradc[i];
1404 if (s->block_last_index[i] >= 0)
1405 cbp |= 1 << (5 - i);
1408 for(i=0; i<6; i++) {
1410 if (s->block_last_index[i] >= 1)
1411 cbp |= 1 << (5 - i);
1416 if (s->pict_type == I_TYPE) {
1417 if(s->dquant) cbpc+=4;
1419 intra_MCBPC_bits[cbpc],
1420 intra_MCBPC_code[cbpc]);
1422 if(s->dquant) cbpc+=8;
1423 put_bits(&s->pb, 1, 0); /* mb coded */
1425 inter_MCBPC_bits[cbpc + 4],
1426 inter_MCBPC_code[cbpc + 4]);
1429 /* XXX: currently, we do not try to use ac prediction */
1430 put_bits(&s->pb, 1, 0); /* no AC prediction */
1433 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1435 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1437 if(interleaved_stats){
1438 s->misc_bits+= get_bits_diff(s);
1442 for(i=0; i<6; i++) {
1443 /* encode each block */
1444 h263_encode_block(s, block[i], i);
1446 /* Update INTRADC for decoding */
1447 if (s->h263_aic && s->mb_intra) {
1448 block[i][0] = rec_intradc[i];
1453 if(interleaved_stats){
1455 s->p_tex_bits+= get_bits_diff(s);
1458 s->i_tex_bits+= get_bits_diff(s);
1465 void ff_h263_loop_filter(MpegEncContext * s){
1467 const int linesize = s->linesize;
1468 const int uvlinesize= s->uvlinesize;
1469 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1470 uint8_t *dest_y = s->dest[0];
1471 uint8_t *dest_cb= s->dest[1];
1472 uint8_t *dest_cr= s->dest[2];
1474 // if(s->pict_type==B_TYPE && !s->readable) return;
1480 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1482 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1483 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1488 int qp_dt, qp_t, qp_tc;
1490 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1493 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1501 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1502 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1503 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1505 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1506 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1510 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1513 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1516 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1519 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1520 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1521 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1522 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1528 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1529 if(s->mb_y + 1 == s->mb_height)
1530 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1535 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1538 qp_lc= s->current_picture.qscale_table[xy-1];
1541 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1542 if(s->mb_y + 1 == s->mb_height){
1543 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1544 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1545 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1546 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1552 #ifdef CONFIG_ENCODERS
1553 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1555 int x, y, wrap, a, c, pred_dc, scale;
1558 /* find prediction */
1560 x = 2 * s->mb_x + (n & 1);
1561 y = 2 * s->mb_y + ((n & 2) >> 1);
1562 wrap = s->b8_stride;
1563 dc_val = s->dc_val[0];
1564 scale = s->y_dc_scale;
1568 wrap = s->mb_stride;
1569 dc_val = s->dc_val[n - 4 + 1];
1570 scale = s->c_dc_scale;
1575 a = dc_val[(x - 1) + (y) * wrap];
1576 c = dc_val[(x) + (y - 1) * wrap];
1578 /* No prediction outside GOB boundary */
1579 if(s->first_slice_line && n!=3){
1581 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1584 /* just DC prediction */
1585 if (a != 1024 && c != 1024)
1586 pred_dc = (a + c) >> 1;
1592 /* we assume pred is positive */
1593 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1594 *dc_val_ptr = &dc_val[x + y * wrap];
1597 #endif /* CONFIG_ENCODERS */
1599 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1601 int x, y, wrap, a, c, pred_dc, scale, i;
1602 int16_t *dc_val, *ac_val, *ac_val1;
1604 /* find prediction */
1606 x = 2 * s->mb_x + (n & 1);
1607 y = 2 * s->mb_y + (n>> 1);
1608 wrap = s->b8_stride;
1609 dc_val = s->dc_val[0];
1610 ac_val = s->ac_val[0][0];
1611 scale = s->y_dc_scale;
1615 wrap = s->mb_stride;
1616 dc_val = s->dc_val[n - 4 + 1];
1617 ac_val = s->ac_val[n - 4 + 1][0];
1618 scale = s->c_dc_scale;
1621 ac_val += ((y) * wrap + (x)) * 16;
1627 a = dc_val[(x - 1) + (y) * wrap];
1628 c = dc_val[(x) + (y - 1) * wrap];
1630 /* No prediction outside GOB boundary */
1631 if(s->first_slice_line && n!=3){
1633 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1638 if (s->h263_aic_dir) {
1639 /* left prediction */
1643 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1648 /* top prediction */
1650 ac_val -= 16 * wrap;
1652 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1658 /* just DC prediction */
1659 if (a != 1024 && c != 1024)
1660 pred_dc = (a + c) >> 1;
1667 /* we assume pred is positive */
1668 block[0]=block[0]*scale + pred_dc;
1675 /* Update AC/DC tables */
1676 dc_val[(x) + (y) * wrap] = block[0];
1680 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1683 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1686 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1690 int16_t *A, *B, *C, (*mot_val)[2];
1691 static const int off[4]= {2, 1, 1, -1};
1693 wrap = s->b8_stride;
1694 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1697 /* special case for first (slice) line */
1698 if (s->first_slice_line && block<3) {
1699 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1700 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1701 if(block==0){ //most common case
1702 if(s->mb_x == s->resync_mb_x){ //rare
1704 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1705 C = mot_val[off[block] - wrap];
1710 *px = mid_pred(A[0], 0, C[0]);
1711 *py = mid_pred(A[1], 0, C[1]);
1718 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1719 C = mot_val[off[block] - wrap];
1720 *px = mid_pred(A[0], 0, C[0]);
1721 *py = mid_pred(A[1], 0, C[1]);
1726 }else{ /* block==2*/
1727 B = mot_val[ - wrap];
1728 C = mot_val[off[block] - wrap];
1729 if(s->mb_x == s->resync_mb_x) //rare
1732 *px = mid_pred(A[0], B[0], C[0]);
1733 *py = mid_pred(A[1], B[1], C[1]);
1736 B = mot_val[ - wrap];
1737 C = mot_val[off[block] - wrap];
1738 *px = mid_pred(A[0], B[0], C[0]);
1739 *py = mid_pred(A[1], B[1], C[1]);
1744 #ifdef CONFIG_ENCODERS
1745 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1747 int range, l, bit_size, sign, code, bits;
1752 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1754 bit_size = f_code - 1;
1755 range = 1 << bit_size;
1756 /* modulo encoding */
1757 l= INT_BIT - 6 - bit_size;
1760 val= (val^sign)-sign;
1764 code = (val >> bit_size) + 1;
1765 bits = val & (range - 1);
1767 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1769 put_bits(&s->pb, bit_size, bits);
1774 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1775 static void h263p_encode_umotion(MpegEncContext * s, int val)
1785 put_bits(&s->pb, 1, 1);
1787 put_bits(&s->pb, 3, 0);
1789 put_bits(&s->pb, 3, 2);
1792 sval = ((val < 0) ? (short)(-val):(short)val);
1795 while (temp_val != 0) {
1796 temp_val = temp_val >> 1;
1802 tcode = (sval & (1 << (i-1))) >> (i-1);
1803 tcode = (tcode << 1) | 1;
1804 code = (code << 2) | tcode;
1807 code = ((code << 1) | (val < 0)) << 1;
1808 put_bits(&s->pb, (2*n_bits)+1, code);
1809 //printf("\nVal = %d\tCode = %d", sval, code);
1813 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1818 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1819 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1822 if(mv==0) len= mvtab[0][1];
1824 int val, bit_size, range, code;
1826 bit_size = f_code - 1;
1827 range = 1 << bit_size;
1833 code = (val >> bit_size) + 1;
1835 len= mvtab[code][1] + 1 + bit_size;
1837 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1841 mv_penalty[f_code][mv+MAX_MV]= len;
1845 for(f_code=MAX_FCODE; f_code>0; f_code--){
1846 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1847 fcode_tab[mv+MAX_MV]= f_code;
1851 for(mv=0; mv<MAX_MV*2+1; mv++){
1852 umv_fcode_tab[mv]= 1;
1856 static void init_uni_dc_tab(void)
1858 int level, uni_code, uni_len;
1860 for(level=-256; level<256; level++){
1862 /* find number of bits */
1871 l= (-level) ^ ((1 << size) - 1);
1876 uni_code= DCtab_lum[size][0];
1877 uni_len = DCtab_lum[size][1];
1880 uni_code<<=size; uni_code|=l;
1883 uni_code<<=1; uni_code|=1;
1887 uni_DCtab_lum_bits[level+256]= uni_code;
1888 uni_DCtab_lum_len [level+256]= uni_len;
1891 uni_code= DCtab_chrom[size][0];
1892 uni_len = DCtab_chrom[size][1];
1895 uni_code<<=size; uni_code|=l;
1898 uni_code<<=1; uni_code|=1;
1902 uni_DCtab_chrom_bits[level+256]= uni_code;
1903 uni_DCtab_chrom_len [level+256]= uni_len;
1908 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1909 int slevel, run, last;
1911 assert(MAX_LEVEL >= 64);
1912 assert(MAX_RUN >= 63);
1914 for(slevel=-64; slevel<64; slevel++){
1915 if(slevel==0) continue;
1916 for(run=0; run<64; run++){
1917 for(last=0; last<=1; last++){
1918 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1919 int level= slevel < 0 ? -slevel : slevel;
1920 int sign= slevel < 0 ? 1 : 0;
1921 int bits, len, code;
1924 len_tab[index]= 100;
1927 code= get_rl_index(rl, last, run, level);
1928 bits= rl->table_vlc[code][0];
1929 len= rl->table_vlc[code][1];
1930 bits=bits*2+sign; len++;
1932 if(code!=rl->n && len < len_tab[index]){
1933 bits_tab[index]= bits;
1934 len_tab [index]= len;
1938 bits= rl->table_vlc[rl->n][0];
1939 len= rl->table_vlc[rl->n][1];
1940 bits=bits*2; len++; //esc1
1941 level1= level - rl->max_level[last][run];
1943 code= get_rl_index(rl, last, run, level1);
1944 bits<<= rl->table_vlc[code][1];
1945 len += rl->table_vlc[code][1];
1946 bits += rl->table_vlc[code][0];
1947 bits=bits*2+sign; len++;
1949 if(code!=rl->n && len < len_tab[index]){
1950 bits_tab[index]= bits;
1951 len_tab [index]= len;
1957 bits= rl->table_vlc[rl->n][0];
1958 len= rl->table_vlc[rl->n][1];
1959 bits=bits*4+2; len+=2; //esc2
1960 run1 = run - rl->max_run[last][level] - 1;
1962 code= get_rl_index(rl, last, run1, level);
1963 bits<<= rl->table_vlc[code][1];
1964 len += rl->table_vlc[code][1];
1965 bits += rl->table_vlc[code][0];
1966 bits=bits*2+sign; len++;
1968 if(code!=rl->n && len < len_tab[index]){
1969 bits_tab[index]= bits;
1970 len_tab [index]= len;
1975 bits= rl->table_vlc[rl->n][0];
1976 len = rl->table_vlc[rl->n][1];
1977 bits=bits*4+3; len+=2; //esc3
1978 bits=bits*2+last; len++;
1979 bits=bits*64+run; len+=6;
1980 bits=bits*2+1; len++; //marker
1981 bits=bits*4096+(slevel&0xfff); len+=12;
1982 bits=bits*2+1; len++; //marker
1984 if(len < len_tab[index]){
1985 bits_tab[index]= bits;
1986 len_tab [index]= len;
1993 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1994 int slevel, run, last;
1996 assert(MAX_LEVEL >= 64);
1997 assert(MAX_RUN >= 63);
1999 for(slevel=-64; slevel<64; slevel++){
2000 if(slevel==0) continue;
2001 for(run=0; run<64; run++){
2002 for(last=0; last<=1; last++){
2003 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2004 int level= slevel < 0 ? -slevel : slevel;
2005 int sign= slevel < 0 ? 1 : 0;
2006 int bits, len, code;
2008 len_tab[index]= 100;
2011 code= get_rl_index(rl, last, run, level);
2012 bits= rl->table_vlc[code][0];
2013 len= rl->table_vlc[code][1];
2014 bits=bits*2+sign; len++;
2016 if(code!=rl->n && len < len_tab[index]){
2017 if(bits_tab) bits_tab[index]= bits;
2018 len_tab [index]= len;
2021 bits= rl->table_vlc[rl->n][0];
2022 len = rl->table_vlc[rl->n][1];
2023 bits=bits*2+last; len++;
2024 bits=bits*64+run; len+=6;
2025 bits=bits*256+(level&0xff); len+=8;
2027 if(len < len_tab[index]){
2028 if(bits_tab) bits_tab[index]= bits;
2029 len_tab [index]= len;
2036 void h263_encode_init(MpegEncContext *s)
2038 static int done = 0;
2045 init_rl(&rl_inter, static_rl_table_store[0]);
2046 init_rl(&rl_intra, static_rl_table_store[1]);
2047 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2049 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2050 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2052 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2053 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2055 init_mv_penalty_and_fcode(s);
2057 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2059 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2060 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2062 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2063 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2065 s->ac_esc_length= 7+1+6+8;
2067 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2068 switch(s->codec_id){
2069 case CODEC_ID_MPEG4:
2070 s->fcode_tab= fcode_tab;
2071 s->min_qcoeff= -2048;
2072 s->max_qcoeff= 2047;
2073 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2074 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2075 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2076 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2077 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2078 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2079 s->ac_esc_length= 7+2+1+6+1+12+1;
2080 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2081 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2083 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2085 s->avctx->extradata= av_malloc(1024);
2086 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2088 if(!(s->workaround_bugs & FF_BUG_MS))
2089 mpeg4_encode_visual_object_header(s);
2090 mpeg4_encode_vol_header(s, 0, 0);
2092 // ff_mpeg4_stuffing(&s->pb); ?
2093 flush_put_bits(&s->pb);
2094 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2098 case CODEC_ID_H263P:
2100 s->fcode_tab= umv_fcode_tab;
2101 if(s->modified_quant){
2102 s->min_qcoeff= -2047;
2103 s->max_qcoeff= 2047;
2105 s->min_qcoeff= -127;
2109 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2111 if (s->h263_flv > 1) {
2112 s->min_qcoeff= -1023;
2113 s->max_qcoeff= 1023;
2115 s->min_qcoeff= -127;
2118 s->y_dc_scale_table=
2119 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2121 default: //nothing needed - default table already set in mpegvideo.c
2122 s->min_qcoeff= -127;
2124 s->y_dc_scale_table=
2125 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2130 * encodes a 8x8 block.
2131 * @param block the 8x8 block
2132 * @param n block index (0-3 are luma, 4-5 are chroma)
2134 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2136 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2140 if (s->mb_intra && !s->h263_aic) {
2143 /* 255 cannot be represented, so we clamp */
2148 /* 0 cannot be represented also */
2149 else if (level < 1) {
2153 if (level == 128) //FIXME check rv10
2154 put_bits(&s->pb, 8, 0xff);
2156 put_bits(&s->pb, 8, level);
2160 if (s->h263_aic && s->mb_intra)
2163 if(s->alt_inter_vlc && !s->mb_intra){
2165 int inter_vlc_bits=0;
2169 last_index = s->block_last_index[n];
2170 last_non_zero = i - 1;
2171 for (; i <= last_index; i++) {
2172 j = s->intra_scantable.permutated[i];
2175 run = i - last_non_zero - 1;
2176 last = (i == last_index);
2178 if(level<0) level= -level;
2180 code = get_rl_index(rl, last, run, level);
2181 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2182 inter_vlc_bits += rl->table_vlc[code][1]+1;
2183 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2185 if (code == rl->n) {
2186 inter_vlc_bits += 1+6+8-1;
2188 if (aic_code == rl_intra_aic.n) {
2189 aic_vlc_bits += 1+6+8-1;
2190 wrong_pos += run + 1;
2192 wrong_pos += wrong_run[aic_code];
2197 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2203 last_index = s->block_last_index[n];
2204 last_non_zero = i - 1;
2205 for (; i <= last_index; i++) {
2206 j = s->intra_scantable.permutated[i];
2209 run = i - last_non_zero - 1;
2210 last = (i == last_index);
2217 code = get_rl_index(rl, last, run, level);
2218 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2219 if (code == rl->n) {
2220 if(s->h263_flv <= 1){
2221 put_bits(&s->pb, 1, last);
2222 put_bits(&s->pb, 6, run);
2224 assert(slevel != 0);
2227 put_bits(&s->pb, 8, slevel & 0xff);
2229 put_bits(&s->pb, 8, 128);
2230 put_bits(&s->pb, 5, slevel & 0x1f);
2231 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2234 if(level < 64) { // 7-bit level
2235 put_bits(&s->pb, 1, 0);
2236 put_bits(&s->pb, 1, last);
2237 put_bits(&s->pb, 6, run);
2239 put_bits(&s->pb, 7, slevel & 0x7f);
2242 put_bits(&s->pb, 1, 1);
2243 put_bits(&s->pb, 1, last);
2244 put_bits(&s->pb, 6, run);
2246 put_bits(&s->pb, 11, slevel & 0x7ff);
2250 put_bits(&s->pb, 1, sign);
2257 /***************************************************/
2259 * add mpeg4 stuffing bits (01...1)
2261 void ff_mpeg4_stuffing(PutBitContext * pbc)
2264 put_bits(pbc, 1, 0);
2265 length= (-put_bits_count(pbc))&7;
2266 if(length) put_bits(pbc, length, (1<<length)-1);
2269 /* must be called before writing the header */
2270 void ff_set_mpeg4_time(MpegEncContext * s){
2271 if(s->pict_type==B_TYPE){
2272 ff_mpeg4_init_direct_mv(s);
2274 s->last_time_base= s->time_base;
2275 s->time_base= s->time/s->avctx->time_base.den;
2279 static void mpeg4_encode_gop_header(MpegEncContext * s){
2280 int hours, minutes, seconds;
2283 put_bits(&s->pb, 16, 0);
2284 put_bits(&s->pb, 16, GOP_STARTCODE);
2286 time= s->current_picture_ptr->pts;
2287 if(s->reordered_input_picture[1])
2288 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2289 time= time*s->avctx->time_base.num;
2291 seconds= time/s->avctx->time_base.den;
2292 minutes= seconds/60; seconds %= 60;
2293 hours= minutes/60; minutes %= 60;
2296 put_bits(&s->pb, 5, hours);
2297 put_bits(&s->pb, 6, minutes);
2298 put_bits(&s->pb, 1, 1);
2299 put_bits(&s->pb, 6, seconds);
2301 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2302 put_bits(&s->pb, 1, 0); //broken link == NO
2304 s->last_time_base= time / s->avctx->time_base.den;
2306 ff_mpeg4_stuffing(&s->pb);
2309 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2310 int profile_and_level_indication;
2313 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2314 profile_and_level_indication = s->avctx->profile << 4;
2315 }else if(s->max_b_frames || s->quarter_sample){
2316 profile_and_level_indication= 0xF0; // adv simple
2318 profile_and_level_indication= 0x00; // simple
2321 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2322 profile_and_level_indication |= s->avctx->level;
2324 profile_and_level_indication |= 1; //level 1
2327 if(profile_and_level_indication>>4 == 0xF){
2335 put_bits(&s->pb, 16, 0);
2336 put_bits(&s->pb, 16, VOS_STARTCODE);
2338 put_bits(&s->pb, 8, profile_and_level_indication);
2340 put_bits(&s->pb, 16, 0);
2341 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2343 put_bits(&s->pb, 1, 1);
2344 put_bits(&s->pb, 4, vo_ver_id);
2345 put_bits(&s->pb, 3, 1); //priority
2347 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2349 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2351 ff_mpeg4_stuffing(&s->pb);
2354 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2358 if (!ENABLE_MPEG4_ENCODER) return;
2360 if(s->max_b_frames || s->quarter_sample){
2362 s->vo_type= ADV_SIMPLE_VO_TYPE;
2365 s->vo_type= SIMPLE_VO_TYPE;
2368 put_bits(&s->pb, 16, 0);
2369 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2370 put_bits(&s->pb, 16, 0);
2371 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2373 put_bits(&s->pb, 1, 0); /* random access vol */
2374 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2375 if(s->workaround_bugs & FF_BUG_MS) {
2376 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2378 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2379 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2380 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2383 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2385 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2386 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2387 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2388 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2391 if(s->workaround_bugs & FF_BUG_MS) { //
2392 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2394 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2395 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2396 put_bits(&s->pb, 1, s->low_delay);
2397 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2400 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2401 put_bits(&s->pb, 1, 1); /* marker bit */
2403 put_bits(&s->pb, 16, s->avctx->time_base.den);
2404 if (s->time_increment_bits < 1)
2405 s->time_increment_bits = 1;
2406 put_bits(&s->pb, 1, 1); /* marker bit */
2407 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2408 put_bits(&s->pb, 1, 1); /* marker bit */
2409 put_bits(&s->pb, 13, s->width); /* vol width */
2410 put_bits(&s->pb, 1, 1); /* marker bit */
2411 put_bits(&s->pb, 13, s->height); /* vol height */
2412 put_bits(&s->pb, 1, 1); /* marker bit */
2413 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2414 put_bits(&s->pb, 1, 1); /* obmc disable */
2415 if (vo_ver_id == 1) {
2416 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2418 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2421 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2422 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2425 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2426 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2430 put_bits(&s->pb, 1, s->quarter_sample);
2431 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2432 s->resync_marker= s->rtp_mode;
2433 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2434 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2435 if(s->data_partitioning){
2436 put_bits(&s->pb, 1, 0); /* no rvlc */
2439 if (vo_ver_id != 1){
2440 put_bits(&s->pb, 1, 0); /* newpred */
2441 put_bits(&s->pb, 1, 0); /* reduced res vop */
2443 put_bits(&s->pb, 1, 0); /* scalability */
2445 ff_mpeg4_stuffing(&s->pb);
2448 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2449 put_bits(&s->pb, 16, 0);
2450 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2451 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2455 /* write mpeg4 VOP header */
2456 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2459 int time_div, time_mod;
2461 if(s->pict_type==I_TYPE){
2462 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2463 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2464 mpeg4_encode_visual_object_header(s);
2465 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2466 mpeg4_encode_vol_header(s, 0, 0);
2468 if(!(s->workaround_bugs & FF_BUG_MS))
2469 mpeg4_encode_gop_header(s);
2472 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2474 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2476 put_bits(&s->pb, 16, 0); /* vop header */
2477 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2478 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2481 time_div= s->time/s->avctx->time_base.den;
2482 time_mod= s->time%s->avctx->time_base.den;
2483 time_incr= time_div - s->last_time_base;
2484 assert(time_incr >= 0);
2486 put_bits(&s->pb, 1, 1);
2488 put_bits(&s->pb, 1, 0);
2490 put_bits(&s->pb, 1, 1); /* marker */
2491 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2492 put_bits(&s->pb, 1, 1); /* marker */
2493 put_bits(&s->pb, 1, 1); /* vop coded */
2494 if ( s->pict_type == P_TYPE
2495 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2496 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2498 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2499 if(!s->progressive_sequence){
2500 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2501 put_bits(&s->pb, 1, s->alternate_scan);
2503 //FIXME sprite stuff
2505 put_bits(&s->pb, 5, s->qscale);
2507 if (s->pict_type != I_TYPE)
2508 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2509 if (s->pict_type == B_TYPE)
2510 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2511 // printf("****frame %d\n", picture_number);
2514 #endif //CONFIG_ENCODERS
2518 * encoding quantized level -> quantized diff
2519 * decoding quantized diff -> quantized level
2520 * @param n block index (0-3 are luma, 4-5 are chroma)
2521 * @param dir_ptr pointer to an integer where the prediction direction will be stored
2523 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2525 int a, b, c, wrap, pred, scale, ret;
2528 /* find prediction */
2530 scale = s->y_dc_scale;
2532 scale = s->c_dc_scale;
2537 wrap= s->block_wrap[n];
2538 dc_val = s->dc_val[0] + s->block_index[n];
2544 b = dc_val[ - 1 - wrap];
2545 c = dc_val[ - wrap];
2547 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2548 if(s->first_slice_line && n!=3){
2550 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2552 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2553 if(n==0 || n==4 || n==5)
2557 if (abs(a - b) < abs(b - c)) {
2559 *dir_ptr = 1; /* top */
2562 *dir_ptr = 0; /* left */
2564 /* we assume pred is positive */
2565 pred = FASTDIV((pred + (scale >> 1)), scale);
2572 if(s->error_resilience>=3){
2574 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2577 if(level*scale > 2048 + scale){
2578 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2587 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2597 * @param n block index (0-3 are luma, 4-5 are chroma)
2598 * @param dir the ac prediction direction
2600 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2604 int16_t *ac_val, *ac_val1;
2605 int8_t * const qscale_table= s->current_picture.qscale_table;
2607 /* find prediction */
2608 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2612 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2613 /* left prediction */
2616 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2619 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2622 /* different qscale, we must rescale */
2624 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2628 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2629 /* top prediction */
2630 ac_val -= 16 * s->block_wrap[n];
2632 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2635 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2638 /* different qscale, we must rescale */
2640 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2647 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2651 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2655 #ifdef CONFIG_ENCODERS
2658 * encodes the dc value.
2659 * @param n block index (0-3 are luma, 4-5 are chroma)
2661 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2664 // if(level<-255 || level>255) printf("dc overflow\n");
2668 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2671 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2675 /* find number of bits */
2685 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2688 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2691 /* encode remaining bits */
2694 level = (-level) ^ ((1 << size) - 1);
2695 put_bits(&s->pb, size, level);
2697 put_bits(&s->pb, 1, 1);
2702 static inline int mpeg4_get_dc_length(int level, int n){
2704 return uni_DCtab_lum_len[level + 256];
2706 return uni_DCtab_chrom_len[level + 256];
2711 * encodes a 8x8 block
2712 * @param n block index (0-3 are luma, 4-5 are chroma)
2714 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2715 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2717 int i, last_non_zero;
2718 #if 0 //variables for the outcommented version
2719 int code, sign, last;
2724 const int last_index = s->block_last_index[n];
2726 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2727 /* mpeg4 based DC predictor */
2728 mpeg4_encode_dc(dc_pb, intra_dc, n);
2729 if(last_index<1) return;
2732 bits_tab= uni_mpeg4_intra_rl_bits;
2733 len_tab = uni_mpeg4_intra_rl_len;
2735 if(last_index<0) return;
2738 bits_tab= uni_mpeg4_inter_rl_bits;
2739 len_tab = uni_mpeg4_inter_rl_len;
2743 last_non_zero = i - 1;
2745 for (; i < last_index; i++) {
2746 int level = block[ scan_table[i] ];
2748 int run = i - last_non_zero - 1;
2750 if((level&(~127)) == 0){
2751 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2752 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2754 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);
2759 /*if(i<=last_index)*/{
2760 int level = block[ scan_table[i] ];
2761 int run = i - last_non_zero - 1;
2763 if((level&(~127)) == 0){
2764 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2765 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2767 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);
2771 for (; i <= last_index; i++) {
2772 const int slevel = block[ scan_table[i] ];
2775 int run = i - last_non_zero - 1;
2776 last = (i == last_index);
2783 code = get_rl_index(rl, last, run, level);
2784 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2785 if (code == rl->n) {
2787 level1 = level - rl->max_level[last][run];
2790 code = get_rl_index(rl, last, run, level1);
2791 if (code == rl->n) {
2793 put_bits(ac_pb, 1, 1);
2794 if (level > MAX_LEVEL)
2796 run1 = run - rl->max_run[last][level] - 1;
2799 code = get_rl_index(rl, last, run1, level);
2800 if (code == rl->n) {
2803 put_bits(ac_pb, 1, 1);
2804 put_bits(ac_pb, 1, last);
2805 put_bits(ac_pb, 6, run);
2806 put_bits(ac_pb, 1, 1);
2807 put_bits(ac_pb, 12, slevel & 0xfff);
2808 put_bits(ac_pb, 1, 1);
2811 put_bits(ac_pb, 1, 0);
2812 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2813 put_bits(ac_pb, 1, sign);
2817 put_bits(ac_pb, 1, 0);
2818 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2819 put_bits(ac_pb, 1, sign);
2822 put_bits(ac_pb, 1, sign);
2830 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2831 uint8_t *scan_table)
2833 int i, last_non_zero;
2836 const int last_index = s->block_last_index[n];
2839 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2840 /* mpeg4 based DC predictor */
2841 len += mpeg4_get_dc_length(intra_dc, n);
2842 if(last_index<1) return len;
2845 len_tab = uni_mpeg4_intra_rl_len;
2847 if(last_index<0) return 0;
2850 len_tab = uni_mpeg4_inter_rl_len;
2854 last_non_zero = i - 1;
2855 for (; i < last_index; i++) {
2856 int level = block[ scan_table[i] ];
2858 int run = i - last_non_zero - 1;
2860 if((level&(~127)) == 0){
2861 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2862 len += len_tab[index];
2864 len += 7+2+1+6+1+12+1;
2869 /*if(i<=last_index)*/{
2870 int level = block[ scan_table[i] ];
2871 int run = i - last_non_zero - 1;
2873 if((level&(~127)) == 0){
2874 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2875 len += len_tab[index];
2877 len += 7+2+1+6+1+12+1;
2887 /***********************************************/
2890 static VLC intra_MCBPC_vlc;
2891 static VLC inter_MCBPC_vlc;
2892 static VLC cbpy_vlc;
2894 static VLC dc_lum, dc_chrom;
2895 static VLC sprite_trajectory;
2896 static VLC mb_type_b_vlc;
2897 static VLC h263_mbtype_b_vlc;
2898 static VLC cbpc_b_vlc;
2902 /* XXX: find a better solution to handle static init */
2903 void h263_decode_init_vlc(MpegEncContext *s)
2905 static int done = 0;
2910 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2911 intra_MCBPC_bits, 1, 1,
2912 intra_MCBPC_code, 1, 1, 1);
2913 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2914 inter_MCBPC_bits, 1, 1,
2915 inter_MCBPC_code, 1, 1, 1);
2916 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2917 &cbpy_tab[0][1], 2, 1,
2918 &cbpy_tab[0][0], 2, 1, 1);
2919 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2921 &mvtab[0][0], 2, 1, 1);
2922 init_rl(&rl_inter, static_rl_table_store[0]);
2923 init_rl(&rl_intra, static_rl_table_store[1]);
2924 init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2925 init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2926 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2927 init_vlc_rl(&rl_inter, 1);
2928 init_vlc_rl(&rl_intra, 1);
2929 init_vlc_rl(&rvlc_rl_inter, 1);
2930 init_vlc_rl(&rvlc_rl_intra, 1);
2931 init_vlc_rl(&rl_intra_aic, 1);
2932 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2933 &DCtab_lum[0][1], 2, 1,
2934 &DCtab_lum[0][0], 2, 1, 1);
2935 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2936 &DCtab_chrom[0][1], 2, 1,
2937 &DCtab_chrom[0][0], 2, 1, 1);
2938 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2939 &sprite_trajectory_tab[0][1], 4, 2,
2940 &sprite_trajectory_tab[0][0], 4, 2, 1);
2941 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2942 &mb_type_b_tab[0][1], 2, 1,
2943 &mb_type_b_tab[0][0], 2, 1, 1);
2944 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2945 &h263_mbtype_b_tab[0][1], 2, 1,
2946 &h263_mbtype_b_tab[0][0], 2, 1, 1);
2947 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2948 &cbpc_b_tab[0][1], 2, 1,
2949 &cbpc_b_tab[0][0], 2, 1, 1);
2954 * Get the GOB height based on picture height.
2956 int ff_h263_get_gob_height(MpegEncContext *s){
2957 if (s->height <= 400)
2959 else if (s->height <= 800)
2965 int ff_h263_decode_mba(MpegEncContext *s)
2970 if(s->mb_num-1 <= ff_mba_max[i]) break;
2972 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2973 s->mb_x= mb_pos % s->mb_width;
2974 s->mb_y= mb_pos / s->mb_width;
2979 void ff_h263_encode_mba(MpegEncContext *s)
2984 if(s->mb_num-1 <= ff_mba_max[i]) break;
2986 mb_pos= s->mb_x + s->mb_width*s->mb_y;
2987 put_bits(&s->pb, ff_mba_length[i], mb_pos);
2991 * decodes the group of blocks header or slice header.
2992 * @return <0 if an error occured
2994 static int h263_decode_gob_header(MpegEncContext *s)
2996 unsigned int val, gfid, gob_number;
2999 /* Check for GOB Start Code */
3000 val = show_bits(&s->gb, 16);
3004 /* We have a GBSC probably with GSTUFF */
3005 skip_bits(&s->gb, 16); /* Drop the zeros */
3006 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3007 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
3008 for(;left>13; left--){
3009 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3014 if(s->h263_slice_structured){
3015 if(get_bits1(&s->gb)==0)
3018 ff_h263_decode_mba(s);
3020 if(s->mb_num > 1583)
3021 if(get_bits1(&s->gb)==0)
3024 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3025 if(get_bits1(&s->gb)==0)
3027 gfid = get_bits(&s->gb, 2); /* GFID */
3029 gob_number = get_bits(&s->gb, 5); /* GN */
3031 s->mb_y= s->gob_index* gob_number;
3032 gfid = get_bits(&s->gb, 2); /* GFID */
3033 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3036 if(s->mb_y >= s->mb_height)
3045 static inline void memsetw(short *tab, int val, int n)
3052 #ifdef CONFIG_ENCODERS
3054 void ff_mpeg4_init_partitions(MpegEncContext *s)
3056 uint8_t *start= pbBufPtr(&s->pb);
3057 uint8_t *end= s->pb.buf_end;
3058 int size= end - start;
3059 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3060 int tex_size= (size - 2*pb_size)&(~3);
3062 set_put_bits_buffer_size(&s->pb, pb_size);
3063 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3064 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3067 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3069 const int pb2_len = put_bits_count(&s->pb2 );
3070 const int tex_pb_len= put_bits_count(&s->tex_pb);
3071 const int bits= put_bits_count(&s->pb);
3073 if(s->pict_type==I_TYPE){
3074 put_bits(&s->pb, 19, DC_MARKER);
3075 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3076 s->i_tex_bits+= tex_pb_len;
3078 put_bits(&s->pb, 17, MOTION_MARKER);
3079 s->misc_bits+=17 + pb2_len;
3080 s->mv_bits+= bits - s->last_bits;
3081 s->p_tex_bits+= tex_pb_len;
3084 flush_put_bits(&s->pb2);
3085 flush_put_bits(&s->tex_pb);
3087 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3088 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3089 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3090 s->last_bits= put_bits_count(&s->pb);
3093 #endif //CONFIG_ENCODERS
3095 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3096 switch(s->pict_type){
3101 return s->f_code+15;
3103 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3109 #ifdef CONFIG_ENCODERS
3111 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3113 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3115 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3116 put_bits(&s->pb, 1, 1);
3118 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3119 put_bits(&s->pb, s->quant_precision, s->qscale);
3120 put_bits(&s->pb, 1, 0); /* no HEC */
3123 #endif //CONFIG_ENCODERS
3126 * check if the next stuff is a resync marker or the end.
3129 static inline int mpeg4_is_resync(MpegEncContext *s){
3130 int bits_count= get_bits_count(&s->gb);
3131 int v= show_bits(&s->gb, 16);
3133 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3138 if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3140 skip_bits(&s->gb, 8+s->pict_type);
3141 bits_count+= 8+s->pict_type;
3142 v= show_bits(&s->gb, 16);
3145 if(bits_count + 8 >= s->gb.size_in_bits){
3147 v|= 0x7F >> (7-(bits_count&7));
3152 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3154 GetBitContext gb= s->gb;
3156 skip_bits(&s->gb, 1);
3157 align_get_bits(&s->gb);
3159 for(len=0; len<32; len++){
3160 if(get_bits1(&s->gb)) break;
3165 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3173 * decodes the next video packet.
3174 * @return <0 if something went wrong
3176 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3178 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3179 int header_extension=0, mb_num, len;
3181 /* is there enough space left for a video packet + header */
3182 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3184 for(len=0; len<32; len++){
3185 if(get_bits1(&s->gb)) break;
3188 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3189 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3193 if(s->shape != RECT_SHAPE){
3194 header_extension= get_bits1(&s->gb);
3195 //FIXME more stuff here
3198 mb_num= get_bits(&s->gb, mb_num_bits);
3199 if(mb_num>=s->mb_num){
3200 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3203 if(s->pict_type == B_TYPE){
3204 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3205 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3208 s->mb_x= mb_num % s->mb_width;
3209 s->mb_y= mb_num / s->mb_width;
3211 if(s->shape != BIN_ONLY_SHAPE){
3212 int qscale= get_bits(&s->gb, s->quant_precision);
3214 s->chroma_qscale=s->qscale= qscale;
3217 if(s->shape == RECT_SHAPE){
3218 header_extension= get_bits1(&s->gb);
3220 if(header_extension){
3224 while (get_bits1(&s->gb) != 0)
3227 check_marker(&s->gb, "before time_increment in video packed header");
3228 time_increment= get_bits(&s->gb, s->time_increment_bits);
3229 check_marker(&s->gb, "before vop_coding_type in video packed header");
3231 skip_bits(&s->gb, 2); /* vop coding type */
3232 //FIXME not rect stuff here
3234 if(s->shape != BIN_ONLY_SHAPE){
3235 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3236 //FIXME don't just ignore everything
3237 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3238 mpeg4_decode_sprite_trajectory(s, &s->gb);
3239 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3242 //FIXME reduced res stuff here
3244 if (s->pict_type != I_TYPE) {
3245 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3247 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3250 if (s->pict_type == B_TYPE) {
3251 int b_code = get_bits(&s->gb, 3);
3253 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3258 //FIXME new-pred stuff
3260 //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));
3265 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3267 int c_wrap, c_xy, l_wrap, l_xy;
3269 l_wrap= s->b8_stride;
3270 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3271 c_wrap= s->mb_stride;
3272 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3276 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3277 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3278 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3282 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3283 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3284 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3287 // we can't clear the MVs as they might be needed by a b frame
3288 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3289 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3290 s->last_mv[0][0][0]=
3291 s->last_mv[0][0][1]=
3292 s->last_mv[1][0][0]=
3293 s->last_mv[1][0][1]= 0;
3297 * decodes the group of blocks / video packet header.
3298 * @return <0 if no resync found
3300 int ff_h263_resync(MpegEncContext *s){
3303 if(s->codec_id==CODEC_ID_MPEG4){
3305 align_get_bits(&s->gb);
3308 if(show_bits(&s->gb, 16)==0){
3309 if(s->codec_id==CODEC_ID_MPEG4)
3310 ret= mpeg4_decode_video_packet_header(s);
3312 ret= h263_decode_gob_header(s);
3316 //OK, it's not where it is supposed to be ...
3317 s->gb= s->last_resync_gb;
3318 align_get_bits(&s->gb);
3319 left= s->gb.size_in_bits - get_bits_count(&s->gb);
3321 for(;left>16+1+5+5; left-=8){
3322 if(show_bits(&s->gb, 16)==0){
3323 GetBitContext bak= s->gb;
3325 if(s->codec_id==CODEC_ID_MPEG4)
3326 ret= mpeg4_decode_video_packet_header(s);
3328 ret= h263_decode_gob_header(s);
3334 skip_bits(&s->gb, 8);
3341 * gets the average motion vector for a GMC MB.
3342 * @param n either 0 for the x component or 1 for y
3343 * @returns the average MV for a GMC MB
3345 static inline int get_amv(MpegEncContext *s, int n){
3346 int x, y, mb_v, sum, dx, dy, shift;
3347 int len = 1 << (s->f_code + 4);
3348 const int a= s->sprite_warping_accuracy;
3350 if(s->workaround_bugs & FF_BUG_AMV)
3351 len >>= s->quarter_sample;
3353 if(s->real_sprite_warping_points==1){
3354 if(s->divx_version==500 && s->divx_build==413)
3355 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3357 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3359 dx= s->sprite_delta[n][0];
3360 dy= s->sprite_delta[n][1];
3361 shift= s->sprite_shift[0];
3362 if(n) dy -= 1<<(shift + a + 1);
3363 else dx -= 1<<(shift + a + 1);
3364 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3367 for(y=0; y<16; y++){
3371 //XXX FIXME optimize
3372 for(x=0; x<16; x++){
3377 sum= RSHIFT(sum, a+8-s->quarter_sample);
3380 if (sum < -len) sum= -len;
3381 else if (sum >= len) sum= len-1;
3387 * decodes first partition.
3388 * @return number of MBs decoded or <0 if an error occured
3390 static int mpeg4_decode_partition_a(MpegEncContext *s){
3392 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3394 /* decode first partition */
3396 s->first_slice_line=1;
3397 for(; s->mb_y<s->mb_height; s->mb_y++){
3398 ff_init_block_index(s);
3399 for(; s->mb_x<s->mb_width; s->mb_x++){
3400 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3405 ff_update_block_index(s);
3406 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3407 s->first_slice_line=0;
3409 if(s->pict_type==I_TYPE){
3413 if(show_bits_long(&s->gb, 19)==DC_MARKER){
3417 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3419 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3424 s->cbp_table[xy]= cbpc & 3;
3425 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3429 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3431 s->current_picture.qscale_table[xy]= s->qscale;
3433 s->mbintra_table[xy]= 1;
3436 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3438 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3442 if(dc_pred_dir) dir|=1;
3444 s->pred_dir_table[xy]= dir;
3445 }else{ /* P/S_TYPE */
3446 int mx, my, pred_x, pred_y, bits;
3447 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3448 const int stride= s->b8_stride*2;
3451 bits= show_bits(&s->gb, 17);
3452 if(bits==MOTION_MARKER){
3458 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3459 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3463 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3466 mot_val[0 ]= mot_val[2 ]=
3467 mot_val[0+stride]= mot_val[2+stride]= mx;
3468 mot_val[1 ]= mot_val[3 ]=
3469 mot_val[1+stride]= mot_val[3+stride]= my;
3471 if(s->mbintra_table[xy])
3472 ff_clean_intra_table_entries(s);
3476 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3478 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3484 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3486 s->mb_intra = ((cbpc & 4) != 0);
3489 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3490 s->mbintra_table[xy]= 1;
3491 mot_val[0 ]= mot_val[2 ]=
3492 mot_val[0+stride]= mot_val[2+stride]= 0;
3493 mot_val[1 ]= mot_val[3 ]=
3494 mot_val[1+stride]= mot_val[3+stride]= 0;
3496 if(s->mbintra_table[xy])
3497 ff_clean_intra_table_entries(s);
3499 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3500 s->mcsel= get_bits1(&s->gb);
3503 if ((cbpc & 16) == 0) {
3504 /* 16x16 motion prediction */
3506 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3508 mx = h263_decode_motion(s, pred_x, s->f_code);
3512 my = h263_decode_motion(s, pred_y, s->f_code);
3515 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3519 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3522 mot_val[0 ]= mot_val[2 ] =
3523 mot_val[0+stride]= mot_val[2+stride]= mx;
3524 mot_val[1 ]= mot_val[3 ]=
3525 mot_val[1+stride]= mot_val[3+stride]= my;
3528 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3530 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3531 mx = h263_decode_motion(s, pred_x, s->f_code);
3535 my = h263_decode_motion(s, pred_y, s->f_code);
3552 * decode second partition.
3553 * @return <0 if an error occured
3555 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3557 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3559 s->mb_x= s->resync_mb_x;
3560 s->first_slice_line=1;
3561 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3562 ff_init_block_index(s);
3563 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3564 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3567 ff_update_block_index(s);
3568 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3569 s->first_slice_line=0;
3571 if(s->pict_type==I_TYPE){
3572 int ac_pred= get_bits1(&s->gb);
3573 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3575 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3579 s->cbp_table[xy]|= cbpy<<2;
3580 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3581 }else{ /* P || S_TYPE */
3582 if(IS_INTRA(s->current_picture.mb_type[xy])){
3584 int ac_pred = get_bits1(&s->gb);
3585 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3588 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3592 if(s->cbp_table[xy] & 8) {
3593 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3595 s->current_picture.qscale_table[xy]= s->qscale;
3599 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3601 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3605 if(dc_pred_dir) dir|=1;
3607 s->cbp_table[xy]&= 3; //remove dquant
3608 s->cbp_table[xy]|= cbpy<<2;
3609 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3610 s->pred_dir_table[xy]= dir;
3611 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3612 s->current_picture.qscale_table[xy]= s->qscale;
3613 s->cbp_table[xy]= 0;
3615 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3618 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3622 if(s->cbp_table[xy] & 8) {
3623 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3625 s->current_picture.qscale_table[xy]= s->qscale;
3627 s->cbp_table[xy]&= 3; //remove dquant
3628 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3632 if(mb_num >= mb_count) return 0;
3639 * decodes the first & second partition
3640 * @return <0 if error (and sets error type in the error_status_table)
3642 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3645 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3646 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3648 mb_num= mpeg4_decode_partition_a(s);
3650 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3654 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3655 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3656 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3660 s->mb_num_left= mb_num;
3662 if(s->pict_type==I_TYPE){
3663 while(show_bits(&s->gb, 9) == 1)
3664 skip_bits(&s->gb, 9);
3665 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3666 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3670 while(show_bits(&s->gb, 10) == 1)
3671 skip_bits(&s->gb, 10);
3672 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3673 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3677 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3679 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3680 if(s->pict_type==P_TYPE)
3681 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3684 if(s->pict_type==P_TYPE)
3685 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3692 * decode partition C of one MB.
3693 * @return <0 if an error occured
3695 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3698 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3700 mb_type= s->current_picture.mb_type[xy];
3701 cbp = s->cbp_table[xy];
3703 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3705 if(s->current_picture.qscale_table[xy] != s->qscale){
3706 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3709 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3712 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3713 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3715 s->mb_intra = IS_INTRA(mb_type);
3717 if (IS_SKIP(mb_type)) {
3720 s->block_last_index[i] = -1;
3721 s->mv_dir = MV_DIR_FORWARD;
3722 s->mv_type = MV_TYPE_16X16;
3723 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3730 }else if(s->mb_intra){
3731 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3732 }else if(!s->mb_intra){
3733 // s->mcsel= 0; //FIXME do we need to init that
3735 s->mv_dir = MV_DIR_FORWARD;
3736 if (IS_8X8(mb_type)) {
3737 s->mv_type = MV_TYPE_8X8;
3739 s->mv_type = MV_TYPE_16X16;
3742 } else { /* I-Frame */
3744 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3747 if (!IS_SKIP(mb_type)) {
3749 s->dsp.clear_blocks(s->block[0]);
3750 /* decode each block */
3751 for (i = 0; i < 6; i++) {
3752 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3753 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3760 /* per-MB end of slice check */
3762 if(--s->mb_num_left <= 0){
3763 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3764 if(mpeg4_is_resync(s))
3769 if(mpeg4_is_resync(s)){
3770 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3771 if(s->cbp_table[xy+delta])
3779 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3781 static void preview_obmc(MpegEncContext *s){
3782 GetBitContext gb= s->gb;
3784 int cbpc, i, pred_x, pred_y, mx, my;
3786 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3787 const int stride= s->b8_stride*2;
3790 s->block_index[i]+= 2;
3792 s->block_index[i]+= 1;
3795 assert(s->pict_type == P_TYPE);
3798 if (get_bits1(&s->gb)) {
3800 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3801 mot_val[0 ]= mot_val[2 ]=
3802 mot_val[0+stride]= mot_val[2+stride]= 0;
3803 mot_val[1 ]= mot_val[3 ]=
3804 mot_val[1+stride]= mot_val[3+stride]= 0;
3806 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3809 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3813 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3815 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3817 if(s->modified_quant){
3818 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3819 else skip_bits(&s->gb, 5);
3821 skip_bits(&s->gb, 2);
3824 if ((cbpc & 16) == 0) {
3825 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3826 /* 16x16 motion prediction */
3827 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3829 mx = h263p_decode_umotion(s, pred_x);
3831 mx = h263_decode_motion(s, pred_x, 1);
3834 my = h263p_decode_umotion(s, pred_y);
3836 my = h263_decode_motion(s, pred_y, 1);
3838 mot_val[0 ]= mot_val[2 ]=
3839 mot_val[0+stride]= mot_val[2+stride]= mx;
3840 mot_val[1 ]= mot_val[3 ]=
3841 mot_val[1+stride]= mot_val[3+stride]= my;
3843 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3845 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3847 mx = h263p_decode_umotion(s, pred_x);
3849 mx = h263_decode_motion(s, pred_x, 1);
3852 my = h263p_decode_umotion(s, pred_y);
3854 my = h263_decode_motion(s, pred_y, 1);
3855 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3856 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3865 s->block_index[i]-= 2;
3867 s->block_index[i]-= 1;
3873 static void h263_decode_dquant(MpegEncContext *s){
3874 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3876 if(s->modified_quant){
3877 if(get_bits1(&s->gb))
3878 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3880 s->qscale= get_bits(&s->gb, 5);
3882 s->qscale += quant_tab[get_bits(&s->gb, 2)];
3883 ff_set_qscale(s, s->qscale);
3886 int ff_h263_decode_mb(MpegEncContext *s,
3887 DCTELEM block[6][64])
3889 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3891 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3893 assert(!s->h263_pred);
3895 if (s->pict_type == P_TYPE) {
3897 if (get_bits1(&s->gb)) {
3901 s->block_last_index[i] = -1;
3902 s->mv_dir = MV_DIR_FORWARD;
3903 s->mv_type = MV_TYPE_16X16;
3904 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3907 s->mb_skipped = !(s->obmc | s->loop_filter);
3910 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3911 //fprintf(stderr, "\tCBPC: %d", cbpc);
3913 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3918 s->dsp.clear_blocks(s->block[0]);
3921 s->mb_intra = ((cbpc & 4) != 0);
3922 if (s->mb_intra) goto intra;
3924 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3926 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3929 cbp = (cbpc & 3) | (cbpy << 2);
3931 h263_decode_dquant(s);
3934 s->mv_dir = MV_DIR_FORWARD;
3935 if ((cbpc & 16) == 0) {
3936 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3937 /* 16x16 motion prediction */
3938 s->mv_type = MV_TYPE_16X16;
3939 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3941 mx = h263p_decode_umotion(s, pred_x);
3943 mx = h263_decode_motion(s, pred_x, 1);
3949 my = h263p_decode_umotion(s, pred_y);
3951 my = h263_decode_motion(s, pred_y, 1);
3955 s->mv[0][0][0] = mx;
3956 s->mv[0][0][1] = my;
3958 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3959 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3961 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3962 s->mv_type = MV_TYPE_8X8;
3964 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3966 mx = h263p_decode_umotion(s, pred_x);
3968 mx = h263_decode_motion(s, pred_x, 1);
3973 my = h263p_decode_umotion(s, pred_y);
3975 my = h263_decode_motion(s, pred_y, 1);
3978 s->mv[0][i][0] = mx;
3979 s->mv[0][i][1] = my;
3980 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3981 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3987 /* decode each block */
3988 for (i = 0; i < 6; i++) {
3989 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3995 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
3998 } else if(s->pict_type==B_TYPE) {
4000 const int stride= s->b8_stride;
4001 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4002 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4003 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4006 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4007 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4008 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4009 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4012 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4014 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4018 mb_type= h263_mb_type_b_map[ mb_type ];
4021 s->mb_intra = IS_INTRA(mb_type);
4022 if(HAS_CBP(mb_type)){
4023 s->dsp.clear_blocks(s->block[0]);
4024 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4026 dquant = IS_QUANT(mb_type);
4030 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4033 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4037 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4040 cbp = (cbpc & 3) | (cbpy << 2);
4044 assert(!s->mb_intra);
4046 if(IS_QUANT(mb_type)){
4047 h263_decode_dquant(s);
4050 if(IS_DIRECT(mb_type)){
4051 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4052 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4055 s->mv_type= MV_TYPE_16X16;
4058 if(USES_LIST(mb_type, 0)){
4059 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4060 s->mv_dir = MV_DIR_FORWARD;
4062 mx = h263_decode_motion(s, mx, 1);
4063 my = h263_decode_motion(s, my, 1);
4065 s->mv[0][0][0] = mx;
4066 s->mv[0][0][1] = my;
4067 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4068 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4071 if(USES_LIST(mb_type, 1)){
4072 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4073 s->mv_dir |= MV_DIR_BACKWARD;
4075 mx = h263_decode_motion(s, mx, 1);
4076 my = h263_decode_motion(s, my, 1);
4078 s->mv[1][0][0] = mx;
4079 s->mv[1][0][1] = my;
4080 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4081 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4085 s->current_picture.mb_type[xy]= mb_type;
4087 /* decode each block */
4088 for (i = 0; i < 6; i++) {
4089 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4093 } else { /* I-Frame */
4095 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4097 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4102 s->dsp.clear_blocks(s->block[0]);
4107 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4109 s->ac_pred = get_bits1(&s->gb);
4111 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4113 s->h263_aic_dir = get_bits1(&s->gb);
4118 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4120 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4123 cbp = (cbpc & 3) | (cbpy << 2);
4125 h263_decode_dquant(s);
4128 /* decode each block */
4129 for (i = 0; i < 6; i++) {
4130 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4137 /* per-MB end of slice check */
4139 int v= show_bits(&s->gb, 16);
4141 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4142 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4152 int ff_mpeg4_decode_mb(MpegEncContext *s,
4153 DCTELEM block[6][64])
4155 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4157 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4158 const int xy= s->mb_x + s->mb_y * s->mb_stride;
4160 assert(s->h263_pred);
4162 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4164 if (get_bits1(&s->gb)) {
4168 s->block_last_index[i] = -1;
4169 s->mv_dir = MV_DIR_FORWARD;
4170 s->mv_type = MV_TYPE_16X16;
4171 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4172 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4174 s->mv[0][0][0]= get_amv(s, 0);
4175 s->mv[0][0][1]= get_amv(s, 1);
4179 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4187 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4188 //fprintf(stderr, "\tCBPC: %d", cbpc);
4190 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4195 s->dsp.clear_blocks(s->block[0]);
4197 s->mb_intra = ((cbpc & 4) != 0);
4198 if (s->mb_intra) goto intra;
4200 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4201 s->mcsel= get_bits1(&s->gb);
4203 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4205 cbp = (cbpc & 3) | (cbpy << 2);
4207 ff_set_qscale(s, s->qscale