2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
5 * Copyright (c) 2001 Juan J. Sierralta P.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * ac prediction encoding, b-frame support, error resilience, optimizations,
22 * qpel decoding, gmc decoding, interlaced decoding,
23 * by Michael Niedermayer <michaelni@gmx.at>
35 #include "mpegvideo.h"
37 #include "mpeg4data.h"
42 #define INTRA_MCBPC_VLC_BITS 6
43 #define INTER_MCBPC_VLC_BITS 6
44 #define CBPY_VLC_BITS 6
47 #define SPRITE_TRAJ_VLC_BITS 6
48 #define MB_TYPE_B_VLC_BITS 4
49 #define TEX_VLC_BITS 9
51 #ifdef CONFIG_ENCODERS
52 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
54 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
55 static void h263p_encode_umotion(MpegEncContext * s, int val);
56 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
57 int n, int dc, uint8_t *scan_table,
58 PutBitContext *dc_pb, PutBitContext *ac_pb);
61 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
62 static int h263p_decode_umotion(MpegEncContext * s, int pred);
63 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
65 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
66 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
67 int n, int coded, int intra, int rvlc);
68 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
69 #ifdef CONFIG_ENCODERS
70 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
72 #endif //CONFIG_ENCODERS
73 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
74 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
76 extern uint32_t inverse[256];
78 #ifdef CONFIG_ENCODERS
79 static uint8_t uni_DCtab_lum_len[512];
80 static uint8_t uni_DCtab_chrom_len[512];
81 static uint16_t uni_DCtab_lum_bits[512];
82 static uint16_t uni_DCtab_chrom_bits[512];
84 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
85 static uint8_t fcode_tab[MAX_MV*2+1];
86 static uint8_t umv_fcode_tab[MAX_MV*2+1];
88 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
89 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
90 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
91 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
92 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
93 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
94 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
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 #ifdef CONFIG_ENCODERS
129 static void float_aspect_to_info(MpegEncContext * s, float aspect){
132 aspect*= s->height/(double)s->width;
133 //printf("%f\n", aspect);
135 if(aspect==0) aspect= 1.0;
137 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
139 //printf("%d %d\n", s->aspected_width, s->aspected_height);
141 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
142 s->aspect_ratio_info=i;
147 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
150 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
154 align_put_bits(&s->pb);
156 /* Update the pointer to last GOB */
157 s->ptr_lastgob = pbBufPtr(&s->pb);
160 put_bits(&s->pb, 22, 0x20); /* PSC */
161 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
162 s->avctx->frame_rate) & 0xff);
164 put_bits(&s->pb, 1, 1); /* marker */
165 put_bits(&s->pb, 1, 0); /* h263 id */
166 put_bits(&s->pb, 1, 0); /* split screen off */
167 put_bits(&s->pb, 1, 0); /* camera off */
168 put_bits(&s->pb, 1, 0); /* freeze picture release off */
170 format = h263_get_picture_format(s->width, s->height);
173 put_bits(&s->pb, 3, format);
174 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
175 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
176 of H.263v1 UMV implies to check the predicted MV after
177 calculation of the current MB to see if we're on the limits */
178 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
179 put_bits(&s->pb, 1, 0); /* SAC: off */
180 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
181 put_bits(&s->pb, 1, 0); /* not PB frame */
182 put_bits(&s->pb, 5, s->qscale);
183 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
186 /* H.263 Plus PTYPE */
187 put_bits(&s->pb, 3, 7);
188 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
190 put_bits(&s->pb,3,6); /* Custom Source Format */
192 put_bits(&s->pb, 3, format);
194 put_bits(&s->pb,1,0); /* Custom PCF: off */
195 s->umvplus = s->unrestricted_mv;
196 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
197 put_bits(&s->pb,1,0); /* SAC: off */
198 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
199 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
200 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
201 put_bits(&s->pb,1,0); /* Slice Structured: off */
202 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
203 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
204 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
205 put_bits(&s->pb,1,0); /* Modified Quantization: off */
206 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
207 put_bits(&s->pb,3,0); /* Reserved */
209 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
211 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
212 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
213 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
214 put_bits(&s->pb,2,0); /* Reserved */
215 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
217 /* This should be here if PLUSPTYPE */
218 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
221 /* Custom Picture Format (CPFMT) */
222 float_aspect_to_info(s, s->avctx->aspect_ratio);
224 put_bits(&s->pb,4,s->aspect_ratio_info);
225 put_bits(&s->pb,9,(s->width >> 2) - 1);
226 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
227 put_bits(&s->pb,9,(s->height >> 2));
228 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
230 put_bits(&s->pb, 8, s->aspected_width);
231 put_bits(&s->pb, 8, s->aspected_height);
235 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
237 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
238 put_bits(&s->pb,2,1); /* unlimited */
240 put_bits(&s->pb, 5, s->qscale);
243 put_bits(&s->pb, 1, 0); /* no PEI */
247 s->c_dc_scale_table= h263_aic_dc_scale_table;
250 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
255 * Encodes a group of blocks header.
257 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
259 align_put_bits(&s->pb);
260 flush_put_bits(&s->pb);
261 /* Call the RTP callback to send the last GOB */
262 if (s->rtp_callback) {
263 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
264 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
266 put_bits(&s->pb, 17, 1); /* GBSC */
267 s->gob_number = mb_line / s->gob_index;
268 put_bits(&s->pb, 5, s->gob_number); /* GN */
269 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
270 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
271 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
275 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
277 int score0=0, score1=0;
279 int8_t * const qscale_table= s->current_picture.qscale_table;
282 int16_t *ac_val, *ac_val1;
284 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
287 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
289 ac_val-= s->block_wrap[n]*16;
290 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
293 const int level= block[n][s->dsp.idct_permutation[i ]];
295 score1+= ABS(level - ac_val[i+8]);
296 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
300 /* different qscale, we must rescale */
302 const int level= block[n][s->dsp.idct_permutation[i ]];
304 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
305 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
310 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
311 /* left prediction */
313 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
316 const int level= block[n][s->dsp.idct_permutation[i<<3]];
318 score1+= ABS(level - ac_val[i]);
320 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
323 /* different qscale, we must rescale */
325 const int level= block[n][s->dsp.idct_permutation[i<<3]];
327 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
329 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
335 return score0 > score1 ? 1 : 0;
339 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
341 void ff_clean_h263_qscales(MpegEncContext *s){
343 int8_t * const qscale_table= s->current_picture.qscale_table;
345 for(i=1; i<s->mb_num; i++){
346 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
347 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
349 for(i=s->mb_num-2; i>=0; i--){
350 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
351 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
356 * modify mb_type & qscale so that encoding is acually possible in mpeg4
358 void ff_clean_mpeg4_qscales(MpegEncContext *s){
360 int8_t * const qscale_table= s->current_picture.qscale_table;
362 ff_clean_h263_qscales(s);
364 for(i=1; i<s->mb_num; i++){
365 int mb_xy= s->mb_index2xy[i];
367 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
368 s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
369 s->mb_type[mb_xy]|= MB_TYPE_INTER;
373 if(s->pict_type== B_TYPE){
375 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
376 for the actual adaptive quantization */
378 for(i=0; i<s->mb_num; i++){
379 int mb_xy= s->mb_index2xy[i];
380 odd += qscale_table[mb_xy]&1;
383 if(2*odd > s->mb_num) odd=1;
386 for(i=0; i<s->mb_num; i++){
387 int mb_xy= s->mb_index2xy[i];
388 if((qscale_table[mb_xy]&1) != odd)
389 qscale_table[mb_xy]++;
390 if(qscale_table[mb_xy] > 31)
391 qscale_table[mb_xy]= 31;
394 for(i=1; i<s->mb_num; i++){
395 int mb_xy= s->mb_index2xy[i];
396 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
397 s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
398 s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
404 #endif //CONFIG_ENCODERS
407 * @return the mb_type
409 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
410 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
411 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
412 int xy= s->block_index[0];
413 uint16_t time_pp= s->pp_time;
414 uint16_t time_pb= s->pb_time;
417 //FIXME avoid divides
419 if(IS_8X8(colocated_mb_type)){
420 s->mv_type = MV_TYPE_8X8;
422 xy= s->block_index[i];
423 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
424 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
425 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
426 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
427 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
428 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
430 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
431 } else if(IS_INTERLACED(colocated_mb_type)){
432 s->mv_type = MV_TYPE_FIELD;
434 if(s->top_field_first){
435 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
436 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
438 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
439 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
441 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
442 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
443 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
444 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
445 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
446 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
448 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
450 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
451 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
452 s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
453 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
454 s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
455 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
456 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
457 s->mv_type= MV_TYPE_16X16;
459 s->mv_type= MV_TYPE_8X8;
460 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
464 #ifdef CONFIG_ENCODERS
465 void mpeg4_encode_mb(MpegEncContext * s,
466 DCTELEM block[6][64],
467 int motion_x, int motion_y)
469 int cbpc, cbpy, pred_x, pred_y;
471 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
472 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
473 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
474 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
475 const int dquant_code[5]= {1,0,9,2,3};
477 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
481 for (i = 0; i < 6; i++) {
482 if (s->block_last_index[i] >= 0)
486 if(s->pict_type==B_TYPE){
487 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
488 int mb_type= mb_type_table[s->mv_dir];
494 s->last_mv[1][0][1]= 0;
497 assert(s->dquant>=-2 && s->dquant<=2);
498 assert((s->dquant&1)==0);
501 /* nothing to do if this MB was skiped in the next P Frame */
502 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
508 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
509 s->qscale -= s->dquant;
515 if ((cbp | motion_x | motion_y | mb_type) ==0) {
516 /* direct MB with MV={0,0} */
517 assert(s->dquant==0);
519 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
521 if(interleaved_stats){
529 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
530 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
531 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
532 if(cbp) put_bits(&s->pb, 6, cbp);
536 put_bits(&s->pb, 2, (s->dquant>>2)+3);
538 put_bits(&s->pb, 1, 0);
540 s->qscale -= s->dquant;
542 if(!s->progressive_sequence){
544 put_bits(&s->pb, 1, s->interlaced_dct);
545 if(mb_type) // not diect mode
546 put_bits(&s->pb, 1, 0); // no interlaced ME yet
549 if(interleaved_stats){
550 s->misc_bits+= get_bits_diff(s);
556 h263_encode_motion(s, motion_x, 1);
557 h263_encode_motion(s, motion_y, 1);
562 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
563 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
564 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
565 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
566 s->last_mv[0][0][0]= s->mv[0][0][0];
567 s->last_mv[0][0][1]= s->mv[0][0][1];
568 s->last_mv[1][0][0]= s->mv[1][0][0];
569 s->last_mv[1][0][1]= s->mv[1][0][1];
573 case 2: /* backward */
574 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
575 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
576 s->last_mv[1][0][0]= motion_x;
577 s->last_mv[1][0][1]= motion_y;
580 case 3: /* forward */
581 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
582 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
583 s->last_mv[0][0][0]= motion_x;
584 s->last_mv[0][0][1]= motion_y;
588 printf("unknown mb type\n");
592 if(interleaved_stats){
593 s->mv_bits+= get_bits_diff(s);
596 /* encode each block */
597 for (i = 0; i < 6; i++) {
598 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
601 if(interleaved_stats){
602 s->p_tex_bits+= get_bits_diff(s);
604 }else{ /* s->pict_type==B_TYPE */
605 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
606 /* check if the B frames can skip it too, as we must skip it if we skip here
607 why didnt they just compress the skip-mb bits instead of reusing them ?! */
608 if(s->max_b_frames>0){
615 if(x+16 > s->width) x= s->width-16;
616 if(y+16 > s->height) y= s->height-16;
618 offset= x + y*s->linesize;
619 p_pic= s->new_picture.data[0] + offset;
622 for(i=0; i<s->max_b_frames; i++){
625 Picture *pic= s->reordered_input_picture[i+1];
627 if(pic==NULL || pic->pict_type!=B_TYPE) break;
629 b_pic= pic->data[0] + offset + 16; //FIXME +16
630 diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
631 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
640 /* skip macroblock */
641 put_bits(&s->pb, 1, 1);
643 if(interleaved_stats){
652 put_bits(&s->pb, 1, 0); /* mb coded */
653 if(s->mv_type==MV_TYPE_16X16){
655 if(s->dquant) cbpc+= 8;
657 inter_MCBPC_bits[cbpc],
658 inter_MCBPC_code[cbpc]);
662 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
664 put_bits(pb2, 2, dquant_code[s->dquant+2]);
666 if(!s->progressive_sequence){
668 put_bits(pb2, 1, s->interlaced_dct);
669 put_bits(pb2, 1, 0); // no interlaced ME yet
672 if(interleaved_stats){
673 s->misc_bits+= get_bits_diff(s);
676 /* motion vectors: 16x16 mode */
677 h263_pred_motion(s, 0, &pred_x, &pred_y);
679 h263_encode_motion(s, motion_x - pred_x, s->f_code);
680 h263_encode_motion(s, motion_y - pred_y, s->f_code);
684 inter_MCBPC_bits[cbpc],
685 inter_MCBPC_code[cbpc]);
688 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
690 if(!s->progressive_sequence){
692 put_bits(pb2, 1, s->interlaced_dct);
695 if(interleaved_stats){
696 s->misc_bits+= get_bits_diff(s);
700 /* motion vectors: 8x8 mode*/
701 h263_pred_motion(s, i, &pred_x, &pred_y);
703 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
704 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
708 if(interleaved_stats){
709 s->mv_bits+= get_bits_diff(s);
712 /* encode each block */
713 for (i = 0; i < 6; i++) {
714 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
717 if(interleaved_stats){
718 s->p_tex_bits+= get_bits_diff(s);
724 int dc_diff[6]; //dc values with the dc prediction subtracted
725 int dir[6]; //prediction direction
726 int zigzag_last_index[6];
727 uint8_t *scan_table[6];
731 const int level= block[i][0];
734 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
736 *dc_ptr = level * s->y_dc_scale;
738 *dc_ptr = level * s->c_dc_scale;
742 s->ac_pred= decide_ac_pred(s, block, dir);
749 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
750 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
751 else st = s->intra_h_scantable.permutated; /* top */
753 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
754 if(block[i][st[last_index]]) break;
755 zigzag_last_index[i]= s->block_last_index[i];
756 s->block_last_index[i]= last_index;
761 scan_table[i]= s->intra_scantable.permutated;
766 for (i = 0; i < 6; i++) {
767 if (s->block_last_index[i] >= 1)
772 if (s->pict_type == I_TYPE) {
773 if(s->dquant) cbpc+=4;
775 intra_MCBPC_bits[cbpc],
776 intra_MCBPC_code[cbpc]);
778 if(s->dquant) cbpc+=8;
779 put_bits(&s->pb, 1, 0); /* mb coded */
781 inter_MCBPC_bits[cbpc + 4],
782 inter_MCBPC_code[cbpc + 4]);
784 put_bits(pb2, 1, s->ac_pred);
786 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
788 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
790 if(!s->progressive_sequence){
791 put_bits(dc_pb, 1, s->interlaced_dct);
794 if(interleaved_stats){
795 s->misc_bits+= get_bits_diff(s);
798 /* encode each block */
799 for (i = 0; i < 6; i++) {
800 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
803 if(interleaved_stats){
804 s->i_tex_bits+= get_bits_diff(s);
808 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
814 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
818 block[i][s->dsp.idct_permutation[j ]]= ac_val[j+8];
821 block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j ];
823 s->block_last_index[i]= zigzag_last_index[i];
829 void h263_encode_mb(MpegEncContext * s,
830 DCTELEM block[6][64],
831 int motion_x, int motion_y)
833 int cbpc, cbpy, i, cbp, pred_x, pred_y;
835 int16_t rec_intradc[6];
837 const int dquant_code[5]= {1,0,9,2,3};
839 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
843 for (i = 0; i < 6; i++) {
844 if (s->block_last_index[i] >= 0)
847 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
848 /* skip macroblock */
849 put_bits(&s->pb, 1, 1);
852 put_bits(&s->pb, 1, 0); /* mb coded */
854 if(s->dquant) cbpc+= 8;
856 inter_MCBPC_bits[cbpc],
857 inter_MCBPC_code[cbpc]);
860 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
862 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
864 /* motion vectors: 16x16 mode only now */
865 h263_pred_motion(s, 0, &pred_x, &pred_y);
868 h263_encode_motion(s, motion_x - pred_x, s->f_code);
869 h263_encode_motion(s, motion_y - pred_y, s->f_code);
872 h263p_encode_umotion(s, motion_x - pred_x);
873 h263p_encode_umotion(s, motion_y - pred_y);
874 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
875 /* To prevent Start Code emulation */
876 put_bits(&s->pb,1,1);
879 int li = s->h263_aic ? 0 : 1;
884 if (s->h263_aic && s->mb_intra) {
885 int16_t level = block[i][0];
887 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
891 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
893 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
895 /* AIC can change CBP */
896 if (level == 0 && s->block_last_index[i] == 0)
897 s->block_last_index[i] = -1;
898 else if (level < -127)
900 else if (level > 127)
905 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
908 //if ((rec_intradc[i] % 2) == 0)
911 if (rec_intradc[i] < 0)
913 else if (rec_intradc[i] > 2047)
914 rec_intradc[i] = 2047;
916 /* Update AC/DC tables */
917 *dc_ptr[i] = rec_intradc[i];
920 if (s->block_last_index[i] >= li)
925 if (s->pict_type == I_TYPE) {
926 if(s->dquant) cbpc+=4;
928 intra_MCBPC_bits[cbpc],
929 intra_MCBPC_code[cbpc]);
931 if(s->dquant) cbpc+=8;
932 put_bits(&s->pb, 1, 0); /* mb coded */
934 inter_MCBPC_bits[cbpc + 4],
935 inter_MCBPC_code[cbpc + 4]);
938 /* XXX: currently, we do not try to use ac prediction */
939 put_bits(&s->pb, 1, 0); /* no AC prediction */
942 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
944 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
948 /* encode each block */
949 h263_encode_block(s, block[i], i);
951 /* Update INTRADC for decoding */
952 if (s->h263_aic && s->mb_intra) {
953 block[i][0] = rec_intradc[i];
960 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
962 int x, y, wrap, a, c, pred_dc, scale;
963 int16_t *dc_val, *ac_val;
965 /* find prediction */
967 x = 2 * s->mb_x + 1 + (n & 1);
968 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
969 wrap = s->mb_width * 2 + 2;
970 dc_val = s->dc_val[0];
971 ac_val = s->ac_val[0][0];
972 scale = s->y_dc_scale;
976 wrap = s->mb_width + 2;
977 dc_val = s->dc_val[n - 4 + 1];
978 ac_val = s->ac_val[n - 4 + 1][0];
979 scale = s->c_dc_scale;
984 a = dc_val[(x - 1) + (y) * wrap];
985 c = dc_val[(x) + (y - 1) * wrap];
987 /* No prediction outside GOB boundary */
988 if (s->first_slice_line && ((n < 2) || (n > 3)))
991 /* just DC prediction */
992 if (a != 1024 && c != 1024)
993 pred_dc = (a + c) >> 1;
999 /* we assume pred is positive */
1000 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1001 *dc_val_ptr = &dc_val[x + y * wrap];
1005 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1007 int x, y, wrap, a, c, pred_dc, scale, i;
1008 int16_t *dc_val, *ac_val, *ac_val1;
1010 /* find prediction */
1012 x = 2 * s->mb_x + 1 + (n & 1);
1013 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1014 wrap = s->mb_width * 2 + 2;
1015 dc_val = s->dc_val[0];
1016 ac_val = s->ac_val[0][0];
1017 scale = s->y_dc_scale;
1021 wrap = s->mb_width + 2;
1022 dc_val = s->dc_val[n - 4 + 1];
1023 ac_val = s->ac_val[n - 4 + 1][0];
1024 scale = s->c_dc_scale;
1027 ac_val += ((y) * wrap + (x)) * 16;
1033 a = dc_val[(x - 1) + (y) * wrap];
1034 c = dc_val[(x) + (y - 1) * wrap];
1036 /* No prediction outside GOB boundary */
1037 if (s->first_slice_line && ((n < 2) || (n > 3)))
1041 if (s->h263_aic_dir) {
1042 /* left prediction */
1046 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1051 /* top prediction */
1053 ac_val -= 16 * wrap;
1055 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1061 /* just DC prediction */
1062 if (a != 1024 && c != 1024)
1063 pred_dc = (a + c) >> 1;
1070 /* we assume pred is positive */
1071 block[0]=block[0]*scale + pred_dc;
1075 else if (!(block[0] & 1))
1078 /* Update AC/DC tables */
1079 dc_val[(x) + (y) * wrap] = block[0];
1083 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1086 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1089 int16_t *h263_pred_motion(MpegEncContext * s, int block,
1093 int16_t *A, *B, *C, *mot_val;
1094 static const int off[4]= {2, 1, 1, -1};
1096 wrap = s->block_wrap[0];
1097 xy = s->block_index[block];
1099 mot_val = s->motion_val[xy];
1101 A = s->motion_val[xy - 1];
1102 /* special case for first (slice) line */
1103 if (s->first_slice_line && block<3) {
1104 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1105 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1106 if(block==0){ //most common case
1107 if(s->mb_x == s->resync_mb_x){ //rare
1109 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1110 C = s->motion_val[xy + off[block] - wrap];
1115 *px = mid_pred(A[0], 0, C[0]);
1116 *py = mid_pred(A[1], 0, C[1]);
1123 if(s->mb_x + 1 == s->resync_mb_x){ //rare
1124 C = s->motion_val[xy + off[block] - wrap];
1125 *px = mid_pred(A[0], 0, C[0]);
1126 *py = mid_pred(A[1], 0, C[1]);
1131 }else{ /* block==2*/
1132 B = s->motion_val[xy - wrap];
1133 C = s->motion_val[xy + off[block] - wrap];
1134 if(s->mb_x == s->resync_mb_x) //rare
1137 *px = mid_pred(A[0], B[0], C[0]);
1138 *py = mid_pred(A[1], B[1], C[1]);
1141 B = s->motion_val[xy - wrap];
1142 C = s->motion_val[xy + off[block] - wrap];
1143 *px = mid_pred(A[0], B[0], C[0]);
1144 *py = mid_pred(A[1], B[1], C[1]);
1149 #ifdef CONFIG_ENCODERS
1150 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1152 int range, l, bit_size, sign, code, bits;
1157 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1159 bit_size = f_code - 1;
1160 range = 1 << bit_size;
1161 /* modulo encoding */
1168 val= (val^sign)-sign;
1173 } else if (val >= l) {
1177 assert(val>=-l && val<l);
1187 code = (val >> bit_size) + 1;
1188 bits = val & (range - 1);
1190 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1192 put_bits(&s->pb, bit_size, bits);
1198 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1199 static void h263p_encode_umotion(MpegEncContext * s, int val)
1209 put_bits(&s->pb, 1, 1);
1211 put_bits(&s->pb, 3, 0);
1213 put_bits(&s->pb, 3, 2);
1216 sval = ((val < 0) ? (short)(-val):(short)val);
1219 while (temp_val != 0) {
1220 temp_val = temp_val >> 1;
1226 tcode = (sval & (1 << (i-1))) >> (i-1);
1227 tcode = (tcode << 1) | 1;
1228 code = (code << 2) | tcode;
1231 code = ((code << 1) | (val < 0)) << 1;
1232 put_bits(&s->pb, (2*n_bits)+1, code);
1233 //printf("\nVal = %d\tCode = %d", sval, code);
1237 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1242 if(mv_penalty==NULL)
1243 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1245 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1246 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1249 if(mv==0) len= mvtab[0][1];
1251 int val, bit_size, range, code;
1253 bit_size = s->f_code - 1;
1254 range = 1 << bit_size;
1260 code = (val >> bit_size) + 1;
1262 len= mvtab[code][1] + 1 + bit_size;
1264 len= mvtab[32][1] + 2 + bit_size;
1268 mv_penalty[f_code][mv+MAX_MV]= len;
1272 for(f_code=MAX_FCODE; f_code>0; f_code--){
1273 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1274 fcode_tab[mv+MAX_MV]= f_code;
1278 for(mv=0; mv<MAX_MV*2+1; mv++){
1279 umv_fcode_tab[mv]= 1;
1284 #ifdef CONFIG_ENCODERS
1286 static void init_uni_dc_tab(void)
1288 int level, uni_code, uni_len;
1290 for(level=-256; level<256; level++){
1292 /* find number of bits */
1301 l= (-level) ^ ((1 << size) - 1);
1306 uni_code= DCtab_lum[size][0];
1307 uni_len = DCtab_lum[size][1];
1310 uni_code<<=size; uni_code|=l;
1313 uni_code<<=1; uni_code|=1;
1317 uni_DCtab_lum_bits[level+256]= uni_code;
1318 uni_DCtab_lum_len [level+256]= uni_len;
1321 uni_code= DCtab_chrom[size][0];
1322 uni_len = DCtab_chrom[size][1];
1325 uni_code<<=size; uni_code|=l;
1328 uni_code<<=1; uni_code|=1;
1332 uni_DCtab_chrom_bits[level+256]= uni_code;
1333 uni_DCtab_chrom_len [level+256]= uni_len;
1338 #endif //CONFIG_ENCODERS
1340 #ifdef CONFIG_ENCODERS
1341 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1342 int slevel, run, last;
1344 assert(MAX_LEVEL >= 64);
1345 assert(MAX_RUN >= 63);
1347 for(slevel=-64; slevel<64; slevel++){
1348 if(slevel==0) continue;
1349 for(run=0; run<64; run++){
1350 for(last=0; last<=1; last++){
1351 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1352 int level= slevel < 0 ? -slevel : slevel;
1353 int sign= slevel < 0 ? 1 : 0;
1354 int bits, len, code;
1357 len_tab[index]= 100;
1360 code= get_rl_index(rl, last, run, level);
1361 bits= rl->table_vlc[code][0];
1362 len= rl->table_vlc[code][1];
1363 bits=bits*2+sign; len++;
1365 if(code!=rl->n && len < len_tab[index]){
1366 bits_tab[index]= bits;
1367 len_tab [index]= len;
1371 bits= rl->table_vlc[rl->n][0];
1372 len= rl->table_vlc[rl->n][1];
1373 bits=bits*2; len++; //esc1
1374 level1= level - rl->max_level[last][run];
1376 code= get_rl_index(rl, last, run, level1);
1377 bits<<= rl->table_vlc[code][1];
1378 len += rl->table_vlc[code][1];
1379 bits += rl->table_vlc[code][0];
1380 bits=bits*2+sign; len++;
1382 if(code!=rl->n && len < len_tab[index]){
1383 bits_tab[index]= bits;
1384 len_tab [index]= len;
1390 bits= rl->table_vlc[rl->n][0];
1391 len= rl->table_vlc[rl->n][1];
1392 bits=bits*4+2; len+=2; //esc2
1393 run1 = run - rl->max_run[last][level] - 1;
1395 code= get_rl_index(rl, last, run1, level);
1396 bits<<= rl->table_vlc[code][1];
1397 len += rl->table_vlc[code][1];
1398 bits += rl->table_vlc[code][0];
1399 bits=bits*2+sign; len++;
1401 if(code!=rl->n && len < len_tab[index]){
1402 bits_tab[index]= bits;
1403 len_tab [index]= len;
1408 bits= rl->table_vlc[rl->n][0];
1409 len = rl->table_vlc[rl->n][1];
1410 bits=bits*4+3; len+=2; //esc3
1411 bits=bits*2+last; len++;
1412 bits=bits*64+run; len+=6;
1413 bits=bits*2+1; len++; //marker
1414 bits=bits*4096+(slevel&0xfff); len+=12;
1415 bits=bits*2+1; len++; //marker
1417 if(len < len_tab[index]){
1418 bits_tab[index]= bits;
1419 len_tab [index]= len;
1426 void h263_encode_init(MpegEncContext *s)
1428 static int done = 0;
1437 init_rl(&rl_intra_aic);
1439 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1440 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1442 init_mv_penalty_and_fcode(s);
1444 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1446 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1447 switch(s->codec_id){
1448 case CODEC_ID_MPEG4:
1449 s->fcode_tab= fcode_tab;
1450 s->min_qcoeff= -2048;
1451 s->max_qcoeff= 2047;
1452 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
1453 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1454 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
1455 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1456 s->luma_dc_vlc_length= uni_DCtab_lum_len;
1457 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1458 s->ac_esc_length= 7+2+1+6+1+12+1;
1460 case CODEC_ID_H263P:
1461 s->fcode_tab= umv_fcode_tab;
1462 s->min_qcoeff= -127;
1465 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1466 default: //nothing needed default table allready set in mpegvideo.c
1467 s->min_qcoeff= -127;
1469 s->y_dc_scale_table=
1470 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1475 * encodes a 8x8 block.
1476 * @param block the 8x8 block
1477 * @param n block index (0-3 are luma, 4-5 are chroma)
1479 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1481 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1485 if (s->mb_intra && !s->h263_aic) {
1488 /* 255 cannot be represented, so we clamp */
1493 /* 0 cannot be represented also */
1494 else if (level < 1) {
1498 if (level == 128) //FIXME check rv10
1499 put_bits(&s->pb, 8, 0xff);
1501 put_bits(&s->pb, 8, level & 0xff);
1505 if (s->h263_aic && s->mb_intra)
1510 last_index = s->block_last_index[n];
1511 last_non_zero = i - 1;
1512 for (; i <= last_index; i++) {
1513 j = s->intra_scantable.permutated[i];
1516 run = i - last_non_zero - 1;
1517 last = (i == last_index);
1524 code = get_rl_index(rl, last, run, level);
1525 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1526 if (code == rl->n) {
1527 put_bits(&s->pb, 1, last);
1528 put_bits(&s->pb, 6, run);
1530 assert(slevel != 0);
1532 if(slevel < 128 && slevel > -128)
1533 put_bits(&s->pb, 8, slevel & 0xff);
1535 put_bits(&s->pb, 8, 128);
1536 put_bits(&s->pb, 5, slevel & 0x1f);
1537 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1540 put_bits(&s->pb, 1, sign);
1548 #ifdef CONFIG_ENCODERS
1550 /***************************************************/
1552 * add mpeg4 stuffing bits (01...1)
1554 void ff_mpeg4_stuffing(PutBitContext * pbc)
1557 put_bits(pbc, 1, 0);
1558 length= (-get_bit_count(pbc))&7;
1559 if(length) put_bits(pbc, length, (1<<length)-1);
1562 /* must be called before writing the header */
1563 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1564 int time_div, time_mod;
1566 if(s->pict_type==I_TYPE){ //we will encode a vol header
1568 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1570 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1573 if(s->current_picture.pts)
1574 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1576 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1577 time_div= s->time/s->time_increment_resolution;
1578 time_mod= s->time%s->time_increment_resolution;
1580 if(s->pict_type==B_TYPE){
1581 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1583 s->last_time_base= s->time_base;
1584 s->time_base= time_div;
1585 s->pp_time= s->time - s->last_non_b_time;
1586 s->last_non_b_time= s->time;
1590 static void mpeg4_encode_gop_header(MpegEncContext * s){
1591 int hours, minutes, seconds;
1593 put_bits(&s->pb, 16, 0);
1594 put_bits(&s->pb, 16, GOP_STARTCODE);
1596 seconds= s->time/s->time_increment_resolution;
1597 minutes= seconds/60; seconds %= 60;
1598 hours= minutes/60; minutes %= 60;
1601 put_bits(&s->pb, 5, hours);
1602 put_bits(&s->pb, 6, minutes);
1603 put_bits(&s->pb, 1, 1);
1604 put_bits(&s->pb, 6, seconds);
1606 put_bits(&s->pb, 1, 0); //closed gov == NO
1607 put_bits(&s->pb, 1, 0); //broken link == NO
1609 ff_mpeg4_stuffing(&s->pb);
1612 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1613 int profile_and_level_indication;
1616 if(s->max_b_frames || s->quarter_sample){
1617 profile_and_level_indication= 0xF1; // adv simple level 1
1620 profile_and_level_indication= 0x01; // simple level 1
1625 put_bits(&s->pb, 16, 0);
1626 put_bits(&s->pb, 16, VOS_STARTCODE);
1628 put_bits(&s->pb, 8, profile_and_level_indication);
1630 put_bits(&s->pb, 16, 0);
1631 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1633 put_bits(&s->pb, 1, 1);
1634 put_bits(&s->pb, 4, vo_ver_id);
1635 put_bits(&s->pb, 3, 1); //priority
1637 put_bits(&s->pb, 4, 1); //visual obj type== video obj
1639 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1641 ff_mpeg4_stuffing(&s->pb);
1644 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1648 if(s->max_b_frames || s->quarter_sample){
1650 s->vo_type= ADV_SIMPLE_VO_TYPE;
1653 s->vo_type= SIMPLE_VO_TYPE;
1656 put_bits(&s->pb, 16, 0);
1657 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
1658 put_bits(&s->pb, 16, 0);
1659 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
1661 put_bits(&s->pb, 1, 0); /* random access vol */
1662 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
1663 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1664 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1665 put_bits(&s->pb, 3, 1); /* is obj layer priority */
1667 float_aspect_to_info(s, s->avctx->aspect_ratio);
1669 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1670 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1672 put_bits(&s->pb, 8, s->aspected_width);
1673 put_bits(&s->pb, 8, s->aspected_height);
1677 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1678 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1679 put_bits(&s->pb, 1, s->low_delay);
1680 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1682 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
1685 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1686 put_bits(&s->pb, 1, 1); /* marker bit */
1688 put_bits(&s->pb, 16, s->time_increment_resolution);
1689 if (s->time_increment_bits < 1)
1690 s->time_increment_bits = 1;
1691 put_bits(&s->pb, 1, 1); /* marker bit */
1692 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1693 put_bits(&s->pb, 1, 1); /* marker bit */
1694 put_bits(&s->pb, 13, s->width); /* vol width */
1695 put_bits(&s->pb, 1, 1); /* marker bit */
1696 put_bits(&s->pb, 13, s->height); /* vol height */
1697 put_bits(&s->pb, 1, 1); /* marker bit */
1698 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1699 put_bits(&s->pb, 1, 1); /* obmc disable */
1700 if (vo_ver_id == 1) {
1701 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
1703 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
1706 s->quant_precision=5;
1707 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
1708 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1709 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1712 put_bits(&s->pb, 1, s->quarter_sample);
1713 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1714 s->resync_marker= s->rtp_mode;
1715 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1716 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1717 if(s->data_partitioning){
1718 put_bits(&s->pb, 1, 0); /* no rvlc */
1721 if (vo_ver_id != 1){
1722 put_bits(&s->pb, 1, 0); /* newpred */
1723 put_bits(&s->pb, 1, 0); /* reduced res vop */
1725 put_bits(&s->pb, 1, 0); /* scalability */
1727 ff_mpeg4_stuffing(&s->pb);
1730 if(!(s->flags & CODEC_FLAG_BITEXACT)){
1731 put_bits(&s->pb, 16, 0);
1732 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1733 put_string(&s->pb, LIBAVCODEC_IDENT);
1734 ff_mpeg4_stuffing(&s->pb);
1738 /* write mpeg4 VOP header */
1739 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1742 int time_div, time_mod;
1744 if(s->pict_type==I_TYPE){
1745 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1746 mpeg4_encode_visual_object_header(s);
1747 mpeg4_encode_vol_header(s, 0, 0);
1749 mpeg4_encode_gop_header(s);
1752 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1754 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1756 put_bits(&s->pb, 16, 0); /* vop header */
1757 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
1758 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1760 time_div= s->time/s->time_increment_resolution;
1761 time_mod= s->time%s->time_increment_resolution;
1762 time_incr= time_div - s->last_time_base;
1764 put_bits(&s->pb, 1, 1);
1766 put_bits(&s->pb, 1, 0);
1768 put_bits(&s->pb, 1, 1); /* marker */
1769 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1770 put_bits(&s->pb, 1, 1); /* marker */
1771 put_bits(&s->pb, 1, 1); /* vop coded */
1772 if ( s->pict_type == P_TYPE
1773 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1774 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1776 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1777 if(!s->progressive_sequence){
1778 put_bits(&s->pb, 1, s->top_field_first);
1779 put_bits(&s->pb, 1, s->alternate_scan);
1781 //FIXME sprite stuff
1783 put_bits(&s->pb, 5, s->qscale);
1785 if (s->pict_type != I_TYPE)
1786 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1787 if (s->pict_type == B_TYPE)
1788 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1789 // printf("****frame %d\n", picture_number);
1791 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1792 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1793 s->h_edge_pos= s->width;
1794 s->v_edge_pos= s->height;
1797 #endif //CONFIG_ENCODERS
1800 * change qscale by given dquant and update qscale dependant variables.
1802 static void change_qscale(MpegEncContext * s, int dquant)
1804 s->qscale += dquant;
1808 else if (s->qscale > 31)
1811 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1812 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1817 * @param n block index (0-3 are luma, 4-5 are chroma)
1818 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1819 * @param dir_ptr pointer to an integer where the prediction direction will be stored
1820 * @return the quantized predicted dc
1822 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
1824 int a, b, c, wrap, pred, scale;
1828 /* find prediction */
1830 scale = s->y_dc_scale;
1832 scale = s->c_dc_scale;
1834 wrap= s->block_wrap[n];
1835 dc_val = s->dc_val[0] + s->block_index[n];
1841 b = dc_val[ - 1 - wrap];
1842 c = dc_val[ - wrap];
1844 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1845 if(s->first_slice_line && n!=3){
1847 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1849 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1850 if(n==0 || n==4 || n==5)
1854 if (abs(a - b) < abs(b - c)) {
1856 *dir_ptr = 1; /* top */
1859 *dir_ptr = 0; /* left */
1861 /* we assume pred is positive */
1864 "xorl %%edx, %%edx \n\t"
1866 : "=d" (pred), "=a"(dummy)
1867 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1870 pred = (pred + (scale >> 1)) / scale;
1873 /* prepare address for prediction update */
1874 *dc_val_ptr = &dc_val[0];
1881 * @param n block index (0-3 are luma, 4-5 are chroma)
1882 * @param dir the ac prediction direction
1884 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1888 int16_t *ac_val, *ac_val1;
1889 int8_t * const qscale_table= s->current_picture.qscale_table;
1891 /* find prediction */
1892 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1896 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
1897 /* left prediction */
1900 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1903 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1906 /* different qscale, we must rescale */
1908 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1912 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
1913 /* top prediction */
1914 ac_val -= 16 * s->block_wrap[n];
1916 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1919 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
1922 /* different qscale, we must rescale */
1924 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1931 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1935 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1939 #ifdef CONFIG_ENCODERS
1941 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1946 int8_t * const qscale_table= s->current_picture.qscale_table;
1948 /* find prediction */
1949 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1952 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
1953 /* left prediction */
1955 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1958 block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
1961 /* different qscale, we must rescale */
1963 block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1967 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
1968 /* top prediction */
1969 ac_val -= 16 * s->block_wrap[n];
1970 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1973 block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
1976 /* different qscale, we must rescale */
1978 block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1985 * encodes the dc value.
1986 * @param n block index (0-3 are luma, 4-5 are chroma)
1988 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1991 // if(level<-255 || level>255) printf("dc overflow\n");
1995 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
1998 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2002 /* find number of bits */
2012 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2015 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2018 /* encode remaining bits */
2021 level = (-level) ^ ((1 << size) - 1);
2022 put_bits(&s->pb, size, level);
2024 put_bits(&s->pb, 1, 1);
2030 * encodes a 8x8 block
2031 * @param n block index (0-3 are luma, 4-5 are chroma)
2033 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2034 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2036 int i, last_non_zero;
2037 #if 0 //variables for the outcommented version
2038 int code, sign, last;
2043 const int last_index = s->block_last_index[n];
2045 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2046 /* mpeg4 based DC predictor */
2047 mpeg4_encode_dc(dc_pb, intra_dc, n);
2048 if(last_index<1) return;
2051 bits_tab= uni_mpeg4_intra_rl_bits;
2052 len_tab = uni_mpeg4_intra_rl_len;
2054 if(last_index<0) return;
2057 bits_tab= uni_mpeg4_inter_rl_bits;
2058 len_tab = uni_mpeg4_inter_rl_len;
2062 last_non_zero = i - 1;
2064 for (; i < last_index; i++) {
2065 int level = block[ scan_table[i] ];
2067 int run = i - last_non_zero - 1;
2069 if((level&(~127)) == 0){
2070 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2071 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2073 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);
2078 /*if(i<=last_index)*/{
2079 int level = block[ scan_table[i] ];
2080 int run = i - last_non_zero - 1;
2082 if((level&(~127)) == 0){
2083 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2084 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2086 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);
2090 for (; i <= last_index; i++) {
2091 const int slevel = block[ scan_table[i] ];
2094 int run = i - last_non_zero - 1;
2095 last = (i == last_index);
2102 code = get_rl_index(rl, last, run, level);
2103 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2104 if (code == rl->n) {
2106 level1 = level - rl->max_level[last][run];
2109 code = get_rl_index(rl, last, run, level1);
2110 if (code == rl->n) {
2112 put_bits(ac_pb, 1, 1);
2113 if (level > MAX_LEVEL)
2115 run1 = run - rl->max_run[last][level] - 1;
2118 code = get_rl_index(rl, last, run1, level);
2119 if (code == rl->n) {
2122 put_bits(ac_pb, 1, 1);
2123 put_bits(ac_pb, 1, last);
2124 put_bits(ac_pb, 6, run);
2125 put_bits(ac_pb, 1, 1);
2126 put_bits(ac_pb, 12, slevel & 0xfff);
2127 put_bits(ac_pb, 1, 1);
2130 put_bits(ac_pb, 1, 0);
2131 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2132 put_bits(ac_pb, 1, sign);
2136 put_bits(ac_pb, 1, 0);
2137 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2138 put_bits(ac_pb, 1, sign);
2141 put_bits(ac_pb, 1, sign);
2149 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2150 uint8_t *scan_table)
2152 int i, last_non_zero;
2155 const int last_index = s->block_last_index[n];
2158 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2159 /* mpeg4 based DC predictor */
2160 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2161 if(last_index<1) return len;
2164 len_tab = uni_mpeg4_intra_rl_len;
2166 if(last_index<0) return 0;
2169 len_tab = uni_mpeg4_inter_rl_len;
2173 last_non_zero = i - 1;
2174 for (; i < last_index; i++) {
2175 int level = block[ scan_table[i] ];
2177 int run = i - last_non_zero - 1;
2179 if((level&(~127)) == 0){
2180 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2181 len += len_tab[index];
2183 len += 7+2+1+6+1+12+1;
2188 /*if(i<=last_index)*/{
2189 int level = block[ scan_table[i] ];
2190 int run = i - last_non_zero - 1;
2192 if((level&(~127)) == 0){
2193 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2194 len += len_tab[index];
2196 len += 7+2+1+6+1+12+1;
2206 /***********************************************/
2209 static VLC intra_MCBPC_vlc;
2210 static VLC inter_MCBPC_vlc;
2211 static VLC cbpy_vlc;
2213 static VLC dc_lum, dc_chrom;
2214 static VLC sprite_trajectory;
2215 static VLC mb_type_b_vlc;
2217 void init_vlc_rl(RLTable *rl)
2221 init_vlc(&rl->vlc, 9, rl->n + 1,
2222 &rl->table_vlc[0][1], 4, 2,
2223 &rl->table_vlc[0][0], 4, 2);
2226 for(q=0; q<32; q++){
2235 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2236 for(i=0; i<rl->vlc.table_size; i++){
2237 int code= rl->vlc.table[i][0];
2238 int len = rl->vlc.table[i][1];
2241 if(len==0){ // illegal code
2244 }else if(len<0){ //more bits needed
2248 if(code==rl->n){ //esc
2252 run= rl->table_run [code] + 1;
2253 level= rl->table_level[code] * qmul + qadd;
2254 if(code >= rl->last) run+=192;
2257 rl->rl_vlc[q][i].len= len;
2258 rl->rl_vlc[q][i].level= level;
2259 rl->rl_vlc[q][i].run= run;
2266 /* XXX: find a better solution to handle static init */
2267 void h263_decode_init_vlc(MpegEncContext *s)
2269 static int done = 0;
2274 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
2275 intra_MCBPC_bits, 1, 1,
2276 intra_MCBPC_code, 1, 1);
2277 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
2278 inter_MCBPC_bits, 1, 1,
2279 inter_MCBPC_code, 1, 1);
2280 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2281 &cbpy_tab[0][1], 2, 1,
2282 &cbpy_tab[0][0], 2, 1);
2283 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2285 &mvtab[0][0], 2, 1);
2288 init_rl(&rvlc_rl_inter);
2289 init_rl(&rvlc_rl_intra);
2290 init_rl(&rl_intra_aic);
2291 init_vlc_rl(&rl_inter);
2292 init_vlc_rl(&rl_intra);
2293 init_vlc_rl(&rvlc_rl_inter);
2294 init_vlc_rl(&rvlc_rl_intra);
2295 init_vlc_rl(&rl_intra_aic);
2296 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2297 &DCtab_lum[0][1], 2, 1,
2298 &DCtab_lum[0][0], 2, 1);
2299 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2300 &DCtab_chrom[0][1], 2, 1,
2301 &DCtab_chrom[0][0], 2, 1);
2302 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2303 &sprite_trajectory_tab[0][1], 4, 2,
2304 &sprite_trajectory_tab[0][0], 4, 2);
2305 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2306 &mb_type_b_tab[0][1], 2, 1,
2307 &mb_type_b_tab[0][0], 2, 1);
2312 * Get the GOB height based on picture height.
2314 int ff_h263_get_gob_height(MpegEncContext *s){
2315 if (s->height <= 400)
2317 else if (s->height <= 800)
2324 * decodes the group of blocks header.
2325 * @return <0 if an error occured
2327 static int h263_decode_gob_header(MpegEncContext *s)
2329 unsigned int val, gfid;
2332 /* Check for GOB Start Code */
2333 val = show_bits(&s->gb, 16);
2337 /* We have a GBSC probably with GSTUFF */
2338 skip_bits(&s->gb, 16); /* Drop the zeros */
2339 left= s->gb.size_in_bits - get_bits_count(&s->gb);
2340 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2341 for(;left>13; left--){
2342 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2348 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2350 s->gob_number = get_bits(&s->gb, 5); /* GN */
2351 gfid = get_bits(&s->gb, 2); /* GFID */
2352 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2356 s->mb_y= s->gob_index* s->gob_number;
2358 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2363 static inline void memsetw(short *tab, int val, int n)
2370 #ifdef CONFIG_ENCODERS
2372 void ff_mpeg4_init_partitions(MpegEncContext *s)
2374 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2375 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
2378 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2380 const int pb2_len = get_bit_count(&s->pb2 );
2381 const int tex_pb_len= get_bit_count(&s->tex_pb);
2382 const int bits= get_bit_count(&s->pb);
2384 if(s->pict_type==I_TYPE){
2385 put_bits(&s->pb, 19, DC_MARKER);
2386 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2387 s->i_tex_bits+= tex_pb_len;
2389 put_bits(&s->pb, 17, MOTION_MARKER);
2390 s->misc_bits+=17 + pb2_len;
2391 s->mv_bits+= bits - s->last_bits;
2392 s->p_tex_bits+= tex_pb_len;
2395 flush_put_bits(&s->pb2);
2396 flush_put_bits(&s->tex_pb);
2398 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
2399 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2400 s->last_bits= get_bit_count(&s->pb);
2403 #endif //CONFIG_ENCODERS
2405 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2406 switch(s->pict_type){
2411 return s->f_code+15;
2413 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2419 #ifdef CONFIG_ENCODERS
2421 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2423 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2425 ff_mpeg4_stuffing(&s->pb);
2426 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2427 put_bits(&s->pb, 1, 1);
2429 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2430 put_bits(&s->pb, s->quant_precision, s->qscale);
2431 put_bits(&s->pb, 1, 0); /* no HEC */
2434 #endif //CONFIG_ENCODERS
2437 * check if the next stuff is a resync marker or the end.
2440 static inline int mpeg4_is_resync(MpegEncContext *s){
2441 const int bits_count= get_bits_count(&s->gb);
2443 if(s->workaround_bugs&FF_BUG_NO_PADDING){
2447 if(bits_count + 8 >= s->gb.size_in_bits){
2448 int v= show_bits(&s->gb, 8);
2449 v|= 0x7F >> (7-(bits_count&7));
2454 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2456 GetBitContext gb= s->gb;
2458 skip_bits(&s->gb, 1);
2459 align_get_bits(&s->gb);
2461 for(len=0; len<32; len++){
2462 if(get_bits1(&s->gb)) break;
2467 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2475 * decodes the next video packet.
2476 * @return <0 if something went wrong
2478 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2480 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2481 int header_extension=0, mb_num, len;
2483 /* is there enough space left for a video packet + header */
2484 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2486 for(len=0; len<32; len++){
2487 if(get_bits1(&s->gb)) break;
2490 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2491 printf("marker does not match f_code\n");
2495 if(s->shape != RECT_SHAPE){
2496 header_extension= get_bits1(&s->gb);
2497 //FIXME more stuff here
2500 mb_num= get_bits(&s->gb, mb_num_bits);
2501 if(mb_num>=s->mb_num){
2502 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2505 if(s->pict_type == B_TYPE){
2506 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2507 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2510 s->mb_x= mb_num % s->mb_width;
2511 s->mb_y= mb_num / s->mb_width;
2513 if(s->shape != BIN_ONLY_SHAPE){
2514 int qscale= get_bits(&s->gb, s->quant_precision);
2519 if(s->shape == RECT_SHAPE){
2520 header_extension= get_bits1(&s->gb);
2522 if(header_extension){
2526 while (get_bits1(&s->gb) != 0)
2529 check_marker(&s->gb, "before time_increment in video packed header");
2530 time_increment= get_bits(&s->gb, s->time_increment_bits);
2531 check_marker(&s->gb, "before vop_coding_type in video packed header");
2533 skip_bits(&s->gb, 2); /* vop coding type */
2534 //FIXME not rect stuff here
2536 if(s->shape != BIN_ONLY_SHAPE){
2537 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2538 //FIXME dont just ignore everything
2539 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2540 mpeg4_decode_sprite_trajectory(s);
2541 fprintf(stderr, "untested\n");
2544 //FIXME reduced res stuff here
2546 if (s->pict_type != I_TYPE) {
2547 int f_code = get_bits(&s->gb, 3); /* fcode_for */
2549 printf("Error, video packet header damaged (f_code=0)\n");
2552 if (s->pict_type == B_TYPE) {
2553 int b_code = get_bits(&s->gb, 3);
2555 printf("Error, video packet header damaged (b_code=0)\n");
2560 //FIXME new-pred stuff
2562 //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));
2567 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2569 int c_wrap, c_xy, l_wrap, l_xy;
2571 l_wrap= s->block_wrap[0];
2572 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2573 c_wrap= s->block_wrap[4];
2574 c_xy= s->mb_y*c_wrap + s->mb_x;
2578 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2579 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2580 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2584 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2585 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
2586 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
2589 // we cant clear the MVs as they might be needed by a b frame
2590 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2591 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2592 s->last_mv[0][0][0]=
2593 s->last_mv[0][0][1]=
2594 s->last_mv[1][0][0]=
2595 s->last_mv[1][0][1]= 0;
2599 * decodes the group of blocks / video packet header.
2600 * @return <0 if no resync found
2602 int ff_h263_resync(MpegEncContext *s){
2605 if(s->codec_id==CODEC_ID_MPEG4)
2608 align_get_bits(&s->gb);
2610 if(show_bits(&s->gb, 16)==0){
2611 if(s->codec_id==CODEC_ID_MPEG4)
2612 ret= mpeg4_decode_video_packet_header(s);
2614 ret= h263_decode_gob_header(s);
2618 //ok, its not where its supposed to be ...
2619 s->gb= s->last_resync_gb;
2620 align_get_bits(&s->gb);
2621 left= s->gb.size_in_bits - get_bits_count(&s->gb);
2623 for(;left>16+1+5+5; left-=8){
2624 if(show_bits(&s->gb, 16)==0){
2625 GetBitContext bak= s->gb;
2627 if(s->codec_id==CODEC_ID_MPEG4)
2628 ret= mpeg4_decode_video_packet_header(s);
2630 ret= h263_decode_gob_header(s);
2636 skip_bits(&s->gb, 8);
2643 * gets the average motion vector for a GMC MB.
2644 * @param n either 0 for the x component or 1 for y
2645 * @returns the average MV for a GMC MB
2647 static inline int get_amv(MpegEncContext *s, int n){
2648 int x, y, mb_v, sum, dx, dy, shift;
2649 int len = 1 << (s->f_code + 4);
2650 const int a= s->sprite_warping_accuracy;
2652 if(s->real_sprite_warping_points==1){
2653 if(s->divx_version==500 && s->divx_build==413)
2654 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2656 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2658 dx= s->sprite_delta[n][0];
2659 dy= s->sprite_delta[n][1];
2660 shift= s->sprite_shift[0];
2661 if(n) dy -= 1<<(shift + a + 1);
2662 else dx -= 1<<(shift + a + 1);
2663 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2666 for(y=0; y<16; y++){
2670 //XXX FIXME optimize
2671 for(x=0; x<16; x++){
2676 sum= RSHIFT(sum, a+8-s->quarter_sample);
2679 if (sum < -len) sum= -len;
2680 else if (sum >= len) sum= len-1;
2686 * decodes first partition.
2687 * @return number of MBs decoded or <0 if an error occured
2689 static int mpeg4_decode_partition_a(MpegEncContext *s){
2691 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2693 /* decode first partition */
2695 s->first_slice_line=1;
2696 for(; s->mb_y<s->mb_height; s->mb_y++){
2697 ff_init_block_index(s);
2698 for(; s->mb_x<s->mb_width; s->mb_x++){
2699 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2704 ff_update_block_index(s);
2705 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2706 s->first_slice_line=0;
2708 if(s->pict_type==I_TYPE){
2711 if(show_bits(&s->gb, 19)==DC_MARKER){
2715 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2718 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2721 s->cbp_table[xy]= cbpc & 3;
2722 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2726 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2728 s->current_picture.qscale_table[xy]= s->qscale;
2730 s->mbintra_table[xy]= 1;
2733 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2735 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2739 if(dc_pred_dir) dir|=1;
2741 s->pred_dir_table[xy]= dir;
2742 }else{ /* P/S_TYPE */
2743 int mx, my, pred_x, pred_y, bits;
2744 int16_t * const mot_val= s->motion_val[s->block_index[0]];
2745 const int stride= s->block_wrap[0]*2;
2747 bits= show_bits(&s->gb, 17);
2748 if(bits==MOTION_MARKER){
2754 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2755 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2759 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
2762 mot_val[0 ]= mot_val[2 ]=
2763 mot_val[0+stride]= mot_val[2+stride]= mx;
2764 mot_val[1 ]= mot_val[3 ]=
2765 mot_val[1+stride]= mot_val[3+stride]= my;
2767 if(s->mbintra_table[xy])
2768 ff_clean_intra_table_entries(s);
2771 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2773 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2778 else if (cbpc == 20)
2779 fprintf(stderr, "Stuffing !");
2780 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2782 s->mb_intra = ((cbpc & 4) != 0);
2785 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2786 s->mbintra_table[xy]= 1;
2787 mot_val[0 ]= mot_val[2 ]=
2788 mot_val[0+stride]= mot_val[2+stride]= 0;
2789 mot_val[1 ]= mot_val[3 ]=
2790 mot_val[1+stride]= mot_val[3+stride]= 0;
2792 if(s->mbintra_table[xy])
2793 ff_clean_intra_table_entries(s);
2795 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2796 s->mcsel= get_bits1(&s->gb);
2799 if ((cbpc & 16) == 0) {
2800 /* 16x16 motion prediction */
2802 h263_pred_motion(s, 0, &pred_x, &pred_y);
2804 mx = h263_decode_motion(s, pred_x, s->f_code);
2808 my = h263_decode_motion(s, pred_y, s->f_code);
2811 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
2815 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2818 mot_val[0 ]= mot_val[2 ] =
2819 mot_val[0+stride]= mot_val[2+stride]= mx;
2820 mot_val[1 ]= mot_val[3 ]=
2821 mot_val[1+stride]= mot_val[3+stride]= my;
2824 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
2826 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2827 mx = h263_decode_motion(s, pred_x, s->f_code);
2831 my = h263_decode_motion(s, pred_y, s->f_code);
2848 * decode second partition.
2849 * @return <0 if an error occured
2851 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2853 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2855 s->mb_x= s->resync_mb_x;
2856 s->first_slice_line=1;
2857 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2858 ff_init_block_index(s);
2859 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2860 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2863 ff_update_block_index(s);
2864 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2865 s->first_slice_line=0;
2867 if(s->pict_type==I_TYPE){
2868 int ac_pred= get_bits1(&s->gb);
2869 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2871 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2875 s->cbp_table[xy]|= cbpy<<2;
2876 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
2877 }else{ /* P || S_TYPE */
2878 if(IS_INTRA(s->current_picture.mb_type[xy])){
2880 int ac_pred = get_bits1(&s->gb);
2881 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2884 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2888 if(s->cbp_table[xy] & 8) {
2889 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2891 s->current_picture.qscale_table[xy]= s->qscale;
2895 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2897 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2901 if(dc_pred_dir) dir|=1;
2903 s->cbp_table[xy]&= 3; //remove dquant
2904 s->cbp_table[xy]|= cbpy<<2;
2905 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
2906 s->pred_dir_table[xy]= dir;
2907 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
2908 s->current_picture.qscale_table[xy]= s->qscale;
2909 s->cbp_table[xy]= 0;
2911 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2914 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2918 if(s->cbp_table[xy] & 8) {
2919 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2921 s->current_picture.qscale_table[xy]= s->qscale;
2923 s->cbp_table[xy]&= 3; //remove dquant
2924 s->cbp_table[xy]|= (cbpy^0xf)<<2;
2928 if(mb_num >= mb_count) return 0;
2935 * decodes the first & second partition
2936 * @return <0 if error (and sets error type in the error_status_table)
2938 int ff_mpeg4_decode_partitions(MpegEncContext *s)
2941 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
2942 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
2944 mb_num= mpeg4_decode_partition_a(s);
2946 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2950 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2951 fprintf(stderr, "slice below monitor ...\n");
2952 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2956 s->mb_num_left= mb_num;
2958 if(s->pict_type==I_TYPE){
2959 if(get_bits(&s->gb, 19)!=DC_MARKER){
2960 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2964 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2965 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2969 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
2971 if( mpeg4_decode_partition_b(s, mb_num) < 0){
2972 if(s->pict_type==P_TYPE)
2973 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
2976 if(s->pict_type==P_TYPE)
2977 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
2984 * decode partition C of one MB.
2985 * @return <0 if an error occured
2987 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2990 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2992 mb_type= s->current_picture.mb_type[xy];
2993 cbp = s->cbp_table[xy];
2995 if(s->current_picture.qscale_table[xy] != s->qscale){
2996 s->qscale= s->current_picture.qscale_table[xy];
2997 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2998 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3001 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3004 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3005 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3007 s->mb_intra = IS_INTRA(mb_type);
3009 if (IS_SKIP(mb_type)) {
3012 s->block_last_index[i] = -1;
3013 s->mv_dir = MV_DIR_FORWARD;
3014 s->mv_type = MV_TYPE_16X16;
3015 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3022 }else if(s->mb_intra){
3023 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3024 }else if(!s->mb_intra){
3025 // s->mcsel= 0; //FIXME do we need to init that
3027 s->mv_dir = MV_DIR_FORWARD;
3028 if (IS_8X8(mb_type)) {
3029 s->mv_type = MV_TYPE_8X8;
3031 s->mv_type = MV_TYPE_16X16;
3034 } else { /* I-Frame */
3036 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3039 if (!IS_SKIP(mb_type)) {
3041 /* decode each block */
3042 for (i = 0; i < 6; i++) {
3043 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3044 fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3051 /* per-MB end of slice check */
3053 if(--s->mb_num_left <= 0){
3054 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3055 if(mpeg4_is_resync(s))
3060 if(mpeg4_is_resync(s)){
3061 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3062 if(s->cbp_table[xy+delta])
3069 int ff_h263_decode_mb(MpegEncContext *s,
3070 DCTELEM block[6][64])
3072 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3074 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3075 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3077 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3078 if (get_bits1(&s->gb)) {
3082 s->block_last_index[i] = -1;
3083 s->mv_dir = MV_DIR_FORWARD;
3084 s->mv_type = MV_TYPE_16X16;
3085 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3086 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3088 s->mv[0][0][0]= get_amv(s, 0);
3089 s->mv[0][0][1]= get_amv(s, 1);
3093 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3101 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3102 //fprintf(stderr, "\tCBPC: %d", cbpc);
3107 else if (cbpc == 20)
3108 fprintf(stderr, "Stuffing !");
3111 s->mb_intra = ((cbpc & 4) != 0);
3112 if (s->mb_intra) goto intra;
3114 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3115 s->mcsel= get_bits1(&s->gb);
3117 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3118 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3120 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3122 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3123 s->interlaced_dct= get_bits1(&s->gb);
3125 s->mv_dir = MV_DIR_FORWARD;
3126 if ((cbpc & 16) == 0) {
3128 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3129 /* 16x16 global motion prediction */
3130 s->mv_type = MV_TYPE_16X16;
3133 s->mv[0][0][0] = mx;
3134 s->mv[0][0][1] = my;
3135 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3136 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
3137 /* 16x8 field motion prediction */
3138 s->mv_type= MV_TYPE_FIELD;
3140 s->field_select[0][0]= get_bits1(&s->gb);
3141 s->field_select[0][1]= get_bits1(&s->gb);
3143 h263_pred_motion(s, 0, &pred_x, &pred_y);
3146 mx = h263_decode_motion(s, pred_x, s->f_code);
3150 my = h263_decode_motion(s, pred_y/2, s->f_code);
3154 s->mv[0][i][0] = mx;
3155 s->mv[0][i][1] = my;
3158 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3159 /* 16x16 motion prediction */
3160 s->mv_type = MV_TYPE_16X16;
3161 h263_pred_motion(s, 0, &pred_x, &pred_y);
3163 mx = h263p_decode_umotion(s, pred_x);
3165 mx = h263_decode_motion(s, pred_x, s->f_code);
3171 my = h263p_decode_umotion(s, pred_y);
3173 my = h263_decode_motion(s, pred_y, s->f_code);
3177 s->mv[0][0][0] = mx;
3178 s->mv[0][0][1] = my;
3180 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3181 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3184 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3185 s->mv_type = MV_TYPE_8X8;
3187 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3189 mx = h263p_decode_umotion(s, pred_x);
3191 mx = h263_decode_motion(s, pred_x, s->f_code);
3196 my = h263p_decode_umotion(s, pred_y);
3198 my = h263_decode_motion(s, pred_y, s->f_code);
3201 s->mv[0][i][0] = mx;
3202 s->mv[0][i][1] = my;
3203 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3204 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3209 } else if(s->pict_type==B_TYPE) {
3210 int modb1; // first bit of modb
3211 int modb2; // second bit of modb
3214 s->mb_intra = 0; //B-frames never contain intra blocks
3215 s->mcsel=0; // ... true gmc blocks
3219 s->last_mv[i][0][0]=
3220 s->last_mv[i][0][1]=
3221 s->last_mv[i][1][0]=
3222 s->last_mv[i][1][1]= 0;
3226 /* if we skipped it in the future P Frame than skip it now too */
3227 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
3232 s->block_last_index[i] = -1;
3234 s->mv_dir = MV_DIR_FORWARD;
3235 s->mv_type = MV_TYPE_16X16;
3240 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3244 modb1= get_bits1(&s->gb);
3246 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3249 modb2= get_bits1(&s->gb);
3250 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3252 printf("illegal MB_type\n");
3255 mb_type= mb_type_b_map[ mb_type ];
3257 else cbp= get_bits(&s->gb, 6);
3259 if ((!IS_DIRECT(mb_type)) && cbp) {
3260 if(get_bits1(&s->gb)){
3261 change_qscale(s, get_bits1(&s->gb)*4 - 2);
3265 if(!s->progressive_sequence){
3267 s->interlaced_dct= get_bits1(&s->gb);
3269 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3270 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3271 mb_type &= ~MB_TYPE_16x16;
3273 if(USES_LIST(mb_type, 0)){
3274 s->field_select[0][0]= get_bits1(&s->gb);
3275 s->field_select[0][1]= get_bits1(&s->gb);
3277 if(USES_LIST(mb_type, 1)){
3278 s->field_select[1][0]= get_bits1(&s->gb);
3279 s->field_select[1][1]= get_bits1(&s->gb);
3285 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3286 s->mv_type= MV_TYPE_16X16;
3288 if(USES_LIST(mb_type, 0)){
3289 s->mv_dir = MV_DIR_FORWARD;
3291 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3292 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3293 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3294 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3297 if(USES_LIST(mb_type, 1)){
3298 s->mv_dir |= MV_DIR_BACKWARD;
3300 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3301 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3302 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3303 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3305 }else if(!IS_DIRECT(mb_type)){
3306 s->mv_type= MV_TYPE_FIELD;
3308 if(USES_LIST(mb_type, 0)){
3309 s->mv_dir = MV_DIR_FORWARD;
3312 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
3313 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3314 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
3315 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3319 if(USES_LIST(mb_type, 1)){
3320 s->mv_dir |= MV_DIR_BACKWARD;
3323 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
3324 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3325 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
3326 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3332 if(IS_DIRECT(mb_type)){
3333 if(IS_SKIP(mb_type))
3336 mx = h263_decode_motion(s, 0, 1);
3337 my = h263_decode_motion(s, 0, 1);
3340 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3341 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3343 s->current_picture.mb_type[xy]= mb_type;
3344 } else { /* I-Frame */
3345 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3351 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3352 if (s->h263_pred || s->h263_aic) {
3353 s->ac_pred = get_bits1(&s->gb);
3355 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3358 s->h263_aic_dir = get_bits1(&s->gb);
3363 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3364 if(cbpy<0) return -1;
3365 cbp = (cbpc & 3) | (cbpy << 2);
3367 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3370 if(!s->progressive_sequence)
3371 s->interlaced_dct= get_bits1(&s->gb);
3373 /* decode each block */
3375 for (i = 0; i < 6; i++) {
3376 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3381 for (i = 0; i < 6; i++) {
3382 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3390 /* decode each block */
3392 for (i = 0; i < 6; i++) {
3393 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3398 for (i = 0; i < 6; i++) {
3399 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3406 /* per-MB end of slice check */
3407 if(s->codec_id==CODEC_ID_MPEG4){
3408 if(mpeg4_is_resync(s)){
3409 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3410 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3415 int v= show_bits(&s->gb, 16);
3417 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3418 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3428 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3430 int code, val, sign, shift, l;
3431 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3438 sign = get_bits1(&s->gb);
3442 val = (val - 1) << shift;
3443 val |= get_bits(&s->gb, shift);
3450 /* modulo decoding */
3451 if (!s->h263_long_vectors) {
3452 l = 1 << (f_code + 4);
3453 val = ((val + l)&(l*2-1)) - l;
3455 /* horrible h263 long vector mode */
3456 if (pred < -31 && val < -63)
3458 if (pred > 32 && val > 63)
3465 /* Decodes RVLC of H.263+ UMV */
3466 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3470 if (get_bits1(&s->gb)) /* Motion difference = 0 */
3473 code = 2 + get_bits1(&s->gb);
3475 while (get_bits1(&s->gb))
3478 code += get_bits1(&s->gb);
3483 code = (sign) ? (pred - code) : (pred + code);
3485 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3491 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3494 int code, level, i, j, last, run;
3495 RLTable *rl = &rl_inter;
3496 const uint8_t *scan_table;
3498 scan_table = s->intra_scantable.permutated;
3499 if (s->h263_aic && s->mb_intra) {
3503 if (s->h263_aic_dir)
3504 scan_table = s->intra_v_scantable.permutated; /* left */
3506 scan_table = s->intra_h_scantable.permutated; /* top */
3508 } else if (s->mb_intra) {
3511 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3512 int component, diff;
3513 component = (n <= 3 ? 0 : n - 4 + 1);
3514 level = s->last_dc[component];
3515 if (s->rv10_first_dc_coded[component]) {
3516 diff = rv_decode_dc(s, n);
3520 level = level & 0xff; /* handle wrap round */
3521 s->last_dc[component] = level;
3523 s->rv10_first_dc_coded[component] = 1;
3526 level = get_bits(&s->gb, 8);
3529 level = get_bits(&s->gb, 8);
3530 if((level&0x7F) == 0){
3531 fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3543 if (s->mb_intra && s->h263_aic)
3545 s->block_last_index[n] = i - 1;
3550 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3552 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3555 if (code == rl->n) {
3557 last = get_bits1(&s->gb);
3558 run = get_bits(&s->gb, 6);
3559 level = (int8_t)get_bits(&s->gb, 8);
3562 /* XXX: should patch encoder too */
3563 level = get_sbits(&s->gb, 12);
3565 level = get_bits(&s->gb, 5);
3566 level |= get_sbits(&s->gb, 6)<<5;
3570 run = rl->table_run[code];
3571 level = rl->table_level[code];
3572 last = code >= rl->last;
3573 if (get_bits1(&s->gb))
3578 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3588 if (s->mb_intra && s->h263_aic) {
3589 h263_pred_acdc(s, block, n);
3592 s->block_last_index[n] = i;
3597 * decodes the dc value.
3598 * @param n block index (0-3 are luma, 4-5 are chroma)
3599 * @param dir_ptr the prediction direction will be stored here
3600 * @return the quantized dc
3602 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3604 int level, pred, code;
3608 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3610 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3611 if (code < 0 || code > 9 /* && s->nbit<9 */){
3612 fprintf(stderr, "illegal dc vlc\n");
3618 level = get_xbits(&s->gb, code);
3620 if(get_bits1(&s->gb)==0){ /* marker */
3621 if(s->error_resilience>=2){
3622 fprintf(stderr, "dc marker bit missing\n");
3628 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3631 if(s->error_resilience>=3){
3632 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3638 *dc_val = level * s->y_dc_scale;
3640 *dc_val = level * s->c_dc_scale;
3642 if(s->error_resilience>=3){
3643 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3644 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3653 * @return <0 if an error occured
3655 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3656 int n, int coded, int intra, int rvlc)
3658 int level, i, last, run;
3661 RL_VLC_ELEM * rl_vlc;
3662 const uint8_t * scan_table;
3665 //Note intra & rvlc should be optimized away if this is inlined
3669 if(s->partitioned_frame){
3670 level = s->dc_val[0][ s->block_index[n] ];
3671 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3672 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3673 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
3675 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3685 rl = &rvlc_rl_intra;
3686 rl_vlc = rvlc_rl_intra.rl_vlc[0];
3689 rl_vlc = rl_intra.rl_vlc[0];
3692 if (dc_pred_dir == 0)
3693 scan_table = s->intra_v_scantable.permutated; /* left */
3695 scan_table = s->intra_h_scantable.permutated; /* top */
3697 scan_table = s->intra_scantable.permutated;
3704 s->block_last_index[n] = i;
3707 if(rvlc) rl = &rvlc_rl_inter;
3708 else rl = &rl_inter;
3710 scan_table = s->intra_scantable.permutated;
3716 rl_vlc = rvlc_rl_inter.rl_vlc[0];
3718 rl_vlc = rl_inter.rl_vlc[0];
3721 qmul = s->qscale << 1;
3722 qadd = (s->qscale - 1) | 1;
3724 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
3726 rl_vlc = rl_inter.rl_vlc[s->qscale];
3731 OPEN_READER(re, &s->gb);
3733 UPDATE_CACHE(re, &s->gb);
3734 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3738 if(SHOW_UBITS(re, &s->gb, 1)==0){
3739 fprintf(stderr, "1. marker bit missing in rvlc esc\n");
3741 }; SKIP_CACHE(re, &s->gb, 1);
3743 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3744 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3745 SKIP_COUNTER(re, &s->gb, 1+1+6);
3746 UPDATE_CACHE(re, &s->gb);
3748 if(SHOW_UBITS(re, &s->gb, 1)==0){
3749 fprintf(stderr, "2. marker bit missing in rvlc esc\n");
3751 }; SKIP_CACHE(re, &s->gb, 1);
3753 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3755 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3756 fprintf(stderr, "reverse esc missing\n");
3758 }; SKIP_CACHE(re, &s->gb, 5);
3760 level= level * qmul + qadd;
3761 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
3762 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
3768 cache= GET_CACHE(re, &s->gb);
3769 if (cache&0x80000000) {
3770 if (cache&0x40000000) {
3772 SKIP_CACHE(re, &s->gb, 2);
3773 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3774 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3775 SKIP_COUNTER(re, &s->gb, 2+1+6);
3776 UPDATE_CACHE(re, &s->gb);
3778 if(SHOW_UBITS(re, &s->gb, 1)==0){
3779 fprintf(stderr, "1. marker bit missing in 3. esc\n");
3781 }; SKIP_CACHE(re, &s->gb, 1);
3783 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3785 if(SHOW_UBITS(re, &s->gb, 1)==0){
3786 fprintf(stderr, "2. marker bit missing in 3. esc\n");
3788 }; LAST_SKIP_CACHE(re, &s->gb, 1);
3790 SKIP_COUNTER(re, &s->gb, 1+12+1);
3792 if(level*s->qscale>1024 || level*s->qscale<-1024){
3793 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3798 const int abs_level= ABS(level);
3799 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3800 const int run1= run - rl->max_run[last][abs_level] - 1;
3801 if(abs_level <= rl->max_level[last][run]){
3802 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3805 if(s->error_resilience > FF_ER_COMPLIANT){
3806 if(abs_level <= rl->max_level[last][run]*2){
3807 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3810 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3811 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3818 if (level>0) level= level * qmul + qadd;
3819 else level= level * qmul - qadd;
3825 #if MIN_CACHE_BITS < 20
3826 LAST_SKIP_BITS(re, &s->gb, 2);
3827 UPDATE_CACHE(re, &s->gb);
3829 SKIP_BITS(re, &s->gb, 2);
3831 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3832 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3833 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3834 LAST_SKIP_BITS(re, &s->gb, 1);
3838 #if MIN_CACHE_BITS < 19
3839 LAST_SKIP_BITS(re, &s->gb, 1);
3840 UPDATE_CACHE(re, &s->gb);
3842 SKIP_BITS(re, &s->gb, 1);
3844 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3846 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3847 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3848 LAST_SKIP_BITS(re, &s->gb, 1);
3853 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3854 LAST_SKIP_BITS(re, &s->gb, 1);
3859 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3863 block[scan_table[i]] = level;
3867 block[scan_table[i]] = level;
3869 CLOSE_READER(re, &s->gb);
3873 mpeg4_pred_ac(s, block, n, dc_pred_dir);
3875 i = 63; /* XXX: not optimal */
3878 s->block_last_index[n] = i;
3882 /* most is hardcoded. should extend to handle all h263 streams */
3883 int h263_decode_picture_header(MpegEncContext *s)
3885 int format, width, height;
3887 /* picture start code */
3888 if (get_bits(&s->gb, 22) != 0x20) {
3889 fprintf(stderr, "Bad picture start code\n");
3892 /* temporal reference */
3893 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3895 /* PTYPE starts here */
3896 if (get_bits1(&s->gb) != 1) {
3898 fprintf(stderr, "Bad marker\n");
3901 if (get_bits1(&s->gb) != 0) {
3902 fprintf(stderr, "Bad H263 id\n");
3903 return -1; /* h263 id */
3905 skip_bits1(&s->gb); /* split screen off */
3906 skip_bits1(&s->gb); /* camera off */
3907 skip_bits1(&s->gb); /* freeze picture release off */
3909 /* Reset GOB number */
3912 format = get_bits(&s->gb, 3);
3917 7 extended PTYPE (PLUSPTYPE)
3920 if (format != 7 && format != 6) {
3923 width = h263_format[format][0];
3924 height = h263_format[format][1];
3930 s->pict_type = I_TYPE + get_bits1(&s->gb);
3932 s->unrestricted_mv = get_bits1(&s->gb);
3933 s->h263_long_vectors = s->unrestricted_mv;
3935 if (get_bits1(&s->gb) != 0) {
3936 fprintf(stderr, "H263 SAC not supported\n");
3937 return -1; /* SAC: off */
3939 if (get_bits1(&s->gb) != 0) {
3940 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3943 if (get_bits1(&s->gb) != 0) {
3944 fprintf(stderr, "H263 PB frame not supported\n");
3945 return -1; /* not PB frame */
3947 s->qscale = get_bits(&s->gb, 5);
3948 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
3954 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3956 /* ufep other than 0 and 1 are reserved */
3959 format = get_bits(&s->gb, 3);
3960 dprintf("ufep=1, format: %d\n", format);
3961 skip_bits(&s->gb,1); /* Custom PCF */
3962 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3963 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3964 if (get_bits1(&s->gb) != 0) {
3965 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3967 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3971 skip_bits(&s->gb, 7);
3972 /* these are the 7 bits: (in order of appearence */
3973 /* Deblocking Filter */
3974 /* Slice Structured */
3975 /* Reference Picture Selection */
3976 /* Independent Segment Decoding */
3977 /* Alternative Inter VLC */
3978 /* Modified Quantization */
3979 /* Prevent start code emulation */
3981 skip_bits(&s->gb, 3); /* Reserved */
3982 } else if (ufep != 0) {
3983 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3988 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3989 dprintf("pict_type: %d\n", s->pict_type);
3990 if (s->pict_type != I_TYPE &&
3991 s->pict_type != P_TYPE)
3993 skip_bits(&s->gb, 2);
3994 s->no_rounding = get_bits1(&s->gb);
3995 dprintf("RTYPE: %d\n", s->no_rounding);
3996 skip_bits(&s->gb, 4);
3998 /* Get the picture dimensions */
4001 /* Custom Picture Format (CPFMT) */
4002 s->aspect_ratio_info = get_bits(&s->gb, 4);
4003 dprintf("aspect: %d\n", s->aspect_ratio_info);
4008 3 - 10:11 (525-type 4:3)
4009 4 - 16:11 (CIF 16:9)
4010 5 - 40:33 (525-type 16:9)
4013 width = (get_bits(&s->gb, 9) + 1) * 4;
4015 height = get_bits(&s->gb, 9) * 4;
4016 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4017 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4018 /* aspected dimensions */
4019 s->aspected_width = get_bits(&s->gb, 8);
4020 s->aspected_height = get_bits(&s->gb, 8);
4022 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4023 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4026 width = h263_format[format][0];
4027 height = h263_format[format][1];
4029 if ((width == 0) || (height == 0))
4034 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4039 s->qscale = get_bits(&s->gb, 5);
4042 while (get_bits1(&s->gb) != 0) {
4043 skip_bits(&s->gb, 8);
4048 s->y_dc_scale_table=
4049 s->c_dc_scale_table= h263_aic_dc_scale_table;
4051 s->y_dc_scale_table=
4052 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4058 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4061 int a= 2<<s->sprite_warping_accuracy;
4062 int rho= 3-s->sprite_warping_accuracy;
4064 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4065 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4066 int sprite_ref[4][2];
4067 int virtual_ref[2][2];
4069 int alpha=0, beta=0;
4074 for(i=0; i<s->num_sprite_warping_points; i++){
4078 length= get_vlc(&s->gb, &sprite_trajectory);
4080 x= get_xbits(&s->gb, length);
4082 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4084 length= get_vlc(&s->gb, &sprite_trajectory);
4086 y=get_xbits(&s->gb, length);
4088 skip_bits1(&s->gb); /* marker bit */
4089 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4094 while((1<<alpha)<w) alpha++;
4095 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4099 // Note, the 4th point isnt used for GMC
4100 if(s->divx_version==500 && s->divx_build==413){
4101 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4102 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4103 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4104 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4105 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4106 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4108 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4109 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4110 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4111 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4112 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4113 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4115 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4116 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4118 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4119 // perhaps it should be reordered to be more readable ...
4120 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4121 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4122 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
4123 + 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);
4124 virtual_ref[0][1]= 16*vop_ref[0][1]
4125 + 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);
4126 virtual_ref[1][0]= 16*vop_ref[0][0]
4127 + 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);
4128 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
4129 + 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);
4131 switch(s->num_sprite_warping_points)
4134 s->sprite_offset[0][0]= 0;
4135 s->sprite_offset[0][1]= 0;
4136 s->sprite_offset[1][0]= 0;
4137 s->sprite_offset[1][1]= 0;
4138 s->sprite_delta[0][0]= a;
4139 s->sprite_delta[0][1]= 0;
4140 s->sprite_delta[1][0]= 0;
4141 s->sprite_delta[1][1]= a;
4142 s->sprite_shift[0]= 0;
4143 s->sprite_shift[1]= 0;
4146 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4147 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4148 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4149 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4150 s->sprite_delta[0][0]= a;
4151 s->sprite_delta[0][1]= 0;
4152 s->sprite_delta[1][0]= 0;
4153 s->sprite_delta[1][1]= a;
4154 s->sprite_shift[0]= 0;
4155 s->sprite_shift[1]= 0;
4158 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4159 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4160 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4161 + (1<<(alpha+rho-1));
4162 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4163 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4164 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4165 + (1<<(alpha+rho-1));
4166 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4167 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4168 +2*w2*r*sprite_ref[0][0]
4170 + (1<<(alpha+rho+1)));
4171 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
4172 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4173 +2*w2*r*sprite_ref[0][1]
4175 + (1<<(alpha+rho+1)));
4176 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4177 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4178 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4179 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4181 s->sprite_shift[0]= alpha+rho;
4182 s->sprite_shift[1]= alpha+rho+2;
4185 min_ab= FFMIN(alpha, beta);
4188 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4189 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4190 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4191 + (1<<(alpha+beta+rho-min_ab-1));
4192 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4193 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4194 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4195 + (1<<(alpha+beta+rho-min_ab-1));
4196 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4197 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4198 + 2*w2*h3*r*sprite_ref[0][0]
4200 + (1<<(alpha+beta+rho-min_ab+1));
4201 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4202 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4203 + 2*w2*h3*r*sprite_ref[0][1]
4205 + (1<<(alpha+beta+rho-min_ab+1));
4206 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4207 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4208 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4209 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4211 s->sprite_shift[0]= alpha + beta + rho - min_ab;
4212 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4215 /* try to simplify the situation */
4216 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4217 && s->sprite_delta[0][1] == 0
4218 && s->sprite_delta[1][0] == 0
4219 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4221 s->sprite_offset[0][0]>>=s->sprite_shift[0];
4222 s->sprite_offset[0][1]>>=s->sprite_shift[0];
4223 s->sprite_offset[1][0]>>=s->sprite_shift[1];
4224 s->sprite_offset[1][1]>>=s->sprite_shift[1];
4225 s->sprite_delta[0][0]= a;
4226 s->sprite_delta[0][1]= 0;
4227 s->sprite_delta[1][0]= 0;
4228 s->sprite_delta[1][1]= a;
4229 s->sprite_shift[0]= 0;
4230 s->sprite_shift[1]= 0;
4231 s->real_sprite_warping_points=1;
4234 int shift_y= 16 - s->sprite_shift[0];
4235 int shift_c= 16 - s->sprite_shift[1];
4236 //printf("shifts %d %d\n", shift_y, shift_c);
4238 s->sprite_offset[0][i]<<= shift_y;
4239 s->sprite_offset[1][i]<<= shift_c;
4240 s->sprite_delta[0][i]<<= shift_y;
4241 s->sprite_delta[1][i]<<= shift_y;
4242 s->sprite_shift[i]= 16;
4244 s->real_sprite_warping_points= s->num_sprite_warping_points;
4247 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4248 vop_ref[0][0], vop_ref[0][1],
4249 vop_ref[1][0], vop_ref[1][1],
4250 vop_ref[2][0], vop_ref[2][1],
4251 sprite_ref[0][0], sprite_ref[0][1],
4252 sprite_ref[1][0], sprite_ref[1][1],
4253 sprite_ref[2][0], sprite_ref[2][1],
4254 virtual_ref[0][0], virtual_ref[0][1],
4255 virtual_ref[1][0], virtual_ref[1][1]
4258 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4259 s->sprite_offset[0][0], s->sprite_offset[0][1],
4260 s->sprite_delta[0][0], s->sprite_delta[0][1],
4261 s->sprite_delta[1][0], s->sprite_delta[1][1],
4267 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4268 int hours, minutes, seconds;
4270 hours= get_bits(gb, 5);
4271 minutes= get_bits(gb, 6);
4273 seconds= get_bits(gb, 6);
4275 s->time_base= seconds + 60*(minutes + 60*hours);
4283 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4284 int width, height, vo_ver_id;
4287 skip_bits(gb, 1); /* random access */
4288 s->vo_type= get_bits(gb, 8);
4289 if (get_bits1(gb) != 0) { /* is_ol_id */
4290 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4291 skip_bits(gb, 3); /* vo_priority */
4295 //printf("vo type:%d\n",s->vo_type);
4296 s->aspect_ratio_info= get_bits(gb, 4);
4297 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
4298 s->aspected_width = get_bits(gb, 8); // par_width
4299 s->aspected_height = get_bits(gb, 8); // par_height
4301 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4302 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4305 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4306 int chroma_format= get_bits(gb, 2);
4307 if(chroma_format!=1){
4308 printf("illegal chroma format\n");
4310 s->low_delay= get_bits1(gb);
4311 if(get_bits1(gb)){ /* vbv parameters */
4312 get_bits(gb, 15); /* first_half_bitrate */
4313 skip_bits1(gb); /* marker */
4314 get_bits(gb, 15); /* latter_half_bitrate */
4315 skip_bits1(gb); /* marker */
4316 get_bits(gb, 15); /* first_half_vbv_buffer_size */
4317 skip_bits1(gb); /* marker */
4318 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
4319 get_bits(gb, 11); /* first_half_vbv_occupancy */
4320 skip_bits1(gb); /* marker */
4321 get_bits(gb, 15); /* latter_half_vbv_occupancy */
4322 skip_bits1(gb); /* marker */
4325 // set low delay flag only once so the smart? low delay detection wont be overriden
4326 if(s->picture_number==0)
4330 s->shape = get_bits(gb, 2); /* vol shape */
4331 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4332 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4333 printf("Gray shape not supported\n");
4334 skip_bits(gb, 4); //video_object_layer_shape_extension
4337 skip_bits1(gb); /* marker */
4339 s->time_increment_resolution = get_bits(gb, 16);
4341 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4342 if (s->time_increment_bits < 1)
4343 s->time_increment_bits = 1;
4344 skip_bits1(gb); /* marker */
4346 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
4347 skip_bits(gb, s->time_increment_bits);
4350 if (s->shape != BIN_ONLY_SHAPE) {
4351 if (s->shape == RECT_SHAPE) {
4352 skip_bits1(gb); /* marker */
4353 width = get_bits(gb, 13);
4354 skip_bits1(gb); /* marker */
4355 height = get_bits(gb, 13);
4356 skip_bits1(gb); /* marker */
4357 if(width && height){ /* they should be non zero but who knows ... */
4360 // printf("width/height: %d %d\n", width, height);
4364 s->progressive_sequence= get_bits1(gb)^1;
4365 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
4366 printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
4367 if (vo_ver_id == 1) {
4368 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4370 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4372 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4373 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4374 if(s->vol_sprite_usage==STATIC_SPRITE){
4375 s->sprite_width = get_bits(gb, 13);
4376 skip_bits1(gb); /* marker */
4377 s->sprite_height= get_bits(gb, 13);
4378 skip_bits1(gb); /* marker */
4379 s->sprite_left = get_bits(gb, 13);
4380 skip_bits1(gb); /* marker */
4381 s->sprite_top = get_bits(gb, 13);
4382 skip_bits1(gb); /* marker */
4384 s->num_sprite_warping_points= get_bits(gb, 6);
4385 s->sprite_warping_accuracy = get_bits(gb, 2);
4386 s->sprite_brightness_change= get_bits1(gb);
4387 if(s->vol_sprite_usage==STATIC_SPRITE)
4388 s->low_latency_sprite= get_bits1(gb);
4390 // FIXME sadct disable bit if verid!=1 && shape not rect
4392 if (get_bits1(gb) == 1) { /* not_8_bit */
4393 s->quant_precision = get_bits(gb, 4); /* quant_precision */
4394 if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4395 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4397 s->quant_precision = 5;
4400 // FIXME a bunch of grayscale shape things
4402 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4405 /* load default matrixes */
4406 for(i=0; i<64; i++){
4407 int j= s->dsp.idct_permutation[i];
4408 v= ff_mpeg4_default_intra_matrix[i];
4409 s->intra_matrix[j]= v;
4410 s->chroma_intra_matrix[j]= v;
4412 v= ff_mpeg4_default_non_intra_matrix[i];
4413 s->inter_matrix[j]= v;
4414 s->chroma_inter_matrix[j]= v;
4417 /* load custom intra matrix */
4420 for(i=0; i<64; i++){
4426 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4427 s->intra_matrix[j]= v;
4428 s->chroma_intra_matrix[j]= v;
4431 /* replicate last value */
4433 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4434 s->intra_matrix[j]= v;
4435 s->chroma_intra_matrix[j]= v;
4439 /* load custom non intra matrix */
4442 for(i=0; i<64; i++){
4448 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4449 s->inter_matrix[j]= v;
4450 s->chroma_inter_matrix[j]= v;
4453 /* replicate last value */
4455 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4456 s->inter_matrix[j]= last;
4457 s->chroma_inter_matrix[j]= last;
4461 // FIXME a bunch of grayscale shape things
4465 s->quarter_sample= get_bits1(gb);
4466 else s->quarter_sample=0;
4468 if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4470 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4472 s->data_partitioning= get_bits1(gb);
4473 if(s->data_partitioning){
4474 s->rvlc= get_bits1(gb);
4477 if(vo_ver_id != 1) {
4478 s->new_pred= get_bits1(gb);
4480 printf("new pred not supported\n");
4481 skip_bits(gb, 2); /* requested upstream message type */
4482 skip_bits1(gb); /* newpred segment type */
4484 s->reduced_res_vop= get_bits1(gb);
4485 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4489 s->reduced_res_vop= 0;
4492 s->scalability= get_bits1(gb);
4494 if (s->scalability) {
4495 GetBitContext bak= *gb;
4497 int ref_layer_sampling_dir;
4498 int h_sampling_factor_n;
4499 int h_sampling_factor_m;
4500 int v_sampling_factor_n;
4501 int v_sampling_factor_m;
4503 s->hierachy_type= get_bits1(gb);
4504 ref_layer_id= get_bits(gb, 4);
4505 ref_layer_sampling_dir= get_bits1(gb);
4506 h_sampling_factor_n= get_bits(gb, 5);
4507 h_sampling_factor_m= get_bits(gb, 5);
4508 v_sampling_factor_n= get_bits(gb, 5);
4509 v_sampling_factor_m= get_bits(gb, 5);
4510 s->enhancement_type= get_bits1(gb);
4512 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
4513 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4515 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4520 printf("scalability not supported\n");
4522 // bin shape stuff FIXME
4529 * decodes the user data stuff in the header.
4530 * allso inits divx/xvid/lavc_version/build
4532 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4536 int ver, build, ver2, ver3;
4539 buf[0]= show_bits(gb, 8);
4540 for(i=1; i<256; i++){
4541 buf[i]= show_bits(gb, 16)&0xFF;
4542 if(buf[i]==0) break;
4547 /* divx detection */
4548 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
4550 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
4552 s->divx_version= ver;
4553 s->divx_build= build;
4554 s->divx_packed= e==3 && last=='p';
4555 if(s->picture_number==0){
4556 printf("This file was encoded with DivX%d Build%d", ver, build);
4564 /* ffmpeg detection */
4565 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4567 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
4569 if(strcmp(buf, "ffmpeg")==0){
4570 s->ffmpeg_version= 0x000406;
4571 s->lavc_build= 4600;
4575 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4576 s->lavc_build= build;
4577 if(s->picture_number==0)
4578 printf("This file was encoded with libavcodec build %d\n", build);
4581 /* xvid detection */
4582 e=sscanf(buf, "XviD%d", &build);
4584 s->xvid_build= build;
4585 if(s->picture_number==0)
4586 printf("This file was encoded with XviD build %d\n", build);
4589 //printf("User Data: %s\n", buf);
4593 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4594 int time_incr, time_increment;
4596 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
4597 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4598 printf("low_delay flag set, but shouldnt, clearing it\n");
4602 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4603 if(s->partitioned_frame)
4604 s->decode_mb= mpeg4_decode_partitioned_mb;
4606 s->decode_mb= ff_h263_decode_mb;
4608 if(s->time_increment_resolution==0){
4609 s->time_increment_resolution=1;
4610 // fprintf(stderr, "time_increment_resolution is illegal\n");
4613 while (get_bits1(gb) != 0)
4616 check_marker(gb, "before time_increment");
4618 if(s->picture_number==0 && (show_bits(gb, s->time_increment_bits+1)&1)==0){
4619 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4622 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
4623 if(show_bits(gb, s->time_increment_bits+1)&1) break;
4625 printf("my guess is %d bits ;)\n",s->time_increment_bits);
4628 time_increment= get_bits(gb, s->time_increment_bits);
4629 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4630 if(s->pict_type!=B_TYPE){
4631 s->last_time_base= s->time_base;
4632 s->time_base+= time_incr;
4633 s->time= s->time_base*s->time_increment_resolution + time_increment;
4634 if(s->workaround_bugs&FF_BUG_UMP4){
4635 if(s->time < s->last_non_b_time){
4636 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4638 s->time+= s->time_increment_resolution;
4641 s->pp_time= s->time - s->last_non_b_time;
4642 s->last_non_b_time= s->time;
4644 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4645 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4646 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4647 // printf("messed up order, seeking?, skiping current b frame\n");
4648 return FRAME_SKIPED;
4651 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4652 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4653 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4654 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4655 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4656 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
4657 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4660 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4661 if(s->avctx->debug&FF_DEBUG_PTS)
4662 printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4664 check_marker(gb, "before vop_coded");
4667 if (get_bits1(gb) != 1){
4668 printf("vop not coded\n");
4669 return FRAME_SKIPED;
4671 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4672 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4673 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4674 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4675 /* rounding type for motion estimation */
4676 s->no_rounding = get_bits1(gb);
4680 //FIXME reduced res stuff
4682 if (s->shape != RECT_SHAPE) {
4683 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4684 int width, height, hor_spat_ref, ver_spat_ref;
4686 width = get_bits(gb, 13);
4687 skip_bits1(gb); /* marker */
4688 height = get_bits(gb, 13);
4689 skip_bits1(gb); /* marker */
4690 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4691 skip_bits1(gb); /* marker */
4692 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4694 skip_bits1(gb); /* change_CR_disable */
4696 if (get_bits1(gb) != 0) {
4697 skip_bits(gb, 8); /* constant_alpha_value */
4700 //FIXME complexity estimation stuff
4702 if (s->shape != BIN_ONLY_SHAPE) {
4704 t=get_bits(gb, 3); /* intra dc VLC threshold */
4705 //printf("threshold %d\n", t);
4706 if(!s->progressive_sequence){
4707 s->top_field_first= get_bits1(gb);
4708 s->alternate_scan= get_bits1(gb);
4710 s->alternate_scan= 0;
4713 if(s->alternate_scan){
4714 ff_init_scantable(s, &s->inter_scantable , ff_alternate_vertical_scan);
4715 ff_init_scantable(s, &s->intra_scantable , ff_alternate_vertical_scan);
4716 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
4717 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4719 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
4720 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
4721 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4722 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
4725 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4726 mpeg4_decode_sprite_trajectory(s);
4727 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4728 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4731 if (s->shape != BIN_ONLY_SHAPE) {
4732 s->qscale = get_bits(gb, s->quant_precision);
4734 printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4735 return -1; // makes no sense to continue, as there is nothing left from the image then
4738 if (s->pict_type != I_TYPE) {
4739 s->f_code = get_bits(gb, 3); /* fcode_for */
4741 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4742 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4747 if (s->pict_type == B_TYPE) {
4748 s->b_code = get_bits(gb, 3);
4752 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4753 printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d\n",
4754 s->qscale, s->f_code, s->b_code,
4755 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4756 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
4757 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4758 s->sprite_warping_accuracy);
4761 if(!s->scalability){
4762 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4763 skip_bits1(gb); // vop shape coding type
4766 if(s->enhancement_type){
4767 int load_backward_shape= get_bits1(gb);
4768 if(load_backward_shape){
4769 printf("load backward shape isnt supported\n");
4772 skip_bits(gb, 2); //ref_select_code
4775 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4776 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4777 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4778 printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4782 s->picture_number++; // better than pic number==0 allways ;)
4784 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
4785 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4787 if(!(s->workaround_bugs&FF_BUG_EDGE)){
4788 s->h_edge_pos= s->width;
4789 s->v_edge_pos= s->height;
4795 * decode mpeg4 headers
4796 * @return <0 if no VOP found (or a damaged one)
4797 * FRAME_SKIPPED if a not coded VOP is found
4798 * 0 if a VOP is found
4800 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
4804 /* search next start code */
4808 v = get_bits(gb, 8);
4809 startcode = ((startcode << 8) | v) & 0xffffffff;
4811 if(get_bits_count(gb) >= gb->size_in_bits){
4812 if(gb->size_in_bits==8 && s->divx_version){
4813 printf("frame skip %d\n", gb->size_in_bits);
4814 return FRAME_SKIPED; //divx bug
4816 return -1; //end of stream
4819 if((startcode&0xFFFFFF00) != 0x100)
4820 continue; //no startcode
4822 if(s->avctx->debug&FF_DEBUG_STARTCODE){
4823 printf("startcode: %3X ", startcode);
4824 if (startcode<=0x11F) printf("Video Object Start");
4825 else if(startcode<=0x12F) printf("Video Object Layer Start");
4826 else if(startcode<=0x13F) printf("Reserved");
4827 else if(startcode<=0x15F) printf("FGS bp start");
4828 else if(startcode<=0x1AF) printf("Reserved");
4829 else if(startcode==0x1B0) printf("Visual Object Seq Start");
4830 else if(startcode==0x1B1) printf("Visual Object Seq End");
4831 else if(startcode==0x1B2) printf("User Data");
4832 else if(startcode==0x1B3) printf("Group of VOP start");
4833 else if(startcode==0x1B4) printf("Video Session Error");
4834 else if(startcode==0x1B5) printf("Visual Object Start");
4835 else if(startcode==0x1B6) printf("Video Object Plane start");
4836 else if(startcode==0x1B7) printf("slice start");
4837 else if(startcode==0x1B8) printf("extension start");
4838 else if(startcode==0x1B9) printf("fgs start");
4839 else if(startcode==0x1BA) printf("FBA Object start");
4840 else if(startcode==0x1BB) printf("FBA Object Plane start");
4841 else if(startcode==0x1BC) printf("Mesh Object start");
4842 else if(startcode==0x1BD) printf("Mesh Object Plane start");
4843 else if(startcode==0x1BE) printf("Still Textutre Object start");
4844 else if(startcode==0x1BF) printf("Textutre Spatial Layer start");
4845 else if(startcode==0x1C0) printf("Textutre SNR Layer start");
4846 else if(startcode==0x1C1) printf("Textutre Tile start");
4847 else if(startcode==0x1C2) printf("Textutre Shape Layer start");
4848 else if(startcode==0x1C3) printf("stuffing start");
4849 else if(startcode<=0x1C5) printf("reserved");
4850 else if(startcode<=0x1FF) printf("System start");
4851 printf(" at %d\n", get_bits_count(gb));
4856 decode_vol_header(s, gb);
4858 case USER_DATA_STARTCODE:
4859 decode_user_data(s, gb);
4862 mpeg4_decode_gop_header(s, gb);
4865 return decode_vop_header(s, gb);
4875 /* don't understand why they choose a different header ! */
4876 int intel_h263_decode_picture_header(MpegEncContext *s)
4880 /* picture header */
4881 if (get_bits(&s->gb, 22) != 0x20) {
4882 fprintf(stderr, "Bad picture start code\n");
4885 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4887 if (get_bits1(&s->gb) != 1) {
4888 fprintf(stderr, "Bad marker\n");
4889 return -1; /* marker */
4891 if (get_bits1(&s->gb) != 0) {
4892 fprintf(stderr, "Bad H263 id\n");
4893 return -1; /* h263 id */
4895 skip_bits1(&s->gb); /* split screen off */
4896 skip_bits1(&s->gb); /* camera off */
4897 skip_bits1(&s->gb); /* freeze picture release off */
4899 format = get_bits(&s->gb, 3);
4901 fprintf(stderr, "Intel H263 free format not supported\n");
4906 s->pict_type = I_TYPE + get_bits1(&s->gb);
4908 s->unrestricted_mv = get_bits1(&s->gb);
4909 s->h263_long_vectors = s->unrestricted_mv;
4911 if (get_bits1(&s->gb) != 0) {
4912 fprintf(stderr, "SAC not supported\n");
4913 return -1; /* SAC: off */
4915 if (get_bits1(&s->gb) != 0) {
4916 fprintf(stderr, "Advanced Prediction Mode not supported\n");
4917 return -1; /* advanced prediction mode: off */
4919 if (get_bits1(&s->gb) != 0) {
4920 fprintf(stderr, "PB frame mode no supported\n");
4921 return -1; /* PB frame mode */
4924 /* skip unknown header garbage */
4925 skip_bits(&s->gb, 41);
4927 s->qscale = get_bits(&s->gb, 5);
4928 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4931 while (get_bits1(&s->gb) != 0) {
4932 skip_bits(&s->gb, 8);
4936 s->y_dc_scale_table=
4937 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;