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
30 * @file libavcodec/h263.c
39 #include "mpegvideo.h"
41 #include "mpeg4data.h"
48 #define INTRA_MCBPC_VLC_BITS 6
49 #define INTER_MCBPC_VLC_BITS 7
50 #define CBPY_VLC_BITS 6
53 #define SPRITE_TRAJ_VLC_BITS 6
54 #define MB_TYPE_B_VLC_BITS 4
55 #define TEX_VLC_BITS 9
56 #define H263_MBTYPE_B_VLC_BITS 6
57 #define CBPC_B_VLC_BITS 3
60 static void mpeg4_encode_visual_object_header(MpegEncContext *s);
61 static void mpeg4_encode_vol_header(MpegEncContext *s, int vo_number,
63 static inline void mpeg4_encode_block(MpegEncContext *s, DCTELEM *block,
64 int n, int dc, uint8_t *scan_table,
66 PutBitContext *ac_pb);
67 static int mpeg4_get_block_length(MpegEncContext *s, DCTELEM *block, int n,
68 int intra_dc, uint8_t *scan_table);
70 static uint8_t uni_DCtab_lum_len[512];
71 static uint8_t uni_DCtab_chrom_len[512];
72 static uint16_t uni_DCtab_lum_bits[512];
73 static uint16_t uni_DCtab_chrom_bits[512];
75 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
76 static uint8_t fcode_tab[MAX_MV*2+1];
77 static uint8_t umv_fcode_tab[MAX_MV*2+1];
79 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
80 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
81 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
82 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
83 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
84 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
85 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
86 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
87 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
100 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
102 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
103 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
108 int h263_get_picture_format(int width, int height)
112 if (width == 128 && height == 96)
114 else if (width == 176 && height == 144)
116 else if (width == 352 && height == 288)
118 else if (width == 704 && height == 576)
120 else if (width == 1408 && height == 1152)
127 static void show_pict_info(MpegEncContext *s){
128 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",
129 s->qscale, av_get_pict_type_char(s->pict_type),
130 s->gb.size_in_bits, 1-s->no_rounding,
131 s->obmc ? " AP" : "",
132 s->umvplus ? " UMV" : "",
133 s->h263_long_vectors ? " LONG" : "",
134 s->h263_plus ? " +" : "",
135 s->h263_aic ? " AIC" : "",
136 s->alt_inter_vlc ? " AIV" : "",
137 s->modified_quant ? " MQ" : "",
138 s->loop_filter ? " LOOP" : "",
139 s->h263_slice_structured ? " SS" : "",
140 s->avctx->time_base.den, s->avctx->time_base.num
146 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
149 if(aspect.num==0) aspect= (AVRational){1,1};
152 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
153 s->aspect_ratio_info=i;
158 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
161 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
165 align_put_bits(&s->pb);
167 put_bits(&s->pb, 17, 1);
168 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
169 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
170 s->avctx->time_base.den) & 0xff); /* TemporalReference */
171 if (s->width == 352 && s->height == 288)
173 else if (s->width == 176 && s->height == 144)
175 else if (s->width == 128 && s->height == 96)
177 else if (s->width == 320 && s->height == 240)
179 else if (s->width == 160 && s->height == 120)
181 else if (s->width <= 255 && s->height <= 255)
182 format = 0; /* use 1 byte width & height */
184 format = 1; /* use 2 bytes width & height */
185 put_bits(&s->pb, 3, format); /* PictureSize */
187 put_bits(&s->pb, 8, s->width);
188 put_bits(&s->pb, 8, s->height);
189 } else if (format == 1) {
190 put_bits(&s->pb, 16, s->width);
191 put_bits(&s->pb, 16, s->height);
193 put_bits(&s->pb, 2, s->pict_type == FF_P_TYPE); /* PictureType */
194 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
195 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
196 put_bits(&s->pb, 1, 0); /* ExtraInformation */
200 s->c_dc_scale_table= ff_aic_dc_scale_table;
203 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
207 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
209 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
210 int best_clock_code=1;
212 int best_error= INT_MAX;
217 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
218 div= av_clip(div, 1, 127);
219 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
220 if(error < best_error){
227 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
228 coded_frame_rate= 1800000;
229 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
231 align_put_bits(&s->pb);
233 /* Update the pointer to last GOB */
234 s->ptr_lastgob = put_bits_ptr(&s->pb);
235 put_bits(&s->pb, 22, 0x20); /* PSC */
236 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
237 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
238 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
240 put_bits(&s->pb, 1, 1); /* marker */
241 put_bits(&s->pb, 1, 0); /* h263 id */
242 put_bits(&s->pb, 1, 0); /* split screen off */
243 put_bits(&s->pb, 1, 0); /* camera off */
244 put_bits(&s->pb, 1, 0); /* freeze picture release off */
246 format = h263_get_picture_format(s->width, s->height);
249 put_bits(&s->pb, 3, format);
250 put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
251 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
252 of H.263v1 UMV implies to check the predicted MV after
253 calculation of the current MB to see if we're on the limits */
254 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
255 put_bits(&s->pb, 1, 0); /* SAC: off */
256 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
257 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
258 put_bits(&s->pb, 5, s->qscale);
259 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
263 /* H.263 Plus PTYPE */
265 put_bits(&s->pb, 3, 7);
266 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
268 put_bits(&s->pb,3,6); /* Custom Source Format */
270 put_bits(&s->pb, 3, format);
272 put_bits(&s->pb,1, s->custom_pcf);
273 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
274 put_bits(&s->pb,1,0); /* SAC: off */
275 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
276 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
277 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
278 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
279 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
280 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
281 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
282 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
283 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
284 put_bits(&s->pb,3,0); /* Reserved */
286 put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE);
288 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
289 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
290 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
291 put_bits(&s->pb,2,0); /* Reserved */
292 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
294 /* This should be here if PLUSPTYPE */
295 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
298 /* Custom Picture Format (CPFMT) */
299 aspect_to_info(s, s->avctx->sample_aspect_ratio);
301 put_bits(&s->pb,4,s->aspect_ratio_info);
302 put_bits(&s->pb,9,(s->width >> 2) - 1);
303 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
304 put_bits(&s->pb,9,(s->height >> 2));
305 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
306 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
307 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
312 put_bits(&s->pb, 1, best_clock_code);
313 put_bits(&s->pb, 7, best_divisor);
315 put_sbits(&s->pb, 2, temp_ref>>8);
318 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
320 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
321 //FIXME check actual requested range
322 put_bits(&s->pb,2,1); /* unlimited */
323 if(s->h263_slice_structured)
324 put_bits(&s->pb,2,0); /* no weird submodes */
326 put_bits(&s->pb, 5, s->qscale);
329 put_bits(&s->pb, 1, 0); /* no PEI */
331 if(s->h263_slice_structured){
332 put_bits(&s->pb, 1, 1);
334 assert(s->mb_x == 0 && s->mb_y == 0);
335 ff_h263_encode_mba(s);
337 put_bits(&s->pb, 1, 1);
342 s->c_dc_scale_table= ff_aic_dc_scale_table;
345 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
350 * Encodes a group of blocks header.
352 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
354 put_bits(&s->pb, 17, 1); /* GBSC */
356 if(s->h263_slice_structured){
357 put_bits(&s->pb, 1, 1);
359 ff_h263_encode_mba(s);
362 put_bits(&s->pb, 1, 1);
363 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
364 put_bits(&s->pb, 1, 1);
365 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
367 int gob_number= mb_line / s->gob_index;
369 put_bits(&s->pb, 5, gob_number); /* GN */
370 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */
371 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
375 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
380 for(j=1; j<=block_last_index; j++){
381 const int index= scantable[j];
382 int level= block[index];
385 if((level&(~127)) == 0){
386 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
387 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
389 rate += s->ac_esc_length;
398 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
402 int8_t * const qscale_table= s->current_picture.qscale_table;
404 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
407 int16_t *ac_val, *ac_val1;
409 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
411 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
414 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
416 ac_val-= s->block_wrap[n]*16;
417 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
420 const int level= block[n][s->dsp.idct_permutation[i ]];
421 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
422 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
426 /* different qscale, we must rescale */
428 const int level= block[n][s->dsp.idct_permutation[i ]];
429 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
430 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
434 st[n]= s->intra_h_scantable.permutated;
436 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
437 /* left prediction */
439 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
442 const int level= block[n][s->dsp.idct_permutation[i<<3]];
443 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
445 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
448 /* different qscale, we must rescale */
450 const int level= block[n][s->dsp.idct_permutation[i<<3]];
451 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
453 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
456 st[n]= s->intra_v_scantable.permutated;
459 for(i=63; i>0; i--) //FIXME optimize
460 if(block[n][ st[n][i] ]) break;
461 s->block_last_index[n]= i;
463 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
469 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
472 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
475 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
477 st[n]= s->intra_scantable.permutated;
481 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
484 /* left prediction */
486 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
493 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
495 void ff_clean_h263_qscales(MpegEncContext *s){
497 int8_t * const qscale_table= s->current_picture.qscale_table;
499 ff_init_qscale_tab(s);
501 for(i=1; i<s->mb_num; i++){
502 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
503 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
505 for(i=s->mb_num-2; i>=0; i--){
506 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
507 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
510 if(s->codec_id != CODEC_ID_H263P){
511 for(i=1; i<s->mb_num; i++){
512 int mb_xy= s->mb_index2xy[i];
514 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
515 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
522 * modify mb_type & qscale so that encoding is acually possible in mpeg4
524 void ff_clean_mpeg4_qscales(MpegEncContext *s){
526 int8_t * const qscale_table= s->current_picture.qscale_table;
528 ff_clean_h263_qscales(s);
530 if(s->pict_type== FF_B_TYPE){
532 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
534 for(i=0; i<s->mb_num; i++){
535 int mb_xy= s->mb_index2xy[i];
536 odd += qscale_table[mb_xy]&1;
539 if(2*odd > s->mb_num) odd=1;
542 for(i=0; i<s->mb_num; i++){
543 int mb_xy= s->mb_index2xy[i];
544 if((qscale_table[mb_xy]&1) != odd)
545 qscale_table[mb_xy]++;
546 if(qscale_table[mb_xy] > 31)
547 qscale_table[mb_xy]= 31;
550 for(i=1; i<s->mb_num; i++){
551 int mb_xy= s->mb_index2xy[i];
552 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
553 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
559 #endif //CONFIG_ENCODERS
561 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
562 #define tab_bias (tab_size/2)
564 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
566 for(i=0; i<tab_size; i++){
567 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
568 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
572 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
573 int xy= s->block_index[i];
574 uint16_t time_pp= s->pp_time;
575 uint16_t time_pb= s->pb_time;
578 p_mx= s->next_picture.motion_val[0][xy][0];
579 if((unsigned)(p_mx + tab_bias) < tab_size){
580 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
581 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
582 : s->direct_scale_mv[1][p_mx + tab_bias];
584 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
585 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
586 : p_mx*(time_pb - time_pp)/time_pp;
588 p_my= s->next_picture.motion_val[0][xy][1];
589 if((unsigned)(p_my + tab_bias) < tab_size){
590 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
591 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
592 : s->direct_scale_mv[1][p_my + tab_bias];
594 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
595 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
596 : p_my*(time_pb - time_pp)/time_pp;
605 * @return the mb_type
607 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
608 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
609 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
614 //FIXME avoid divides
615 // try special case with shifts for 1 and 3 B-frames?
617 if(IS_8X8(colocated_mb_type)){
618 s->mv_type = MV_TYPE_8X8;
620 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
622 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
623 } else if(IS_INTERLACED(colocated_mb_type)){
624 s->mv_type = MV_TYPE_FIELD;
626 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
627 s->field_select[0][i]= field_select;
628 s->field_select[1][i]= i;
629 if(s->top_field_first){
630 time_pp= s->pp_field_time - field_select + i;
631 time_pb= s->pb_field_time - field_select + i;
633 time_pp= s->pp_field_time + field_select - i;
634 time_pb= s->pb_field_time + field_select - i;
636 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
637 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
638 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
639 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
640 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
641 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
643 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
645 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
646 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
647 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
648 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
649 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
650 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
651 s->mv_type= MV_TYPE_16X16;
653 s->mv_type= MV_TYPE_8X8;
654 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
658 void ff_h263_update_motion_val(MpegEncContext * s){
659 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
660 //FIXME a lot of that is only needed for !low_delay
661 const int wrap = s->b8_stride;
662 const int xy = s->block_index[0];
664 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
666 if(s->mv_type != MV_TYPE_8X8){
667 int motion_x, motion_y;
671 } else if (s->mv_type == MV_TYPE_16X16) {
672 motion_x = s->mv[0][0][0];
673 motion_y = s->mv[0][0][1];
674 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
676 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
677 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
678 motion_x = (motion_x>>1) | (motion_x&1);
680 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
681 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
683 s->current_picture.ref_index[0][xy ]=
684 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
685 s->current_picture.ref_index[0][xy + wrap ]=
686 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
689 /* no update if 8X8 because it has been done during parsing */
690 s->current_picture.motion_val[0][xy][0] = motion_x;
691 s->current_picture.motion_val[0][xy][1] = motion_y;
692 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
693 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
694 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
695 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
696 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
697 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
700 if(s->encoding){ //FIXME encoding MUST be cleaned up
701 if (s->mv_type == MV_TYPE_8X8)
702 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
704 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
706 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
712 * encoding quantized level -> quantized diff
713 * decoding quantized diff -> quantized level
714 * @param n block index (0-3 are luma, 4-5 are chroma)
715 * @param dir_ptr pointer to an integer where the prediction direction will be stored
717 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
719 int a, b, c, wrap, pred, scale, ret;
722 /* find prediction */
724 scale = s->y_dc_scale;
726 scale = s->c_dc_scale;
731 wrap= s->block_wrap[n];
732 dc_val = s->dc_val[0] + s->block_index[n];
738 b = dc_val[ - 1 - wrap];
741 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
742 if(s->first_slice_line && n!=3){
744 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
746 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
747 if(n==0 || n==4 || n==5)
751 if (abs(a - b) < abs(b - c)) {
753 *dir_ptr = 1; /* top */
756 *dir_ptr = 0; /* left */
758 /* we assume pred is positive */
759 pred = FASTDIV((pred + (scale >> 1)), scale);
766 if(s->error_recognition>=3){
768 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
771 if(level*scale > 2048 + scale){
772 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
781 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
791 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
792 int l, bit_size, code;
797 bit_size = f_code - 1;
798 /* modulo encoding */
799 l= INT_BIT - 6 - bit_size;
802 code = (val >> bit_size) + 1;
804 return mvtab[code][1] + 1 + bit_size;
808 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
809 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
810 skip_put_bits(&s->pb,
811 h263_get_motion_length(s, x, f_code)
812 +h263_get_motion_length(s, y, f_code));
814 ff_h263_encode_motion(s, x, f_code);
815 ff_h263_encode_motion(s, y, f_code);
819 static inline int get_p_cbp(MpegEncContext * s,
820 DCTELEM block[6][64],
821 int motion_x, int motion_y){
824 if(s->flags & CODEC_FLAG_CBP_RD){
825 int best_cbpy_score= INT_MAX;
826 int best_cbpc_score= INT_MAX;
827 int cbpc = (-1), cbpy= (-1);
828 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
829 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
832 int score= inter_MCBPC_bits[i + offset] * lambda;
833 if(i&1) score += s->coded_score[5];
834 if(i&2) score += s->coded_score[4];
836 if(score < best_cbpc_score){
837 best_cbpc_score= score;
843 int score= cbpy_tab[i ^ 0xF][1] * lambda;
844 if(i&1) score += s->coded_score[3];
845 if(i&2) score += s->coded_score[2];
846 if(i&4) score += s->coded_score[1];
847 if(i&8) score += s->coded_score[0];
849 if(score < best_cbpy_score){
850 best_cbpy_score= score;
855 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
856 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
860 for (i = 0; i < 6; i++) {
861 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
862 s->block_last_index[i]= -1;
863 s->dsp.clear_block(s->block[i]);
868 for (i = 0; i < 6; i++) {
869 if (s->block_last_index[i] >= 0)
876 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
877 int motion_x, int motion_y, int mb_type){
880 if(s->flags & CODEC_FLAG_CBP_RD){
882 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
885 if(s->coded_score[i] < 0){
886 score += s->coded_score[i];
893 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
894 zero_score-= 4; //2*MV + mb_type + cbp bit
898 if(zero_score <= score){
903 for (i = 0; i < 6; i++) {
904 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
905 s->block_last_index[i]= -1;
906 s->dsp.clear_block(s->block[i]);
910 for (i = 0; i < 6; i++) {
911 if (s->block_last_index[i] >= 0)
918 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
919 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
923 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
924 for (i = 0; i < 6; i++) {
925 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
928 /* encode each block */
929 for (i = 0; i < 6; i++) {
930 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
934 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
935 for (i = 0; i < 6; i++) {
936 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
939 /* encode each block */
940 for (i = 0; i < 6; i++) {
941 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
947 static const int dquant_code[5]= {1,0,9,2,3};
949 void mpeg4_encode_mb(MpegEncContext * s,
950 DCTELEM block[6][64],
951 int motion_x, int motion_y)
953 int cbpc, cbpy, pred_x, pred_y;
954 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
955 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb;
956 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2 : &s->pb;
957 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
962 if(s->pict_type==FF_B_TYPE){
963 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
964 int mb_type= mb_type_table[s->mv_dir];
971 s->last_mv[i][1][1]= 0;
975 assert(s->dquant>=-2 && s->dquant<=2);
976 assert((s->dquant&1)==0);
979 /* nothing to do if this MB was skipped in the next P Frame */
980 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
986 s->mv_dir= MV_DIR_FORWARD; //doesn't matter
987 s->qscale -= s->dquant;
993 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
995 if ((cbp | motion_x | motion_y | mb_type) ==0) {
996 /* direct MB with MV={0,0} */
997 assert(s->dquant==0);
999 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
1001 if(interleaved_stats){
1009 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
1010 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
1011 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
1012 if(cbp) put_bits(&s->pb, 6, cbp);
1016 put_bits(&s->pb, 2, (s->dquant>>2)+3);
1018 put_bits(&s->pb, 1, 0);
1020 s->qscale -= s->dquant;
1022 if(!s->progressive_sequence){
1024 put_bits(&s->pb, 1, s->interlaced_dct);
1025 if(mb_type) // not direct mode
1026 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
1029 if(interleaved_stats){
1030 s->misc_bits+= get_bits_diff(s);
1034 assert(s->mv_dir & MV_DIRECT);
1035 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
1039 assert(mb_type > 0 && mb_type < 4);
1040 if(s->mv_type != MV_TYPE_FIELD){
1041 if(s->mv_dir & MV_DIR_FORWARD){
1042 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
1043 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
1044 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
1045 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
1048 if(s->mv_dir & MV_DIR_BACKWARD){
1049 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
1050 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1051 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
1052 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
1056 if(s->mv_dir & MV_DIR_FORWARD){
1057 put_bits(&s->pb, 1, s->field_select[0][0]);
1058 put_bits(&s->pb, 1, s->field_select[0][1]);
1060 if(s->mv_dir & MV_DIR_BACKWARD){
1061 put_bits(&s->pb, 1, s->field_select[1][0]);
1062 put_bits(&s->pb, 1, s->field_select[1][1]);
1064 if(s->mv_dir & MV_DIR_FORWARD){
1066 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
1067 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1068 s->last_mv[0][i][0]= s->mv[0][i][0];
1069 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1073 if(s->mv_dir & MV_DIR_BACKWARD){
1075 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
1076 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1077 s->last_mv[1][i][0]= s->mv[1][i][0];
1078 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1085 if(interleaved_stats){
1086 s->mv_bits+= get_bits_diff(s);
1089 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
1091 if(interleaved_stats){
1092 s->p_tex_bits+= get_bits_diff(s);
1095 }else{ /* s->pict_type==FF_B_TYPE */
1096 cbp= get_p_cbp(s, block, motion_x, motion_y);
1098 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
1099 /* check if the B frames can skip it too, as we must skip it if we skip here
1100 why didn't they just compress the skip-mb bits instead of reusing them ?! */
1101 if(s->max_b_frames>0){
1108 if(x+16 > s->width) x= s->width-16;
1109 if(y+16 > s->height) y= s->height-16;
1111 offset= x + y*s->linesize;
1112 p_pic= s->new_picture.data[0] + offset;
1115 for(i=0; i<s->max_b_frames; i++){
1118 Picture *pic= s->reordered_input_picture[i+1];
1120 if(pic==NULL || pic->pict_type!=FF_B_TYPE) break;
1122 b_pic= pic->data[0] + offset;
1123 if(pic->type != FF_BUFFER_TYPE_SHARED)
1124 b_pic+= INPLACE_OFFSET;
1125 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1126 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1134 if(s->mb_skipped==1){
1135 /* skip macroblock */
1136 put_bits(&s->pb, 1, 1);
1138 if(interleaved_stats){
1148 put_bits(&s->pb, 1, 0); /* mb coded */
1152 if(s->mv_type==MV_TYPE_16X16){
1153 if(s->dquant) cbpc+= 8;
1155 inter_MCBPC_bits[cbpc],
1156 inter_MCBPC_code[cbpc]);
1158 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1160 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1162 if(!s->progressive_sequence){
1164 put_bits(pb2, 1, s->interlaced_dct);
1165 put_bits(pb2, 1, 0);
1168 if(interleaved_stats){
1169 s->misc_bits+= get_bits_diff(s);
1172 /* motion vectors: 16x16 mode */
1173 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1175 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1176 motion_y - pred_y, s->f_code);
1177 }else if(s->mv_type==MV_TYPE_FIELD){
1178 if(s->dquant) cbpc+= 8;
1180 inter_MCBPC_bits[cbpc],
1181 inter_MCBPC_code[cbpc]);
1183 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1185 put_bits(pb2, 2, dquant_code[s->dquant+2]);
1187 assert(!s->progressive_sequence);
1189 put_bits(pb2, 1, s->interlaced_dct);
1190 put_bits(pb2, 1, 1);
1192 if(interleaved_stats){
1193 s->misc_bits+= get_bits_diff(s);
1196 /* motion vectors: 16x8 interlaced mode */
1197 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1200 put_bits(&s->pb, 1, s->field_select[0][0]);
1201 put_bits(&s->pb, 1, s->field_select[0][1]);
1203 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1204 s->mv[0][0][1] - pred_y, s->f_code);
1205 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1206 s->mv[0][1][1] - pred_y, s->f_code);
1208 assert(s->mv_type==MV_TYPE_8X8);
1210 inter_MCBPC_bits[cbpc+16],
1211 inter_MCBPC_code[cbpc+16]);
1212 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1214 if(!s->progressive_sequence){
1216 put_bits(pb2, 1, s->interlaced_dct);
1219 if(interleaved_stats){
1220 s->misc_bits+= get_bits_diff(s);
1224 /* motion vectors: 8x8 mode*/
1225 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1227 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1228 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1232 if(interleaved_stats){
1233 s->mv_bits+= get_bits_diff(s);
1236 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1238 if(interleaved_stats){
1239 s->p_tex_bits+= get_bits_diff(s);
1245 int dc_diff[6]; //dc values with the dc prediction subtracted
1246 int dir[6]; //prediction direction
1247 int zigzag_last_index[6];
1248 uint8_t *scan_table[6];
1252 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1255 if(s->flags & CODEC_FLAG_AC_PRED){
1256 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1258 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1261 scan_table[i]= s->intra_scantable.permutated;
1266 for (i = 0; i < 6; i++) {
1267 if (s->block_last_index[i] >= 1)
1268 cbp |= 1 << (5 - i);
1272 if (s->pict_type == FF_I_TYPE) {
1273 if(s->dquant) cbpc+=4;
1275 intra_MCBPC_bits[cbpc],
1276 intra_MCBPC_code[cbpc]);
1278 if(s->dquant) cbpc+=8;
1279 put_bits(&s->pb, 1, 0); /* mb coded */
1281 inter_MCBPC_bits[cbpc + 4],
1282 inter_MCBPC_code[cbpc + 4]);
1284 put_bits(pb2, 1, s->ac_pred);
1286 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1288 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1290 if(!s->progressive_sequence){
1291 put_bits(dc_pb, 1, s->interlaced_dct);
1294 if(interleaved_stats){
1295 s->misc_bits+= get_bits_diff(s);
1298 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1300 if(interleaved_stats){
1301 s->i_tex_bits+= get_bits_diff(s);
1305 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1307 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1312 * encodes a 8x8 block.
1313 * @param block the 8x8 block
1314 * @param n block index (0-3 are luma, 4-5 are chroma)
1316 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1318 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1322 if (s->mb_intra && !s->h263_aic) {
1325 /* 255 cannot be represented, so we clamp */
1330 /* 0 cannot be represented also */
1331 else if (level < 1) {
1335 if (level == 128) //FIXME check rv10
1336 put_bits(&s->pb, 8, 0xff);
1338 put_bits(&s->pb, 8, level);
1342 if (s->h263_aic && s->mb_intra)
1345 if(s->alt_inter_vlc && !s->mb_intra){
1347 int inter_vlc_bits=0;
1351 last_index = s->block_last_index[n];
1352 last_non_zero = i - 1;
1353 for (; i <= last_index; i++) {
1354 j = s->intra_scantable.permutated[i];
1357 run = i - last_non_zero - 1;
1358 last = (i == last_index);
1360 if(level<0) level= -level;
1362 code = get_rl_index(rl, last, run, level);
1363 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
1364 inter_vlc_bits += rl->table_vlc[code][1]+1;
1365 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
1367 if (code == rl->n) {
1368 inter_vlc_bits += 1+6+8-1;
1370 if (aic_code == rl_intra_aic.n) {
1371 aic_vlc_bits += 1+6+8-1;
1372 wrong_pos += run + 1;
1374 wrong_pos += wrong_run[aic_code];
1379 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
1385 last_index = s->block_last_index[n];
1386 last_non_zero = i - 1;
1387 for (; i <= last_index; i++) {
1388 j = s->intra_scantable.permutated[i];
1391 run = i - last_non_zero - 1;
1392 last = (i == last_index);
1399 code = get_rl_index(rl, last, run, level);
1400 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1401 if (code == rl->n) {
1402 if(s->h263_flv <= 1){
1403 put_bits(&s->pb, 1, last);
1404 put_bits(&s->pb, 6, run);
1406 assert(slevel != 0);
1409 put_sbits(&s->pb, 8, slevel);
1411 put_bits(&s->pb, 8, 128);
1412 put_sbits(&s->pb, 5, slevel);
1413 put_sbits(&s->pb, 6, slevel>>5);
1416 if(level < 64) { // 7-bit level
1417 put_bits(&s->pb, 1, 0);
1418 put_bits(&s->pb, 1, last);
1419 put_bits(&s->pb, 6, run);
1421 put_sbits(&s->pb, 7, slevel);
1424 put_bits(&s->pb, 1, 1);
1425 put_bits(&s->pb, 1, last);
1426 put_bits(&s->pb, 6, run);
1428 put_sbits(&s->pb, 11, slevel);
1432 put_bits(&s->pb, 1, sign);
1439 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1440 static void h263p_encode_umotion(MpegEncContext * s, int val)
1450 put_bits(&s->pb, 1, 1);
1452 put_bits(&s->pb, 3, 0);
1454 put_bits(&s->pb, 3, 2);
1457 sval = ((val < 0) ? (short)(-val):(short)val);
1460 while (temp_val != 0) {
1461 temp_val = temp_val >> 1;
1467 tcode = (sval & (1 << (i-1))) >> (i-1);
1468 tcode = (tcode << 1) | 1;
1469 code = (code << 2) | tcode;
1472 code = ((code << 1) | (val < 0)) << 1;
1473 put_bits(&s->pb, (2*n_bits)+1, code);
1477 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1479 int x, y, wrap, a, c, pred_dc;
1482 /* find prediction */
1484 x = 2 * s->mb_x + (n & 1);
1485 y = 2 * s->mb_y + ((n & 2) >> 1);
1486 wrap = s->b8_stride;
1487 dc_val = s->dc_val[0];
1491 wrap = s->mb_stride;
1492 dc_val = s->dc_val[n - 4 + 1];
1497 a = dc_val[(x - 1) + (y) * wrap];
1498 c = dc_val[(x) + (y - 1) * wrap];
1500 /* No prediction outside GOB boundary */
1501 if(s->first_slice_line && n!=3){
1503 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1505 /* just DC prediction */
1506 if (a != 1024 && c != 1024)
1507 pred_dc = (a + c) >> 1;
1513 /* we assume pred is positive */
1514 *dc_val_ptr = &dc_val[x + y * wrap];
1518 void h263_encode_mb(MpegEncContext * s,
1519 DCTELEM block[6][64],
1520 int motion_x, int motion_y)
1522 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1524 int16_t rec_intradc[6];
1526 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1530 cbp= get_p_cbp(s, block, motion_x, motion_y);
1532 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1533 /* skip macroblock */
1534 put_bits(&s->pb, 1, 1);
1535 if(interleaved_stats){
1543 put_bits(&s->pb, 1, 0); /* mb coded */
1547 if(s->alt_inter_vlc==0 || cbpc!=3)
1549 if(s->dquant) cbpc+= 8;
1550 if(s->mv_type==MV_TYPE_16X16){
1552 inter_MCBPC_bits[cbpc],
1553 inter_MCBPC_code[cbpc]);
1555 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1557 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1559 if(interleaved_stats){
1560 s->misc_bits+= get_bits_diff(s);
1563 /* motion vectors: 16x16 mode */
1564 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1567 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1568 motion_y - pred_y, 1);
1571 h263p_encode_umotion(s, motion_x - pred_x);
1572 h263p_encode_umotion(s, motion_y - pred_y);
1573 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1574 /* To prevent Start Code emulation */
1575 put_bits(&s->pb,1,1);
1579 inter_MCBPC_bits[cbpc+16],
1580 inter_MCBPC_code[cbpc+16]);
1581 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1583 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1585 if(interleaved_stats){
1586 s->misc_bits+= get_bits_diff(s);
1590 /* motion vectors: 8x8 mode*/
1591 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1593 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1594 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1596 ff_h263_encode_motion_vector(s, motion_x - pred_x,
1597 motion_y - pred_y, 1);
1600 h263p_encode_umotion(s, motion_x - pred_x);
1601 h263p_encode_umotion(s, motion_y - pred_y);
1602 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1603 /* To prevent Start Code emulation */
1604 put_bits(&s->pb,1,1);
1609 if(interleaved_stats){
1610 s->mv_bits+= get_bits_diff(s);
1613 assert(s->mb_intra);
1618 for(i=0; i<6; i++) {
1619 int16_t level = block[i][0];
1622 if(i<4) scale= s->y_dc_scale;
1623 else scale= s->c_dc_scale;
1625 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1629 level = (level + (scale>>1))/scale;
1631 level = (level - (scale>>1))/scale;
1633 /* AIC can change CBP */
1634 if (level == 0 && s->block_last_index[i] == 0)
1635 s->block_last_index[i] = -1;
1637 if(!s->modified_quant){
1640 else if (level > 127)
1644 block[i][0] = level;
1645 /* Reconstruction */
1646 rec_intradc[i] = scale*level + pred_dc;
1648 rec_intradc[i] |= 1;
1649 //if ((rec_intradc[i] % 2) == 0)
1650 // rec_intradc[i]++;
1652 if (rec_intradc[i] < 0)
1654 else if (rec_intradc[i] > 2047)
1655 rec_intradc[i] = 2047;
1657 /* Update AC/DC tables */
1658 *dc_ptr[i] = rec_intradc[i];
1659 if (s->block_last_index[i] >= 0)
1660 cbp |= 1 << (5 - i);
1663 for(i=0; i<6; i++) {
1665 if (s->block_last_index[i] >= 1)
1666 cbp |= 1 << (5 - i);
1671 if (s->pict_type == FF_I_TYPE) {
1672 if(s->dquant) cbpc+=4;
1674 intra_MCBPC_bits[cbpc],
1675 intra_MCBPC_code[cbpc]);
1677 if(s->dquant) cbpc+=8;
1678 put_bits(&s->pb, 1, 0); /* mb coded */
1680 inter_MCBPC_bits[cbpc + 4],
1681 inter_MCBPC_code[cbpc + 4]);
1684 /* XXX: currently, we do not try to use ac prediction */
1685 put_bits(&s->pb, 1, 0); /* no AC prediction */
1688 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1690 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1692 if(interleaved_stats){
1693 s->misc_bits+= get_bits_diff(s);
1697 for(i=0; i<6; i++) {
1698 /* encode each block */
1699 h263_encode_block(s, block[i], i);
1701 /* Update INTRADC for decoding */
1702 if (s->h263_aic && s->mb_intra) {
1703 block[i][0] = rec_intradc[i];
1708 if(interleaved_stats){
1710 s->p_tex_bits+= get_bits_diff(s);
1713 s->i_tex_bits+= get_bits_diff(s);
1720 void ff_h263_loop_filter(MpegEncContext * s){
1722 const int linesize = s->linesize;
1723 const int uvlinesize= s->uvlinesize;
1724 const int xy = s->mb_y * s->mb_stride + s->mb_x;
1725 uint8_t *dest_y = s->dest[0];
1726 uint8_t *dest_cb= s->dest[1];
1727 uint8_t *dest_cr= s->dest[2];
1729 // if(s->pict_type==FF_B_TYPE && !s->readable) return;
1735 if(!IS_SKIP(s->current_picture.mb_type[xy])){
1737 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1738 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1743 int qp_dt, qp_tt, qp_tc;
1745 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1748 qp_tt= s->current_picture.qscale_table[xy-s->mb_stride];
1756 const int chroma_qp= s->chroma_qscale_table[qp_tc];
1757 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1758 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1760 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1761 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1765 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_tt);
1768 if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1771 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1774 const int chroma_qp= s->chroma_qscale_table[qp_dt];
1775 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1776 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1777 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1783 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1784 if(s->mb_y + 1 == s->mb_height)
1785 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1790 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1793 qp_lc= s->current_picture.qscale_table[xy-1];
1796 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1797 if(s->mb_y + 1 == s->mb_height){
1798 const int chroma_qp= s->chroma_qscale_table[qp_lc];
1799 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1800 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1801 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1807 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1809 int x, y, wrap, a, c, pred_dc, scale, i;
1810 int16_t *dc_val, *ac_val, *ac_val1;
1812 /* find prediction */
1814 x = 2 * s->mb_x + (n & 1);
1815 y = 2 * s->mb_y + (n>> 1);
1816 wrap = s->b8_stride;
1817 dc_val = s->dc_val[0];
1818 ac_val = s->ac_val[0][0];
1819 scale = s->y_dc_scale;
1823 wrap = s->mb_stride;
1824 dc_val = s->dc_val[n - 4 + 1];
1825 ac_val = s->ac_val[n - 4 + 1][0];
1826 scale = s->c_dc_scale;
1829 ac_val += ((y) * wrap + (x)) * 16;
1835 a = dc_val[(x - 1) + (y) * wrap];
1836 c = dc_val[(x) + (y - 1) * wrap];
1838 /* No prediction outside GOB boundary */
1839 if(s->first_slice_line && n!=3){
1841 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1846 if (s->h263_aic_dir) {
1847 /* left prediction */
1851 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1856 /* top prediction */
1858 ac_val -= 16 * wrap;
1860 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1866 /* just DC prediction */
1867 if (a != 1024 && c != 1024)
1868 pred_dc = (a + c) >> 1;
1875 /* we assume pred is positive */
1876 block[0]=block[0]*scale + pred_dc;
1883 /* Update AC/DC tables */
1884 dc_val[(x) + (y) * wrap] = block[0];
1888 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1891 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1894 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1898 int16_t *A, *B, *C, (*mot_val)[2];
1899 static const int off[4]= {2, 1, 1, -1};
1901 wrap = s->b8_stride;
1902 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1905 /* special case for first (slice) line */
1906 if (s->first_slice_line && block<3) {
1907 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1908 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1909 if(block==0){ //most common case
1910 if(s->mb_x == s->resync_mb_x){ //rare
1912 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1913 C = mot_val[off[block] - wrap];
1918 *px = mid_pred(A[0], 0, C[0]);
1919 *py = mid_pred(A[1], 0, C[1]);
1926 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1927 C = mot_val[off[block] - wrap];
1928 *px = mid_pred(A[0], 0, C[0]);
1929 *py = mid_pred(A[1], 0, C[1]);
1934 }else{ /* block==2*/
1935 B = mot_val[ - wrap];
1936 C = mot_val[off[block] - wrap];
1937 if(s->mb_x == s->resync_mb_x) //rare
1940 *px = mid_pred(A[0], B[0], C[0]);
1941 *py = mid_pred(A[1], B[1], C[1]);
1944 B = mot_val[ - wrap];
1945 C = mot_val[off[block] - wrap];
1946 *px = mid_pred(A[0], B[0], C[0]);
1947 *py = mid_pred(A[1], B[1], C[1]);
1953 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1955 int range, l, bit_size, sign, code, bits;
1960 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1962 bit_size = f_code - 1;
1963 range = 1 << bit_size;
1964 /* modulo encoding */
1965 l= INT_BIT - 6 - bit_size;
1968 val= (val^sign)-sign;
1972 code = (val >> bit_size) + 1;
1973 bits = val & (range - 1);
1975 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1977 put_bits(&s->pb, bit_size, bits);
1982 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1987 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1988 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1991 if(mv==0) len= mvtab[0][1];
1993 int val, bit_size, code;
1995 bit_size = f_code - 1;
2001 code = (val >> bit_size) + 1;
2003 len= mvtab[code][1] + 1 + bit_size;
2005 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
2009 mv_penalty[f_code][mv+MAX_MV]= len;
2013 for(f_code=MAX_FCODE; f_code>0; f_code--){
2014 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
2015 fcode_tab[mv+MAX_MV]= f_code;
2019 for(mv=0; mv<MAX_MV*2+1; mv++){
2020 umv_fcode_tab[mv]= 1;
2024 static void init_uni_dc_tab(void)
2026 int level, uni_code, uni_len;
2028 for(level=-256; level<256; level++){
2030 /* find number of bits */
2039 l= (-level) ^ ((1 << size) - 1);
2044 uni_code= DCtab_lum[size][0];
2045 uni_len = DCtab_lum[size][1];
2048 uni_code<<=size; uni_code|=l;
2051 uni_code<<=1; uni_code|=1;
2055 uni_DCtab_lum_bits[level+256]= uni_code;
2056 uni_DCtab_lum_len [level+256]= uni_len;
2059 uni_code= DCtab_chrom[size][0];
2060 uni_len = DCtab_chrom[size][1];
2063 uni_code<<=size; uni_code|=l;
2066 uni_code<<=1; uni_code|=1;
2070 uni_DCtab_chrom_bits[level+256]= uni_code;
2071 uni_DCtab_chrom_len [level+256]= uni_len;
2076 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
2077 int slevel, run, last;
2079 assert(MAX_LEVEL >= 64);
2080 assert(MAX_RUN >= 63);
2082 for(slevel=-64; slevel<64; slevel++){
2083 if(slevel==0) continue;
2084 for(run=0; run<64; run++){
2085 for(last=0; last<=1; last++){
2086 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2087 int level= slevel < 0 ? -slevel : slevel;
2088 int sign= slevel < 0 ? 1 : 0;
2089 int bits, len, code;
2092 len_tab[index]= 100;
2095 code= get_rl_index(rl, last, run, level);
2096 bits= rl->table_vlc[code][0];
2097 len= rl->table_vlc[code][1];
2098 bits=bits*2+sign; len++;
2100 if(code!=rl->n && len < len_tab[index]){
2101 bits_tab[index]= bits;
2102 len_tab [index]= len;
2105 bits= rl->table_vlc[rl->n][0];
2106 len= rl->table_vlc[rl->n][1];
2107 bits=bits*2; len++; //esc1
2108 level1= level - rl->max_level[last][run];
2110 code= get_rl_index(rl, last, run, level1);
2111 bits<<= rl->table_vlc[code][1];
2112 len += rl->table_vlc[code][1];
2113 bits += rl->table_vlc[code][0];
2114 bits=bits*2+sign; len++;
2116 if(code!=rl->n && len < len_tab[index]){
2117 bits_tab[index]= bits;
2118 len_tab [index]= len;
2122 bits= rl->table_vlc[rl->n][0];
2123 len= rl->table_vlc[rl->n][1];
2124 bits=bits*4+2; len+=2; //esc2
2125 run1 = run - rl->max_run[last][level] - 1;
2127 code= get_rl_index(rl, last, run1, level);
2128 bits<<= rl->table_vlc[code][1];
2129 len += rl->table_vlc[code][1];
2130 bits += rl->table_vlc[code][0];
2131 bits=bits*2+sign; len++;
2133 if(code!=rl->n && len < len_tab[index]){
2134 bits_tab[index]= bits;
2135 len_tab [index]= len;
2139 bits= rl->table_vlc[rl->n][0];
2140 len = rl->table_vlc[rl->n][1];
2141 bits=bits*4+3; len+=2; //esc3
2142 bits=bits*2+last; len++;
2143 bits=bits*64+run; len+=6;
2144 bits=bits*2+1; len++; //marker
2145 bits=bits*4096+(slevel&0xfff); len+=12;
2146 bits=bits*2+1; len++; //marker
2148 if(len < len_tab[index]){
2149 bits_tab[index]= bits;
2150 len_tab [index]= len;
2157 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
2158 int slevel, run, last;
2160 assert(MAX_LEVEL >= 64);
2161 assert(MAX_RUN >= 63);
2163 for(slevel=-64; slevel<64; slevel++){
2164 if(slevel==0) continue;
2165 for(run=0; run<64; run++){
2166 for(last=0; last<=1; last++){
2167 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
2168 int level= slevel < 0 ? -slevel : slevel;
2169 int sign= slevel < 0 ? 1 : 0;
2170 int bits, len, code;
2172 len_tab[index]= 100;
2175 code= get_rl_index(rl, last, run, level);
2176 bits= rl->table_vlc[code][0];
2177 len= rl->table_vlc[code][1];
2178 bits=bits*2+sign; len++;
2180 if(code!=rl->n && len < len_tab[index]){
2181 if(bits_tab) bits_tab[index]= bits;
2182 len_tab [index]= len;
2185 bits= rl->table_vlc[rl->n][0];
2186 len = rl->table_vlc[rl->n][1];
2187 bits=bits*2+last; len++;
2188 bits=bits*64+run; len+=6;
2189 bits=bits*256+(level&0xff); len+=8;
2191 if(len < len_tab[index]){
2192 if(bits_tab) bits_tab[index]= bits;
2193 len_tab [index]= len;
2200 void h263_encode_init(MpegEncContext *s)
2202 static int done = 0;
2209 init_rl(&rl_inter, static_rl_table_store[0]);
2210 init_rl(&rl_intra, static_rl_table_store[1]);
2211 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2213 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
2214 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
2216 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2217 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2219 init_mv_penalty_and_fcode(s);
2221 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
2223 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2224 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2226 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2227 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2229 s->ac_esc_length= 7+1+6+8;
2231 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2232 switch(s->codec_id){
2233 case CODEC_ID_MPEG4:
2234 s->fcode_tab= fcode_tab;
2235 s->min_qcoeff= -2048;
2236 s->max_qcoeff= 2047;
2237 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2238 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2239 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2240 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2241 s->luma_dc_vlc_length= uni_DCtab_lum_len;
2242 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2243 s->ac_esc_length= 7+2+1+6+1+12+1;
2244 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2245 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2247 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2249 s->avctx->extradata= av_malloc(1024);
2250 init_put_bits(&s->pb, s->avctx->extradata, 1024);
2252 if(!(s->workaround_bugs & FF_BUG_MS))
2253 mpeg4_encode_visual_object_header(s);
2254 mpeg4_encode_vol_header(s, 0, 0);
2256 // ff_mpeg4_stuffing(&s->pb); ?
2257 flush_put_bits(&s->pb);
2258 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2262 case CODEC_ID_H263P:
2264 s->fcode_tab= umv_fcode_tab;
2265 if(s->modified_quant){
2266 s->min_qcoeff= -2047;
2267 s->max_qcoeff= 2047;
2269 s->min_qcoeff= -127;
2273 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2275 if (s->h263_flv > 1) {
2276 s->min_qcoeff= -1023;
2277 s->max_qcoeff= 1023;
2279 s->min_qcoeff= -127;
2282 s->y_dc_scale_table=
2283 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2285 default: //nothing needed - default table already set in mpegvideo.c
2286 s->min_qcoeff= -127;
2288 s->y_dc_scale_table=
2289 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2293 /***************************************************/
2295 * add mpeg4 stuffing bits (01...1)
2297 void ff_mpeg4_stuffing(PutBitContext * pbc)
2300 put_bits(pbc, 1, 0);
2301 length= (-put_bits_count(pbc))&7;
2302 if(length) put_bits(pbc, length, (1<<length)-1);
2305 /* must be called before writing the header */
2306 void ff_set_mpeg4_time(MpegEncContext * s){
2307 if(s->pict_type==FF_B_TYPE){
2308 ff_mpeg4_init_direct_mv(s);
2310 s->last_time_base= s->time_base;
2311 s->time_base= s->time/s->avctx->time_base.den;
2315 static void mpeg4_encode_gop_header(MpegEncContext * s){
2316 int hours, minutes, seconds;
2319 put_bits(&s->pb, 16, 0);
2320 put_bits(&s->pb, 16, GOP_STARTCODE);
2322 time= s->current_picture_ptr->pts;
2323 if(s->reordered_input_picture[1])
2324 time= FFMIN(time, s->reordered_input_picture[1]->pts);
2325 time= time*s->avctx->time_base.num;
2327 seconds= time/s->avctx->time_base.den;
2328 minutes= seconds/60; seconds %= 60;
2329 hours= minutes/60; minutes %= 60;
2332 put_bits(&s->pb, 5, hours);
2333 put_bits(&s->pb, 6, minutes);
2334 put_bits(&s->pb, 1, 1);
2335 put_bits(&s->pb, 6, seconds);
2337 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2338 put_bits(&s->pb, 1, 0); //broken link == NO
2340 s->last_time_base= time / s->avctx->time_base.den;
2342 ff_mpeg4_stuffing(&s->pb);
2345 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2346 int profile_and_level_indication;
2349 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2350 profile_and_level_indication = s->avctx->profile << 4;
2351 }else if(s->max_b_frames || s->quarter_sample){
2352 profile_and_level_indication= 0xF0; // adv simple
2354 profile_and_level_indication= 0x00; // simple
2357 if(s->avctx->level != FF_LEVEL_UNKNOWN){
2358 profile_and_level_indication |= s->avctx->level;
2360 profile_and_level_indication |= 1; //level 1
2363 if(profile_and_level_indication>>4 == 0xF){
2371 put_bits(&s->pb, 16, 0);
2372 put_bits(&s->pb, 16, VOS_STARTCODE);
2374 put_bits(&s->pb, 8, profile_and_level_indication);
2376 put_bits(&s->pb, 16, 0);
2377 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2379 put_bits(&s->pb, 1, 1);
2380 put_bits(&s->pb, 4, vo_ver_id);
2381 put_bits(&s->pb, 3, 1); //priority
2383 put_bits(&s->pb, 4, 1); //visual obj type== video obj
2385 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2387 ff_mpeg4_stuffing(&s->pb);
2390 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2394 if (!CONFIG_MPEG4_ENCODER) return;
2396 if(s->max_b_frames || s->quarter_sample){
2398 s->vo_type= ADV_SIMPLE_VO_TYPE;
2401 s->vo_type= SIMPLE_VO_TYPE;
2404 put_bits(&s->pb, 16, 0);
2405 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2406 put_bits(&s->pb, 16, 0);
2407 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2409 put_bits(&s->pb, 1, 0); /* random access vol */
2410 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2411 if(s->workaround_bugs & FF_BUG_MS) {
2412 put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2414 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2415 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2416 put_bits(&s->pb, 3, 1); /* is obj layer priority */
2419 aspect_to_info(s, s->avctx->sample_aspect_ratio);
2421 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2422 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2423 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2424 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2427 if(s->workaround_bugs & FF_BUG_MS) { //
2428 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2430 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2431 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2432 put_bits(&s->pb, 1, s->low_delay);
2433 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2436 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2437 put_bits(&s->pb, 1, 1); /* marker bit */
2439 put_bits(&s->pb, 16, s->avctx->time_base.den);
2440 if (s->time_increment_bits < 1)
2441 s->time_increment_bits = 1;
2442 put_bits(&s->pb, 1, 1); /* marker bit */
2443 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2444 put_bits(&s->pb, 1, 1); /* marker bit */
2445 put_bits(&s->pb, 13, s->width); /* vol width */
2446 put_bits(&s->pb, 1, 1); /* marker bit */
2447 put_bits(&s->pb, 13, s->height); /* vol height */
2448 put_bits(&s->pb, 1, 1); /* marker bit */
2449 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2450 put_bits(&s->pb, 1, 1); /* obmc disable */
2451 if (vo_ver_id == 1) {
2452 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2454 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2457 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2458 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2461 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2462 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2466 put_bits(&s->pb, 1, s->quarter_sample);
2467 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2468 s->resync_marker= s->rtp_mode;
2469 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2470 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2471 if(s->data_partitioning){
2472 put_bits(&s->pb, 1, 0); /* no rvlc */
2475 if (vo_ver_id != 1){
2476 put_bits(&s->pb, 1, 0); /* newpred */
2477 put_bits(&s->pb, 1, 0); /* reduced res vop */
2479 put_bits(&s->pb, 1, 0); /* scalability */
2481 ff_mpeg4_stuffing(&s->pb);
2484 if(!(s->flags & CODEC_FLAG_BITEXACT)){
2485 put_bits(&s->pb, 16, 0);
2486 put_bits(&s->pb, 16, 0x1B2); /* user_data */
2487 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2491 /* write mpeg4 VOP header */
2492 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2495 int time_div, time_mod;
2497 if(s->pict_type==FF_I_TYPE){
2498 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2499 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2500 mpeg4_encode_visual_object_header(s);
2501 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2502 mpeg4_encode_vol_header(s, 0, 0);
2504 if(!(s->workaround_bugs & FF_BUG_MS))
2505 mpeg4_encode_gop_header(s);
2508 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE;
2510 put_bits(&s->pb, 16, 0); /* vop header */
2511 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2512 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2515 time_div= s->time/s->avctx->time_base.den;
2516 time_mod= s->time%s->avctx->time_base.den;
2517 time_incr= time_div - s->last_time_base;
2518 assert(time_incr >= 0);
2520 put_bits(&s->pb, 1, 1);
2522 put_bits(&s->pb, 1, 0);
2524 put_bits(&s->pb, 1, 1); /* marker */
2525 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2526 put_bits(&s->pb, 1, 1); /* marker */
2527 put_bits(&s->pb, 1, 1); /* vop coded */
2528 if ( s->pict_type == FF_P_TYPE
2529 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2530 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2532 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2533 if(!s->progressive_sequence){
2534 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2535 put_bits(&s->pb, 1, s->alternate_scan);
2537 //FIXME sprite stuff
2539 put_bits(&s->pb, 5, s->qscale);
2541 if (s->pict_type != FF_I_TYPE)
2542 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2543 if (s->pict_type == FF_B_TYPE)
2544 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2547 #endif //CONFIG_ENCODERS
2551 * @param n block index (0-3 are luma, 4-5 are chroma)
2552 * @param dir the ac prediction direction
2554 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2558 int16_t *ac_val, *ac_val1;
2559 int8_t * const qscale_table= s->current_picture.qscale_table;
2561 /* find prediction */
2562 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2566 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2567 /* left prediction */
2570 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2573 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2576 /* different qscale, we must rescale */
2578 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2582 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2583 /* top prediction */
2584 ac_val -= 16 * s->block_wrap[n];
2586 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2589 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2592 /* different qscale, we must rescale */
2594 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2601 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2605 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2612 * encodes the dc value.
2613 * @param n block index (0-3 are luma, 4-5 are chroma)
2615 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2621 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2624 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2628 /* find number of bits */
2638 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2641 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2644 /* encode remaining bits */
2647 level = (-level) ^ ((1 << size) - 1);
2648 put_bits(&s->pb, size, level);
2650 put_bits(&s->pb, 1, 1);
2655 static inline int mpeg4_get_dc_length(int level, int n){
2657 return uni_DCtab_lum_len[level + 256];
2659 return uni_DCtab_chrom_len[level + 256];
2664 * encodes a 8x8 block
2665 * @param n block index (0-3 are luma, 4-5 are chroma)
2667 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2668 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2670 int i, last_non_zero;
2671 #if 0 //variables for the outcommented version
2672 int code, sign, last;
2677 const int last_index = s->block_last_index[n];
2679 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2680 /* mpeg4 based DC predictor */
2681 mpeg4_encode_dc(dc_pb, intra_dc, n);
2682 if(last_index<1) return;
2685 bits_tab= uni_mpeg4_intra_rl_bits;
2686 len_tab = uni_mpeg4_intra_rl_len;
2688 if(last_index<0) return;
2691 bits_tab= uni_mpeg4_inter_rl_bits;
2692 len_tab = uni_mpeg4_inter_rl_len;
2696 last_non_zero = i - 1;
2698 for (; i < last_index; i++) {
2699 int level = block[ scan_table[i] ];
2701 int run = i - last_non_zero - 1;
2703 if((level&(~127)) == 0){
2704 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2705 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2707 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);
2712 /*if(i<=last_index)*/{
2713 int level = block[ scan_table[i] ];
2714 int run = i - last_non_zero - 1;
2716 if((level&(~127)) == 0){
2717 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2718 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2720 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);
2724 for (; i <= last_index; i++) {
2725 const int slevel = block[ scan_table[i] ];
2728 int run = i - last_non_zero - 1;
2729 last = (i == last_index);
2736 code = get_rl_index(rl, last, run, level);
2737 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2738 if (code == rl->n) {
2740 level1 = level - rl->max_level[last][run];
2743 code = get_rl_index(rl, last, run, level1);
2744 if (code == rl->n) {
2746 put_bits(ac_pb, 1, 1);
2747 if (level > MAX_LEVEL)
2749 run1 = run - rl->max_run[last][level] - 1;
2752 code = get_rl_index(rl, last, run1, level);
2753 if (code == rl->n) {
2756 put_bits(ac_pb, 1, 1);
2757 put_bits(ac_pb, 1, last);
2758 put_bits(ac_pb, 6, run);
2759 put_bits(ac_pb, 1, 1);
2760 put_sbits(ac_pb, 12, slevel);
2761 put_bits(ac_pb, 1, 1);
2764 put_bits(ac_pb, 1, 0);
2765 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2766 put_bits(ac_pb, 1, sign);
2770 put_bits(ac_pb, 1, 0);
2771 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2772 put_bits(ac_pb, 1, sign);
2775 put_bits(ac_pb, 1, sign);
2783 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2784 uint8_t *scan_table)
2786 int i, last_non_zero;
2788 const int last_index = s->block_last_index[n];
2791 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2792 /* mpeg4 based DC predictor */
2793 len += mpeg4_get_dc_length(intra_dc, n);
2794 if(last_index<1) return len;
2796 len_tab = uni_mpeg4_intra_rl_len;
2798 if(last_index<0) return 0;
2800 len_tab = uni_mpeg4_inter_rl_len;
2804 last_non_zero = i - 1;
2805 for (; i < last_index; i++) {
2806 int level = block[ scan_table[i] ];
2808 int run = i - last_non_zero - 1;
2810 if((level&(~127)) == 0){
2811 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2812 len += len_tab[index];
2814 len += 7+2+1+6+1+12+1;
2819 /*if(i<=last_index)*/{
2820 int level = block[ scan_table[i] ];
2821 int run = i - last_non_zero - 1;
2823 if((level&(~127)) == 0){
2824 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2825 len += len_tab[index];
2827 len += 7+2+1+6+1+12+1;
2837 /***********************************************/
2840 static VLC intra_MCBPC_vlc;
2841 static VLC inter_MCBPC_vlc;
2842 static VLC cbpy_vlc;
2844 static VLC dc_lum, dc_chrom;
2845 static VLC sprite_trajectory;
2846 static VLC mb_type_b_vlc;
2847 static VLC h263_mbtype_b_vlc;
2848 static VLC cbpc_b_vlc;
2852 /* XXX: find a better solution to handle static init */
2853 void h263_decode_init_vlc(MpegEncContext *s)
2855 static int done = 0;
2860 INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2861 intra_MCBPC_bits, 1, 1,
2862 intra_MCBPC_code, 1, 1, 72);
2863 INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2864 inter_MCBPC_bits, 1, 1,
2865 inter_MCBPC_code, 1, 1, 198);
2866 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16,
2867 &cbpy_tab[0][1], 2, 1,
2868 &cbpy_tab[0][0], 2, 1, 64);
2869 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
2871 &mvtab[0][0], 2, 1, 538);
2872 init_rl(&rl_inter, static_rl_table_store[0]);
2873 init_rl(&rl_intra, static_rl_table_store[1]);
2874 init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
2875 init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
2876 init_rl(&rl_intra_aic, static_rl_table_store[2]);
2877 INIT_VLC_RL(rl_inter, 554);
2878 INIT_VLC_RL(rl_intra, 554);
2879 INIT_VLC_RL(rvlc_rl_inter, 1072);
2880 INIT_VLC_RL(rvlc_rl_intra, 1072);
2881 INIT_VLC_RL(rl_intra_aic, 554);
2882 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2883 &DCtab_lum[0][1], 2, 1,
2884 &DCtab_lum[0][0], 2, 1, 512);
2885 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2886 &DCtab_chrom[0][1], 2, 1,
2887 &DCtab_chrom[0][0], 2, 1, 512);
2888 INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2889 &sprite_trajectory_tab[0][1], 4, 2,
2890 &sprite_trajectory_tab[0][0], 4, 2, 128);
2891 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2892 &mb_type_b_tab[0][1], 2, 1,
2893 &mb_type_b_tab[0][0], 2, 1, 16);
2894 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2895 &h263_mbtype_b_tab[0][1], 2, 1,
2896 &h263_mbtype_b_tab[0][0], 2, 1, 80);
2897 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2898 &cbpc_b_tab[0][1], 2, 1,
2899 &cbpc_b_tab[0][0], 2, 1, 8);
2904 * Get the GOB height based on picture height.
2906 int ff_h263_get_gob_height(MpegEncContext *s){
2907 if (s->height <= 400)
2909 else if (s->height <= 800)
2915 int ff_h263_decode_mba(MpegEncContext *s)
2920 if(s->mb_num-1 <= ff_mba_max[i]) break;
2922 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2923 s->mb_x= mb_pos % s->mb_width;
2924 s->mb_y= mb_pos / s->mb_width;
2929 void ff_h263_encode_mba(MpegEncContext *s)
2934 if(s->mb_num-1 <= ff_mba_max[i]) break;
2936 mb_pos= s->mb_x + s->mb_width*s->mb_y;
2937 put_bits(&s->pb, ff_mba_length[i], mb_pos);
2941 * decodes the group of blocks header or slice header.
2942 * @return <0 if an error occurred
2944 static int h263_decode_gob_header(MpegEncContext *s)
2946 unsigned int val, gfid, gob_number;
2949 /* Check for GOB Start Code */
2950 val = show_bits(&s->gb, 16);
2954 /* We have a GBSC probably with GSTUFF */
2955 skip_bits(&s->gb, 16); /* Drop the zeros */
2956 left= get_bits_left(&s->gb);
2957 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2958 for(;left>13; left--){
2959 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2964 if(s->h263_slice_structured){
2965 if(get_bits1(&s->gb)==0)
2968 ff_h263_decode_mba(s);
2970 if(s->mb_num > 1583)
2971 if(get_bits1(&s->gb)==0)
2974 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
2975 if(get_bits1(&s->gb)==0)
2977 gfid = get_bits(&s->gb, 2); /* GFID */
2979 gob_number = get_bits(&s->gb, 5); /* GN */
2981 s->mb_y= s->gob_index* gob_number;
2982 gfid = get_bits(&s->gb, 2); /* GFID */
2983 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2986 if(s->mb_y >= s->mb_height)
2995 static inline void memsetw(short *tab, int val, int n)
3004 void ff_mpeg4_init_partitions(MpegEncContext *s)
3006 uint8_t *start= put_bits_ptr(&s->pb);
3007 uint8_t *end= s->pb.buf_end;
3008 int size= end - start;
3009 int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start;
3010 int tex_size= (size - 2*pb_size)&(~3);
3012 set_put_bits_buffer_size(&s->pb, pb_size);
3013 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3014 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3017 void ff_mpeg4_merge_partitions(MpegEncContext *s)
3019 const int pb2_len = put_bits_count(&s->pb2 );
3020 const int tex_pb_len= put_bits_count(&s->tex_pb);
3021 const int bits= put_bits_count(&s->pb);
3023 if(s->pict_type==FF_I_TYPE){
3024 put_bits(&s->pb, 19, DC_MARKER);
3025 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3026 s->i_tex_bits+= tex_pb_len;
3028 put_bits(&s->pb, 17, MOTION_MARKER);
3029 s->misc_bits+=17 + pb2_len;
3030 s->mv_bits+= bits - s->last_bits;
3031 s->p_tex_bits+= tex_pb_len;
3034 flush_put_bits(&s->pb2);
3035 flush_put_bits(&s->tex_pb);
3037 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3038 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3039 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3040 s->last_bits= put_bits_count(&s->pb);
3043 #endif //CONFIG_ENCODERS
3045 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3046 switch(s->pict_type){
3051 return s->f_code+15;
3053 return FFMAX3(s->f_code, s->b_code, 2) + 15;
3061 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3063 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3065 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3066 put_bits(&s->pb, 1, 1);
3068 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3069 put_bits(&s->pb, s->quant_precision, s->qscale);
3070 put_bits(&s->pb, 1, 0); /* no HEC */
3073 #endif //CONFIG_ENCODERS
3076 * check if the next stuff is a resync marker or the end.
3079 static inline int mpeg4_is_resync(MpegEncContext *s){
3080 int bits_count= get_bits_count(&s->gb);
3081 int v= show_bits(&s->gb, 16);
3083 if(s->workaround_bugs&FF_BUG_NO_PADDING){
3088 if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3090 skip_bits(&s->gb, 8+s->pict_type);
3091 bits_count+= 8+s->pict_type;
3092 v= show_bits(&s->gb, 16);
3095 if(bits_count + 8 >= s->gb.size_in_bits){
3097 v|= 0x7F >> (7-(bits_count&7));
3102 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
3104 GetBitContext gb= s->gb;
3106 skip_bits(&s->gb, 1);
3107 align_get_bits(&s->gb);
3109 for(len=0; len<32; len++){
3110 if(get_bits1(&s->gb)) break;
3115 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3122 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
3125 int a= 2<<s->sprite_warping_accuracy;
3126 int rho= 3-s->sprite_warping_accuracy;
3128 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3129 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3130 int sprite_ref[4][2];
3131 int virtual_ref[2][2];
3133 int alpha=0, beta=0;
3138 for(i=0; i<s->num_sprite_warping_points; i++){
3142 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
3144 x= get_xbits(gb, length);
3146 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
3148 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
3150 y=get_xbits(gb, length);
3152 skip_bits1(gb); /* marker bit */
3153 s->sprite_traj[i][0]= d[i][0]= x;
3154 s->sprite_traj[i][1]= d[i][1]= y;
3157 s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0;
3159 while((1<<alpha)<w) alpha++;
3160 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3164 // Note, the 4th point isn't used for GMC
3165 if(s->divx_version==500 && s->divx_build==413){
3166 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3167 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3168 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3169 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3170 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3171 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3173 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3174 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3175 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3176 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3177 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3178 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3180 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3181 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3183 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3184 // perhaps it should be reordered to be more readable ...
3185 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3186 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3187 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
3188 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
3189 virtual_ref[0][1]= 16*vop_ref[0][1]
3190 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
3191 virtual_ref[1][0]= 16*vop_ref[0][0]
3192 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
3193 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
3194 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
3196 switch(s->num_sprite_warping_points)
3199 s->sprite_offset[0][0]= 0;
3200 s->sprite_offset[0][1]= 0;
3201 s->sprite_offset[1][0]= 0;
3202 s->sprite_offset[1][1]= 0;
3203 s->sprite_delta[0][0]= a;
3204 s->sprite_delta[0][1]= 0;
3205 s->sprite_delta[1][0]= 0;
3206 s->sprite_delta[1][1]= a;
3207 s->sprite_shift[0]= 0;
3208 s->sprite_shift[1]= 0;
3211 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3212 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3213 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3214 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3215 s->sprite_delta[0][0]= a;
3216 s->sprite_delta[0][1]= 0;
3217 s->sprite_delta[1][0]= 0;
3218 s->sprite_delta[1][1]= a;
3219 s->sprite_shift[0]= 0;
3220 s->sprite_shift[1]= 0;
3223 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3224 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3225 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
3226 + (1<<(alpha+rho-1));
3227 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3228 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
3229 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
3230 + (1<<(alpha+rho-1));
3231 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
3232 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
3233 +2*w2*r*sprite_ref[0][0]
3235 + (1<<(alpha+rho+1)));
3236 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
3237 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
3238 +2*w2*r*sprite_ref[0][1]
3240 + (1<<(alpha+rho+1)));
3241 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3242 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
3243 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
3244 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3246 s->sprite_shift[0]= alpha+rho;
3247 s->sprite_shift[1]= alpha+rho+2;
3250 min_ab= FFMIN(alpha, beta);
3253 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
3254 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
3255 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
3256 + (1<<(alpha+beta+rho-min_ab-1));
3257 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
3258 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
3259 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
3260 + (1<<(alpha+beta+rho-min_ab-1));
3261 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
3262 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
3263 + 2*w2*h3*r*sprite_ref[0][0]
3265 + (1<<(alpha+beta+rho-min_ab+1));
3266 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
3267 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
3268 + 2*w2*h3*r*sprite_ref[0][1]
3270 + (1<<(alpha+beta+rho-min_ab+1));
3271 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
3272 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
3273 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
3274 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
3276 s->sprite_shift[0]= alpha + beta + rho - min_ab;
3277 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
3280 /* try to simplify the situation */
3281 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
3282 && s->sprite_delta[0][1] == 0
3283 && s->sprite_delta[1][0] == 0
3284 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
3286 s->sprite_offset[0][0]>>=s->sprite_shift[0];
3287 s->sprite_offset[0][1]>>=s->sprite_shift[0];
3288 s->sprite_offset[1][0]>>=s->sprite_shift[1];
3289 s->sprite_offset[1][1]>>=s->sprite_shift[1];
3290 s->sprite_delta[0][0]= a;
3291 s->sprite_delta[0][1]= 0;
3292 s->sprite_delta[1][0]= 0;
3293 s->sprite_delta[1][1]= a;
3294 s->sprite_shift[0]= 0;
3295 s->sprite_shift[1]= 0;
3296 s->real_sprite_warping_points=1;
3299 int shift_y= 16 - s->sprite_shift[0];
3300 int shift_c= 16 - s->sprite_shift[1];
3302 s->sprite_offset[0][i]<<= shift_y;
3303 s->sprite_offset[1][i]<<= shift_c;
3304 s->sprite_delta[0][i]<<= shift_y;
3305 s->sprite_delta[1][i]<<= shift_y;
3306 s->sprite_shift[i]= 16;
3308 s->real_sprite_warping_points= s->num_sprite_warping_points;
3313 * decodes the next video packet.
3314 * @return <0 if something went wrong
3316 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3318 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3319 int header_extension=0, mb_num, len;
3321 /* is there enough space left for a video packet + header */
3322 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3324 for(len=0; len<32; len++){
3325 if(get_bits1(&s->gb)) break;
3328 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3329 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3333 if(s->shape != RECT_SHAPE){
3334 header_extension= get_bits1(&s->gb);
3335 //FIXME more stuff here
3338 mb_num= get_bits(&s->gb, mb_num_bits);
3339 if(mb_num>=s->mb_num){
3340 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3343 if(s->pict_type == FF_B_TYPE){
3344 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3345 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
3348 s->mb_x= mb_num % s->mb_width;
3349 s->mb_y= mb_num / s->mb_width;
3351 if(s->shape != BIN_ONLY_SHAPE){
3352 int qscale= get_bits(&s->gb, s->quant_precision);
3354 s->chroma_qscale=s->qscale= qscale;
3357 if(s->shape == RECT_SHAPE){
3358 header_extension= get_bits1(&s->gb);
3360 if(header_extension){
3364 while (get_bits1(&s->gb) != 0)
3367 check_marker(&s->gb, "before time_increment in video packed header");
3368 time_increment= get_bits(&s->gb, s->time_increment_bits);
3369 check_marker(&s->gb, "before vop_coding_type in video packed header");
3371 skip_bits(&s->gb, 2); /* vop coding type */
3372 //FIXME not rect stuff here
3374 if(s->shape != BIN_ONLY_SHAPE){
3375 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3376 //FIXME don't just ignore everything
3377 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3378 mpeg4_decode_sprite_trajectory(s, &s->gb);
3379 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3382 //FIXME reduced res stuff here
3384 if (s->pict_type != FF_I_TYPE) {
3385 int f_code = get_bits(&s->gb, 3); /* fcode_for */
3387 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3390 if (s->pict_type == FF_B_TYPE) {
3391 int b_code = get_bits(&s->gb, 3);
3393 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3398 //FIXME new-pred stuff
3403 void ff_mpeg4_clean_buffers(MpegEncContext *s)
3405 int c_wrap, c_xy, l_wrap, l_xy;
3407 l_wrap= s->b8_stride;
3408 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3409 c_wrap= s->mb_stride;
3410 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3414 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3415 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3416 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3420 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3421 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3422 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3425 // we can't clear the MVs as they might be needed by a b frame
3426 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3427 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3428 s->last_mv[0][0][0]=
3429 s->last_mv[0][0][1]=
3430 s->last_mv[1][0][0]=
3431 s->last_mv[1][0][1]= 0;
3435 * finds the next resync_marker
3436 * @param p pointer to buffer to scan
3437 * @param end pointer to the end of the buffer
3438 * @return pointer to the next resync_marker, or \p end if none was found
3440 const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end)
3448 if (!p[-1] && p[1]) return p - 1;
3449 else if(!p[ 1] && p[2]) return p;
3456 * decodes the group of blocks / video packet header.
3457 * @return bit position of the resync_marker, or <0 if none was found
3459 int ff_h263_resync(MpegEncContext *s){
3462 if(s->codec_id==CODEC_ID_MPEG4){
3464 align_get_bits(&s->gb);
3467 if(show_bits(&s->gb, 16)==0){
3468 pos= get_bits_count(&s->gb);
3469 if(s->codec_id==CODEC_ID_MPEG4)
3470 ret= mpeg4_decode_video_packet_header(s);
3472 ret= h263_decode_gob_header(s);
3476 //OK, it's not where it is supposed to be ...
3477 s->gb= s->last_resync_gb;
3478 align_get_bits(&s->gb);
3479 left= get_bits_left(&s->gb);
3481 for(;left>16+1+5+5; left-=8){
3482 if(show_bits(&s->gb, 16)==0){
3483 GetBitContext bak= s->gb;
3485 pos= get_bits_count(&s->gb);
3486 if(s->codec_id==CODEC_ID_MPEG4)
3487 ret= mpeg4_decode_video_packet_header(s);
3489 ret= h263_decode_gob_header(s);
3495 skip_bits(&s->gb, 8);
3501 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3503 int code, val, sign, shift, l;
3504 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3511 sign = get_bits1(&s->gb);
3515 val = (val - 1) << shift;
3516 val |= get_bits(&s->gb, shift);
3523 /* modulo decoding */
3524 if (!s->h263_long_vectors) {
3525 l = INT_BIT - 5 - f_code;
3528 /* horrible h263 long vector mode */
3529 if (pred < -31 && val < -63)
3531 if (pred > 32 && val > 63)
3539 * gets the average motion vector for a GMC MB.
3540 * @param n either 0 for the x component or 1 for y
3541 * @returns the average MV for a GMC MB
3543 static inline int get_amv(MpegEncContext *s, int n){
3544 int x, y, mb_v, sum, dx, dy, shift;
3545 int len = 1 << (s->f_code + 4);
3546 const int a= s->sprite_warping_accuracy;
3548 if(s->workaround_bugs & FF_BUG_AMV)
3549 len >>= s->quarter_sample;
3551 if(s->real_sprite_warping_points==1){
3552 if(s->divx_version==500 && s->divx_build==413)
3553 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3555 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3557 dx= s->sprite_delta[n][0];
3558 dy= s->sprite_delta[n][1];
3559 shift= s->sprite_shift[0];
3560 if(n) dy -= 1<<(shift + a + 1);
3561 else dx -= 1<<(shift + a + 1);
3562 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3565 for(y=0; y<16; y++){
3569 //XXX FIXME optimize
3570 for(x=0; x<16; x++){
3575 sum= RSHIFT(sum, a+8-s->quarter_sample);
3578 if (sum < -len) sum= -len;
3579 else if (sum >= len) sum= len-1;
3585 * decodes the dc value.
3586 * @param n block index (0-3 are luma, 4-5 are chroma)
3587 * @param dir_ptr the prediction direction will be stored here
3588 * @return the quantized dc
3590 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)