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 #ifdef CONFIG_ENCODERS
77 static uint8_t uni_DCtab_lum_len[512];
78 static uint8_t uni_DCtab_chrom_len[512];
79 static uint16_t uni_DCtab_lum_bits[512];
80 static uint16_t uni_DCtab_chrom_bits[512];
82 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
83 static uint8_t fcode_tab[MAX_MV*2+1];
84 static uint8_t umv_fcode_tab[MAX_MV*2+1];
86 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
87 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
88 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
89 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
90 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
91 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
92 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
105 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit
106 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
111 int h263_get_picture_format(int width, int height)
115 if (width == 128 && height == 96)
117 else if (width == 176 && height == 144)
119 else if (width == 352 && height == 288)
121 else if (width == 704 && height == 576)
123 else if (width == 1408 && height == 1152)
130 #ifdef CONFIG_ENCODERS
132 static void float_aspect_to_info(MpegEncContext * s, float aspect){
135 aspect*= s->height/(double)s->width;
136 //printf("%f\n", aspect);
138 if(aspect==0) aspect= 1.0;
140 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
142 //printf("%d %d\n", s->aspected_width, s->aspected_height);
144 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
145 s->aspect_ratio_info=i;
150 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
153 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
157 align_put_bits(&s->pb);
159 /* Update the pointer to last GOB */
160 s->ptr_lastgob = pbBufPtr(&s->pb);
163 put_bits(&s->pb, 22, 0x20); /* PSC */
164 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
165 s->avctx->frame_rate) & 0xff);
167 put_bits(&s->pb, 1, 1); /* marker */
168 put_bits(&s->pb, 1, 0); /* h263 id */
169 put_bits(&s->pb, 1, 0); /* split screen off */
170 put_bits(&s->pb, 1, 0); /* camera off */
171 put_bits(&s->pb, 1, 0); /* freeze picture release off */
173 format = h263_get_picture_format(s->width, s->height);
176 put_bits(&s->pb, 3, format);
177 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
178 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
179 of H.263v1 UMV implies to check the predicted MV after
180 calculation of the current MB to see if we're on the limits */
181 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
182 put_bits(&s->pb, 1, 0); /* SAC: off */
183 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
184 put_bits(&s->pb, 1, 0); /* not PB frame */
185 put_bits(&s->pb, 5, s->qscale);
186 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
189 /* H.263 Plus PTYPE */
190 put_bits(&s->pb, 3, 7);
191 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
193 put_bits(&s->pb,3,6); /* Custom Source Format */
195 put_bits(&s->pb, 3, format);
197 put_bits(&s->pb,1,0); /* Custom PCF: off */
198 s->umvplus = s->unrestricted_mv;
199 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
200 put_bits(&s->pb,1,0); /* SAC: off */
201 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
202 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
203 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
204 put_bits(&s->pb,1,0); /* Slice Structured: off */
205 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
206 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
207 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
208 put_bits(&s->pb,1,0); /* Modified Quantization: off */
209 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
210 put_bits(&s->pb,3,0); /* Reserved */
212 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
214 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
215 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
216 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
217 put_bits(&s->pb,2,0); /* Reserved */
218 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
220 /* This should be here if PLUSPTYPE */
221 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
224 /* Custom Picture Format (CPFMT) */
225 float_aspect_to_info(s, s->avctx->aspect_ratio);
227 put_bits(&s->pb,4,s->aspect_ratio_info);
228 put_bits(&s->pb,9,(s->width >> 2) - 1);
229 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
230 put_bits(&s->pb,9,(s->height >> 2));
231 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
233 put_bits(&s->pb, 8, s->aspected_width);
234 put_bits(&s->pb, 8, s->aspected_height);
238 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
240 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
241 put_bits(&s->pb,2,1); /* unlimited */
243 put_bits(&s->pb, 5, s->qscale);
246 put_bits(&s->pb, 1, 0); /* no PEI */
250 s->c_dc_scale_table= h263_aic_dc_scale_table;
253 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
258 * Encodes a group of blocks header.
260 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
262 align_put_bits(&s->pb);
263 flush_put_bits(&s->pb);
264 /* Call the RTP callback to send the last GOB */
265 if (s->rtp_callback) {
266 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
267 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
269 put_bits(&s->pb, 17, 1); /* GBSC */
270 s->gob_number = mb_line / s->gob_index;
271 put_bits(&s->pb, 5, s->gob_number); /* GN */
272 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
273 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
274 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
278 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
280 int score0=0, score1=0;
282 int8_t * const qscale_table= s->current_picture.qscale_table;
285 int16_t *ac_val, *ac_val1;
287 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
290 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
292 ac_val-= s->block_wrap[n]*16;
293 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
296 const int level= block[n][s->dsp.idct_permutation[i ]];
298 score1+= ABS(level - ac_val[i+8]);
299 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
303 /* different qscale, we must rescale */
305 const int level= block[n][s->dsp.idct_permutation[i ]];
307 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
308 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
313 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
314 /* left prediction */
316 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
319 const int level= block[n][s->dsp.idct_permutation[i<<3]];
321 score1+= ABS(level - ac_val[i]);
323 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
326 /* different qscale, we must rescale */
328 const int level= block[n][s->dsp.idct_permutation[i<<3]];
330 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
332 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
338 return score0 > score1 ? 1 : 0;
342 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
344 void ff_clean_h263_qscales(MpegEncContext *s){
346 int8_t * const qscale_table= s->current_picture.qscale_table;
348 for(i=1; i<s->mb_num; i++){
349 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
350 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
352 for(i=s->mb_num-2; i>=0; i--){
353 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
354 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
359 * modify mb_type & qscale so that encoding is acually possible in mpeg4
361 void ff_clean_mpeg4_qscales(MpegEncContext *s){
363 int8_t * const qscale_table= s->current_picture.qscale_table;
365 ff_clean_h263_qscales(s);
367 for(i=1; i<s->mb_num; i++){
368 int mb_xy= s->mb_index2xy[i];
370 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
371 s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
372 s->mb_type[mb_xy]|= MB_TYPE_INTER;
376 if(s->pict_type== B_TYPE){
378 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
379 for the actual adaptive quantization */
381 for(i=0; i<s->mb_num; i++){
382 int mb_xy= s->mb_index2xy[i];
383 odd += qscale_table[mb_xy]&1;
386 if(2*odd > s->mb_num) odd=1;
389 for(i=0; i<s->mb_num; i++){
390 int mb_xy= s->mb_index2xy[i];
391 if((qscale_table[mb_xy]&1) != odd)
392 qscale_table[mb_xy]++;
393 if(qscale_table[mb_xy] > 31)
394 qscale_table[mb_xy]= 31;
397 for(i=1; i<s->mb_num; i++){
398 int mb_xy= s->mb_index2xy[i];
399 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
400 s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
401 s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
407 #endif //CONFIG_ENCODERS
410 * @return the mb_type
412 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
413 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
414 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
415 int xy= s->block_index[0];
416 uint16_t time_pp= s->pp_time;
417 uint16_t time_pb= s->pb_time;
420 //FIXME avoid divides
422 if(IS_8X8(colocated_mb_type)){
423 s->mv_type = MV_TYPE_8X8;
425 xy= s->block_index[i];
426 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
427 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
428 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
429 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
430 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
431 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
433 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
434 } else if(IS_INTERLACED(colocated_mb_type)){
435 s->mv_type = MV_TYPE_FIELD;
437 if(s->top_field_first){
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 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
442 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
444 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
445 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
446 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
447 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
448 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
449 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
451 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
453 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;
454 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;
455 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]
456 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
457 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]
458 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
459 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
460 s->mv_type= MV_TYPE_16X16;
462 s->mv_type= MV_TYPE_8X8;
463 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
467 #ifdef CONFIG_ENCODERS
468 void mpeg4_encode_mb(MpegEncContext * s,
469 DCTELEM block[6][64],
470 int motion_x, int motion_y)
472 int cbpc, cbpy, pred_x, pred_y;
474 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
475 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
476 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
477 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
478 const int dquant_code[5]= {1,0,9,2,3};
480 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
484 for (i = 0; i < 6; i++) {
485 if (s->block_last_index[i] >= 0)
489 if(s->pict_type==B_TYPE){
490 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
491 int mb_type= mb_type_table[s->mv_dir];
497 s->last_mv[1][0][1]= 0;
500 assert(s->dquant>=-2 && s->dquant<=2);
501 assert((s->dquant&1)==0);
504 /* nothing to do if this MB was skiped in the next P Frame */
505 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
511 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
512 s->qscale -= s->dquant;
518 if ((cbp | motion_x | motion_y | mb_type) ==0) {
519 /* direct MB with MV={0,0} */
520 assert(s->dquant==0);
522 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
524 if(interleaved_stats){
532 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
533 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
534 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
535 if(cbp) put_bits(&s->pb, 6, cbp);
539 put_bits(&s->pb, 2, (s->dquant>>2)+3);
541 put_bits(&s->pb, 1, 0);
543 s->qscale -= s->dquant;
545 if(!s->progressive_sequence){
547 put_bits(&s->pb, 1, s->interlaced_dct);
548 if(mb_type) // not diect mode
549 put_bits(&s->pb, 1, 0); // no interlaced ME yet
552 if(interleaved_stats){
553 s->misc_bits+= get_bits_diff(s);
559 h263_encode_motion(s, motion_x, 1);
560 h263_encode_motion(s, motion_y, 1);
565 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
566 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
567 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
568 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
569 s->last_mv[0][0][0]= s->mv[0][0][0];
570 s->last_mv[0][0][1]= s->mv[0][0][1];
571 s->last_mv[1][0][0]= s->mv[1][0][0];
572 s->last_mv[1][0][1]= s->mv[1][0][1];
576 case 2: /* backward */
577 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
578 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
579 s->last_mv[1][0][0]= motion_x;
580 s->last_mv[1][0][1]= motion_y;
583 case 3: /* forward */
584 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
585 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
586 s->last_mv[0][0][0]= motion_x;
587 s->last_mv[0][0][1]= motion_y;
591 printf("unknown mb type\n");
595 if(interleaved_stats){
596 s->mv_bits+= get_bits_diff(s);
599 /* encode each block */
600 for (i = 0; i < 6; i++) {
601 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
604 if(interleaved_stats){
605 s->p_tex_bits+= get_bits_diff(s);
607 }else{ /* s->pict_type==B_TYPE */
608 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
609 /* check if the B frames can skip it too, as we must skip it if we skip here
610 why didnt they just compress the skip-mb bits instead of reusing them ?! */
611 if(s->max_b_frames>0){
618 if(x+16 > s->width) x= s->width-16;
619 if(y+16 > s->height) y= s->height-16;
621 offset= x + y*s->linesize;
622 p_pic= s->new_picture.data[0] + offset;
625 for(i=0; i<s->max_b_frames; i++){
628 Picture *pic= s->reordered_input_picture[i+1];
630 if(pic==NULL || pic->pict_type!=B_TYPE) break;
632 b_pic= pic->data[0] + offset + 16; //FIXME +16
633 diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
634 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
643 /* skip macroblock */
644 put_bits(&s->pb, 1, 1);
646 if(interleaved_stats){
656 put_bits(&s->pb, 1, 0); /* mb coded */
657 if(s->mv_type==MV_TYPE_16X16){
659 if(s->dquant) cbpc+= 8;
661 inter_MCBPC_bits[cbpc],
662 inter_MCBPC_code[cbpc]);
666 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
668 put_bits(pb2, 2, dquant_code[s->dquant+2]);
670 if(!s->progressive_sequence){
672 put_bits(pb2, 1, s->interlaced_dct);
673 put_bits(pb2, 1, 0); // no interlaced ME yet
676 if(interleaved_stats){
677 s->misc_bits+= get_bits_diff(s);
680 /* motion vectors: 16x16 mode */
681 h263_pred_motion(s, 0, &pred_x, &pred_y);
683 h263_encode_motion(s, motion_x - pred_x, s->f_code);
684 h263_encode_motion(s, motion_y - pred_y, s->f_code);
688 inter_MCBPC_bits[cbpc],
689 inter_MCBPC_code[cbpc]);
692 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
694 if(!s->progressive_sequence){
696 put_bits(pb2, 1, s->interlaced_dct);
699 if(interleaved_stats){
700 s->misc_bits+= get_bits_diff(s);
704 /* motion vectors: 8x8 mode*/
705 h263_pred_motion(s, i, &pred_x, &pred_y);
707 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
708 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
712 if(interleaved_stats){
713 s->mv_bits+= get_bits_diff(s);
716 /* encode each block */
717 for (i = 0; i < 6; i++) {
718 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
721 if(interleaved_stats){
722 s->p_tex_bits+= get_bits_diff(s);
728 int dc_diff[6]; //dc values with the dc prediction subtracted
729 int dir[6]; //prediction direction
730 int zigzag_last_index[6];
731 uint8_t *scan_table[6];
735 const int level= block[i][0];
738 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
740 *dc_ptr = level * s->y_dc_scale;
742 *dc_ptr = level * s->c_dc_scale;
746 s->ac_pred= decide_ac_pred(s, block, dir);
753 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
754 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
755 else st = s->intra_h_scantable.permutated; /* top */
757 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
758 if(block[i][st[last_index]]) break;
759 zigzag_last_index[i]= s->block_last_index[i];
760 s->block_last_index[i]= last_index;
765 scan_table[i]= s->intra_scantable.permutated;
770 for (i = 0; i < 6; i++) {
771 if (s->block_last_index[i] >= 1)
776 if (s->pict_type == I_TYPE) {
777 if(s->dquant) cbpc+=4;
779 intra_MCBPC_bits[cbpc],
780 intra_MCBPC_code[cbpc]);
782 if(s->dquant) cbpc+=8;
783 put_bits(&s->pb, 1, 0); /* mb coded */
785 inter_MCBPC_bits[cbpc + 4],
786 inter_MCBPC_code[cbpc + 4]);
788 put_bits(pb2, 1, s->ac_pred);
790 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
792 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
794 if(!s->progressive_sequence){
795 put_bits(dc_pb, 1, s->interlaced_dct);
798 if(interleaved_stats){
799 s->misc_bits+= get_bits_diff(s);
802 /* encode each block */
803 for (i = 0; i < 6; i++) {
804 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
807 if(interleaved_stats){
808 s->i_tex_bits+= get_bits_diff(s);
812 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
818 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
822 block[i][s->dsp.idct_permutation[j ]]= ac_val[j+8];
825 block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j ];
827 s->block_last_index[i]= zigzag_last_index[i];
833 void h263_encode_mb(MpegEncContext * s,
834 DCTELEM block[6][64],
835 int motion_x, int motion_y)
837 int cbpc, cbpy, i, cbp, pred_x, pred_y;
839 int16_t rec_intradc[6];
841 const int dquant_code[5]= {1,0,9,2,3};
843 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
847 for (i = 0; i < 6; i++) {
848 if (s->block_last_index[i] >= 0)
851 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
852 /* skip macroblock */
853 put_bits(&s->pb, 1, 1);
856 put_bits(&s->pb, 1, 0); /* mb coded */
858 if(s->dquant) cbpc+= 8;
860 inter_MCBPC_bits[cbpc],
861 inter_MCBPC_code[cbpc]);
864 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
866 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
868 /* motion vectors: 16x16 mode only now */
869 h263_pred_motion(s, 0, &pred_x, &pred_y);
872 h263_encode_motion(s, motion_x - pred_x, s->f_code);
873 h263_encode_motion(s, motion_y - pred_y, s->f_code);
876 h263p_encode_umotion(s, motion_x - pred_x);
877 h263p_encode_umotion(s, motion_y - pred_y);
878 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
879 /* To prevent Start Code emulation */
880 put_bits(&s->pb,1,1);
883 int li = s->h263_aic ? 0 : 1;
888 if (s->h263_aic && s->mb_intra) {
889 int16_t level = block[i][0];
891 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
895 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
897 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
899 /* AIC can change CBP */
900 if (level == 0 && s->block_last_index[i] == 0)
901 s->block_last_index[i] = -1;
902 else if (level < -127)
904 else if (level > 127)
909 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
912 //if ((rec_intradc[i] % 2) == 0)
915 if (rec_intradc[i] < 0)
917 else if (rec_intradc[i] > 2047)
918 rec_intradc[i] = 2047;
920 /* Update AC/DC tables */
921 *dc_ptr[i] = rec_intradc[i];
924 if (s->block_last_index[i] >= li)
929 if (s->pict_type == I_TYPE) {
930 if(s->dquant) cbpc+=4;
932 intra_MCBPC_bits[cbpc],
933 intra_MCBPC_code[cbpc]);
935 if(s->dquant) cbpc+=8;
936 put_bits(&s->pb, 1, 0); /* mb coded */
938 inter_MCBPC_bits[cbpc + 4],
939 inter_MCBPC_code[cbpc + 4]);
942 /* XXX: currently, we do not try to use ac prediction */
943 put_bits(&s->pb, 1, 0); /* no AC prediction */
946 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
948 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
952 /* encode each block */
953 h263_encode_block(s, block[i], i);
955 /* Update INTRADC for decoding */
956 if (s->h263_aic && s->mb_intra) {
957 block[i][0] = rec_intradc[i];
964 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
966 int x, y, wrap, a, c, pred_dc, scale;
967 int16_t *dc_val, *ac_val;
969 /* find prediction */
971 x = 2 * s->mb_x + 1 + (n & 1);
972 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
973 wrap = s->mb_width * 2 + 2;
974 dc_val = s->dc_val[0];
975 ac_val = s->ac_val[0][0];
976 scale = s->y_dc_scale;
980 wrap = s->mb_width + 2;
981 dc_val = s->dc_val[n - 4 + 1];
982 ac_val = s->ac_val[n - 4 + 1][0];
983 scale = s->c_dc_scale;
988 a = dc_val[(x - 1) + (y) * wrap];
989 c = dc_val[(x) + (y - 1) * wrap];
991 /* No prediction outside GOB boundary */
992 if (s->first_slice_line && ((n < 2) || (n > 3)))
995 /* just DC prediction */
996 if (a != 1024 && c != 1024)
997 pred_dc = (a + c) >> 1;
1003 /* we assume pred is positive */
1004 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1005 *dc_val_ptr = &dc_val[x + y * wrap];
1009 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1011 int x, y, wrap, a, c, pred_dc, scale, i;
1012 int16_t *dc_val, *ac_val, *ac_val1;
1014 /* find prediction */
1016 x = 2 * s->mb_x + 1 + (n & 1);
1017 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1018 wrap = s->mb_width * 2 + 2;
1019 dc_val = s->dc_val[0];
1020 ac_val = s->ac_val[0][0];
1021 scale = s->y_dc_scale;
1025 wrap = s->mb_width + 2;
1026 dc_val = s->dc_val[n - 4 + 1];
1027 ac_val = s->ac_val[n - 4 + 1][0];
1028 scale = s->c_dc_scale;
1031 ac_val += ((y) * wrap + (x)) * 16;
1037 a = dc_val[(x - 1) + (y) * wrap];
1038 c = dc_val[(x) + (y - 1) * wrap];
1040 /* No prediction outside GOB boundary */
1041 if (s->first_slice_line && ((n < 2) || (n > 3)))
1045 if (s->h263_aic_dir) {
1046 /* left prediction */
1050 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1055 /* top prediction */
1057 ac_val -= 16 * wrap;
1059 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1065 /* just DC prediction */
1066 if (a != 1024 && c != 1024)
1067 pred_dc = (a + c) >> 1;
1074 /* we assume pred is positive */
1075 block[0]=block[0]*scale + pred_dc;
1079 else if (!(block[0] & 1))
1082 /* Update AC/DC tables */
1083 dc_val[(x) + (y) * wrap] = block[0];
1087 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1090 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1093 int16_t *h263_pred_motion(MpegEncContext * s, int block,
1097 int16_t *A, *B, *C, *mot_val;
1098 static const int off[4]= {2, 1, 1, -1};
1100 wrap = s->block_wrap[0];
1101 xy = s->block_index[block];
1103 mot_val = s->motion_val[xy];
1105 A = s->motion_val[xy - 1];
1106 /* special case for first (slice) line */
1107 if (s->first_slice_line && block<3) {
1108 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1109 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1110 if(block==0){ //most common case
1111 if(s->mb_x == s->resync_mb_x){ //rare
1113 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1114 C = s->motion_val[xy + off[block] - wrap];
1119 *px = mid_pred(A[0], 0, C[0]);
1120 *py = mid_pred(A[1], 0, C[1]);
1127 if(s->mb_x + 1 == s->resync_mb_x){ //rare
1128 C = s->motion_val[xy + off[block] - wrap];
1129 *px = mid_pred(A[0], 0, C[0]);
1130 *py = mid_pred(A[1], 0, C[1]);
1135 }else{ /* block==2*/
1136 B = s->motion_val[xy - wrap];
1137 C = s->motion_val[xy + off[block] - wrap];
1138 if(s->mb_x == s->resync_mb_x) //rare
1141 *px = mid_pred(A[0], B[0], C[0]);
1142 *py = mid_pred(A[1], B[1], C[1]);
1145 B = s->motion_val[xy - wrap];
1146 C = s->motion_val[xy + off[block] - wrap];
1147 *px = mid_pred(A[0], B[0], C[0]);
1148 *py = mid_pred(A[1], B[1], C[1]);
1153 #ifdef CONFIG_ENCODERS
1154 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1156 int range, l, bit_size, sign, code, bits;
1161 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1163 bit_size = f_code - 1;
1164 range = 1 << bit_size;
1165 /* modulo encoding */
1172 val= (val^sign)-sign;
1177 } else if (val >= l) {
1181 assert(val>=-l && val<l);
1191 code = (val >> bit_size) + 1;
1192 bits = val & (range - 1);
1194 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1196 put_bits(&s->pb, bit_size, bits);
1202 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1203 static void h263p_encode_umotion(MpegEncContext * s, int val)
1213 put_bits(&s->pb, 1, 1);
1215 put_bits(&s->pb, 3, 0);
1217 put_bits(&s->pb, 3, 2);
1220 sval = ((val < 0) ? (short)(-val):(short)val);
1223 while (temp_val != 0) {
1224 temp_val = temp_val >> 1;
1230 tcode = (sval & (1 << (i-1))) >> (i-1);
1231 tcode = (tcode << 1) | 1;
1232 code = (code << 2) | tcode;
1235 code = ((code << 1) | (val < 0)) << 1;
1236 put_bits(&s->pb, (2*n_bits)+1, code);
1237 //printf("\nVal = %d\tCode = %d", sval, code);
1241 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1246 if(mv_penalty==NULL)
1247 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1249 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1250 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1253 if(mv==0) len= mvtab[0][1];
1255 int val, bit_size, range, code;
1257 bit_size = s->f_code - 1;
1258 range = 1 << bit_size;
1264 code = (val >> bit_size) + 1;
1266 len= mvtab[code][1] + 1 + bit_size;
1268 len= mvtab[32][1] + 2 + bit_size;
1272 mv_penalty[f_code][mv+MAX_MV]= len;
1276 for(f_code=MAX_FCODE; f_code>0; f_code--){
1277 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1278 fcode_tab[mv+MAX_MV]= f_code;
1282 for(mv=0; mv<MAX_MV*2+1; mv++){
1283 umv_fcode_tab[mv]= 1;
1288 #ifdef CONFIG_ENCODERS
1290 static void init_uni_dc_tab(void)
1292 int level, uni_code, uni_len;
1294 for(level=-256; level<256; level++){
1296 /* find number of bits */
1305 l= (-level) ^ ((1 << size) - 1);
1310 uni_code= DCtab_lum[size][0];
1311 uni_len = DCtab_lum[size][1];
1314 uni_code<<=size; uni_code|=l;
1317 uni_code<<=1; uni_code|=1;
1321 uni_DCtab_lum_bits[level+256]= uni_code;
1322 uni_DCtab_lum_len [level+256]= uni_len;
1325 uni_code= DCtab_chrom[size][0];
1326 uni_len = DCtab_chrom[size][1];
1329 uni_code<<=size; uni_code|=l;
1332 uni_code<<=1; uni_code|=1;
1336 uni_DCtab_chrom_bits[level+256]= uni_code;
1337 uni_DCtab_chrom_len [level+256]= uni_len;
1342 #endif //CONFIG_ENCODERS
1344 #ifdef CONFIG_ENCODERS
1345 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1346 int slevel, run, last;
1348 assert(MAX_LEVEL >= 64);
1349 assert(MAX_RUN >= 63);
1351 for(slevel=-64; slevel<64; slevel++){
1352 if(slevel==0) continue;
1353 for(run=0; run<64; run++){
1354 for(last=0; last<=1; last++){
1355 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1356 int level= slevel < 0 ? -slevel : slevel;
1357 int sign= slevel < 0 ? 1 : 0;
1358 int bits, len, code;
1361 len_tab[index]= 100;
1364 code= get_rl_index(rl, last, run, level);
1365 bits= rl->table_vlc[code][0];
1366 len= rl->table_vlc[code][1];
1367 bits=bits*2+sign; len++;
1369 if(code!=rl->n && len < len_tab[index]){
1370 bits_tab[index]= bits;
1371 len_tab [index]= len;
1375 bits= rl->table_vlc[rl->n][0];
1376 len= rl->table_vlc[rl->n][1];
1377 bits=bits*2; len++; //esc1
1378 level1= level - rl->max_level[last][run];
1380 code= get_rl_index(rl, last, run, level1);
1381 bits<<= rl->table_vlc[code][1];
1382 len += rl->table_vlc[code][1];
1383 bits += rl->table_vlc[code][0];
1384 bits=bits*2+sign; len++;
1386 if(code!=rl->n && len < len_tab[index]){
1387 bits_tab[index]= bits;
1388 len_tab [index]= len;
1394 bits= rl->table_vlc[rl->n][0];
1395 len= rl->table_vlc[rl->n][1];
1396 bits=bits*4+2; len+=2; //esc2
1397 run1 = run - rl->max_run[last][level] - 1;
1399 code= get_rl_index(rl, last, run1, level);
1400 bits<<= rl->table_vlc[code][1];
1401 len += rl->table_vlc[code][1];
1402 bits += rl->table_vlc[code][0];
1403 bits=bits*2+sign; len++;
1405 if(code!=rl->n && len < len_tab[index]){
1406 bits_tab[index]= bits;
1407 len_tab [index]= len;
1412 bits= rl->table_vlc[rl->n][0];
1413 len = rl->table_vlc[rl->n][1];
1414 bits=bits*4+3; len+=2; //esc3
1415 bits=bits*2+last; len++;
1416 bits=bits*64+run; len+=6;
1417 bits=bits*2+1; len++; //marker
1418 bits=bits*4096+(slevel&0xfff); len+=12;
1419 bits=bits*2+1; len++; //marker
1421 if(len < len_tab[index]){
1422 bits_tab[index]= bits;
1423 len_tab [index]= len;
1430 void h263_encode_init(MpegEncContext *s)
1432 static int done = 0;
1441 init_rl(&rl_intra_aic);
1443 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1444 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1446 init_mv_penalty_and_fcode(s);
1448 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1450 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1451 switch(s->codec_id){
1452 case CODEC_ID_MPEG4:
1453 s->fcode_tab= fcode_tab;
1454 s->min_qcoeff= -2048;
1455 s->max_qcoeff= 2047;
1456 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
1457 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1458 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
1459 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1460 s->luma_dc_vlc_length= uni_DCtab_lum_len;
1461 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1462 s->ac_esc_length= 7+2+1+6+1+12+1;
1464 case CODEC_ID_H263P:
1465 s->fcode_tab= umv_fcode_tab;
1466 s->min_qcoeff= -127;
1469 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1470 default: //nothing needed default table allready set in mpegvideo.c
1471 s->min_qcoeff= -127;
1473 s->y_dc_scale_table=
1474 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1479 * encodes a 8x8 block.
1480 * @param block the 8x8 block
1481 * @param n block index (0-3 are luma, 4-5 are chroma)
1483 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1485 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1489 if (s->mb_intra && !s->h263_aic) {
1492 /* 255 cannot be represented, so we clamp */
1497 /* 0 cannot be represented also */
1498 else if (level < 1) {
1502 if (level == 128) //FIXME check rv10
1503 put_bits(&s->pb, 8, 0xff);
1505 put_bits(&s->pb, 8, level & 0xff);
1509 if (s->h263_aic && s->mb_intra)
1514 last_index = s->block_last_index[n];
1515 last_non_zero = i - 1;
1516 for (; i <= last_index; i++) {
1517 j = s->intra_scantable.permutated[i];
1520 run = i - last_non_zero - 1;
1521 last = (i == last_index);
1528 code = get_rl_index(rl, last, run, level);
1529 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1530 if (code == rl->n) {
1531 put_bits(&s->pb, 1, last);
1532 put_bits(&s->pb, 6, run);
1534 assert(slevel != 0);
1536 if(slevel < 128 && slevel > -128)
1537 put_bits(&s->pb, 8, slevel & 0xff);
1539 put_bits(&s->pb, 8, 128);
1540 put_bits(&s->pb, 5, slevel & 0x1f);
1541 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1544 put_bits(&s->pb, 1, sign);
1552 #ifdef CONFIG_ENCODERS
1554 /***************************************************/
1556 * add mpeg4 stuffing bits (01...1)
1558 void ff_mpeg4_stuffing(PutBitContext * pbc)
1561 put_bits(pbc, 1, 0);
1562 length= (-get_bit_count(pbc))&7;
1563 if(length) put_bits(pbc, length, (1<<length)-1);
1566 /* must be called before writing the header */
1567 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1568 int time_div, time_mod;
1570 if(s->pict_type==I_TYPE){ //we will encode a vol header
1572 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1574 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1577 if(s->current_picture.pts)
1578 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1580 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1581 time_div= s->time/s->time_increment_resolution;
1582 time_mod= s->time%s->time_increment_resolution;
1584 if(s->pict_type==B_TYPE){
1585 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1587 s->last_time_base= s->time_base;
1588 s->time_base= time_div;
1589 s->pp_time= s->time - s->last_non_b_time;
1590 s->last_non_b_time= s->time;
1594 static void mpeg4_encode_gop_header(MpegEncContext * s){
1595 int hours, minutes, seconds;
1597 put_bits(&s->pb, 16, 0);
1598 put_bits(&s->pb, 16, GOP_STARTCODE);
1600 seconds= s->time/s->time_increment_resolution;
1601 minutes= seconds/60; seconds %= 60;
1602 hours= minutes/60; minutes %= 60;
1605 put_bits(&s->pb, 5, hours);
1606 put_bits(&s->pb, 6, minutes);
1607 put_bits(&s->pb, 1, 1);
1608 put_bits(&s->pb, 6, seconds);
1610 put_bits(&s->pb, 1, 0); //closed gov == NO
1611 put_bits(&s->pb, 1, 0); //broken link == NO
1613 ff_mpeg4_stuffing(&s->pb);
1616 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1617 int profile_and_level_indication;
1620 if(s->max_b_frames || s->quarter_sample){
1621 profile_and_level_indication= 0xF1; // adv simple level 1
1624 profile_and_level_indication= 0x01; // simple level 1
1629 put_bits(&s->pb, 16, 0);
1630 put_bits(&s->pb, 16, VOS_STARTCODE);
1632 put_bits(&s->pb, 8, profile_and_level_indication);
1634 put_bits(&s->pb, 16, 0);
1635 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1637 put_bits(&s->pb, 1, 1);
1638 put_bits(&s->pb, 4, vo_ver_id);
1639 put_bits(&s->pb, 3, 1); //priority
1641 put_bits(&s->pb, 4, 1); //visual obj type== video obj
1643 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1645 ff_mpeg4_stuffing(&s->pb);
1648 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1652 if(s->max_b_frames || s->quarter_sample){
1654 s->vo_type= ADV_SIMPLE_VO_TYPE;
1657 s->vo_type= SIMPLE_VO_TYPE;
1660 put_bits(&s->pb, 16, 0);
1661 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
1662 put_bits(&s->pb, 16, 0);
1663 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
1665 put_bits(&s->pb, 1, 0); /* random access vol */
1666 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
1667 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1668 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1669 put_bits(&s->pb, 3, 1); /* is obj layer priority */
1671 float_aspect_to_info(s, s->avctx->aspect_ratio);
1673 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1674 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1676 put_bits(&s->pb, 8, s->aspected_width);
1677 put_bits(&s->pb, 8, s->aspected_height);
1681 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1682 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1683 put_bits(&s->pb, 1, s->low_delay);
1684 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1686 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
1689 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1690 put_bits(&s->pb, 1, 1); /* marker bit */
1692 put_bits(&s->pb, 16, s->time_increment_resolution);
1693 if (s->time_increment_bits < 1)
1694 s->time_increment_bits = 1;
1695 put_bits(&s->pb, 1, 1); /* marker bit */
1696 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1697 put_bits(&s->pb, 1, 1); /* marker bit */
1698 put_bits(&s->pb, 13, s->width); /* vol width */
1699 put_bits(&s->pb, 1, 1); /* marker bit */
1700 put_bits(&s->pb, 13, s->height); /* vol height */
1701 put_bits(&s->pb, 1, 1); /* marker bit */
1702 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1703 put_bits(&s->pb, 1, 1); /* obmc disable */
1704 if (vo_ver_id == 1) {
1705 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
1707 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
1710 s->quant_precision=5;
1711 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
1712 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1713 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1716 put_bits(&s->pb, 1, s->quarter_sample);
1717 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1718 s->resync_marker= s->rtp_mode;
1719 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1720 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1721 if(s->data_partitioning){
1722 put_bits(&s->pb, 1, 0); /* no rvlc */
1725 if (vo_ver_id != 1){
1726 put_bits(&s->pb, 1, 0); /* newpred */
1727 put_bits(&s->pb, 1, 0); /* reduced res vop */
1729 put_bits(&s->pb, 1, 0); /* scalability */
1731 ff_mpeg4_stuffing(&s->pb);
1734 if(!(s->flags & CODEC_FLAG_BITEXACT)){
1735 put_bits(&s->pb, 16, 0);
1736 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1737 put_string(&s->pb, LIBAVCODEC_IDENT);
1738 ff_mpeg4_stuffing(&s->pb);
1742 /* write mpeg4 VOP header */
1743 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1746 int time_div, time_mod;
1748 if(s->pict_type==I_TYPE){
1749 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1750 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
1751 mpeg4_encode_visual_object_header(s);
1752 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
1753 mpeg4_encode_vol_header(s, 0, 0);
1755 mpeg4_encode_gop_header(s);
1758 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1760 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1762 put_bits(&s->pb, 16, 0); /* vop header */
1763 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
1764 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1766 time_div= s->time/s->time_increment_resolution;
1767 time_mod= s->time%s->time_increment_resolution;
1768 time_incr= time_div - s->last_time_base;
1770 put_bits(&s->pb, 1, 1);
1772 put_bits(&s->pb, 1, 0);
1774 put_bits(&s->pb, 1, 1); /* marker */
1775 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1776 put_bits(&s->pb, 1, 1); /* marker */
1777 put_bits(&s->pb, 1, 1); /* vop coded */
1778 if ( s->pict_type == P_TYPE
1779 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1780 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1782 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1783 if(!s->progressive_sequence){
1784 put_bits(&s->pb, 1, s->top_field_first);
1785 put_bits(&s->pb, 1, s->alternate_scan);
1787 //FIXME sprite stuff
1789 put_bits(&s->pb, 5, s->qscale);
1791 if (s->pict_type != I_TYPE)
1792 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1793 if (s->pict_type == B_TYPE)
1794 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1795 // printf("****frame %d\n", picture_number);
1797 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1798 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1799 s->h_edge_pos= s->width;
1800 s->v_edge_pos= s->height;
1803 #endif //CONFIG_ENCODERS
1806 * change qscale by given dquant and update qscale dependant variables.
1808 static void change_qscale(MpegEncContext * s, int dquant)
1810 s->qscale += dquant;
1814 else if (s->qscale > 31)
1817 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1818 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1823 * @param n block index (0-3 are luma, 4-5 are chroma)
1824 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1825 * @param dir_ptr pointer to an integer where the prediction direction will be stored
1826 * @return the quantized predicted dc
1828 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
1830 int a, b, c, wrap, pred, scale;
1833 /* find prediction */
1835 scale = s->y_dc_scale;
1837 scale = s->c_dc_scale;
1842 wrap= s->block_wrap[n];
1843 dc_val = s->dc_val[0] + s->block_index[n];
1849 b = dc_val[ - 1 - wrap];
1850 c = dc_val[ - wrap];
1852 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1853 if(s->first_slice_line && n!=3){
1855 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1857 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1858 if(n==0 || n==4 || n==5)
1862 if (abs(a - b) < abs(b - c)) {
1864 *dir_ptr = 1; /* top */
1867 *dir_ptr = 0; /* left */
1869 /* we assume pred is positive */
1870 pred = FASTDIV((pred + (scale >> 1)), scale);
1872 /* prepare address for prediction update */
1873 *dc_val_ptr = &dc_val[0];
1880 * @param n block index (0-3 are luma, 4-5 are chroma)
1881 * @param dir the ac prediction direction
1883 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1887 int16_t *ac_val, *ac_val1;
1888 int8_t * const qscale_table= s->current_picture.qscale_table;
1890 /* find prediction */
1891 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1895 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
1896 /* left prediction */
1899 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1902 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1905 /* different qscale, we must rescale */
1907 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1911 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
1912 /* top prediction */
1913 ac_val -= 16 * s->block_wrap[n];
1915 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1918 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
1921 /* different qscale, we must rescale */
1923 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1930 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1934 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1938 #ifdef CONFIG_ENCODERS
1940 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
1945 int8_t * const qscale_table= s->current_picture.qscale_table;
1947 /* find prediction */
1948 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1951 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
1952 /* left prediction */
1954 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
1957 block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
1960 /* different qscale, we must rescale */
1962 block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
1966 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
1967 /* top prediction */
1968 ac_val -= 16 * s->block_wrap[n];
1969 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
1972 block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
1975 /* different qscale, we must rescale */
1977 block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1984 * encodes the dc value.
1985 * @param n block index (0-3 are luma, 4-5 are chroma)
1987 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1990 // if(level<-255 || level>255) printf("dc overflow\n");
1994 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
1997 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2001 /* find number of bits */
2011 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2014 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2017 /* encode remaining bits */
2020 level = (-level) ^ ((1 << size) - 1);
2021 put_bits(&s->pb, size, level);
2023 put_bits(&s->pb, 1, 1);
2029 * encodes a 8x8 block
2030 * @param n block index (0-3 are luma, 4-5 are chroma)
2032 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2033 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2035 int i, last_non_zero;
2036 #if 0 //variables for the outcommented version
2037 int code, sign, last;
2042 const int last_index = s->block_last_index[n];
2044 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2045 /* mpeg4 based DC predictor */
2046 mpeg4_encode_dc(dc_pb, intra_dc, n);
2047 if(last_index<1) return;
2050 bits_tab= uni_mpeg4_intra_rl_bits;
2051 len_tab = uni_mpeg4_intra_rl_len;
2053 if(last_index<0) return;
2056 bits_tab= uni_mpeg4_inter_rl_bits;
2057 len_tab = uni_mpeg4_inter_rl_len;
2061 last_non_zero = i - 1;
2063 for (; i < last_index; i++) {
2064 int level = block[ scan_table[i] ];
2066 int run = i - last_non_zero - 1;
2068 if((level&(~127)) == 0){
2069 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2070 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2072 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);
2077 /*if(i<=last_index)*/{
2078 int level = block[ scan_table[i] ];
2079 int run = i - last_non_zero - 1;
2081 if((level&(~127)) == 0){
2082 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2083 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2085 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);
2089 for (; i <= last_index; i++) {
2090 const int slevel = block[ scan_table[i] ];
2093 int run = i - last_non_zero - 1;
2094 last = (i == last_index);
2101 code = get_rl_index(rl, last, run, level);
2102 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2103 if (code == rl->n) {
2105 level1 = level - rl->max_level[last][run];
2108 code = get_rl_index(rl, last, run, level1);
2109 if (code == rl->n) {
2111 put_bits(ac_pb, 1, 1);
2112 if (level > MAX_LEVEL)
2114 run1 = run - rl->max_run[last][level] - 1;
2117 code = get_rl_index(rl, last, run1, level);
2118 if (code == rl->n) {
2121 put_bits(ac_pb, 1, 1);
2122 put_bits(ac_pb, 1, last);
2123 put_bits(ac_pb, 6, run);
2124 put_bits(ac_pb, 1, 1);
2125 put_bits(ac_pb, 12, slevel & 0xfff);
2126 put_bits(ac_pb, 1, 1);
2129 put_bits(ac_pb, 1, 0);
2130 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2131 put_bits(ac_pb, 1, sign);
2135 put_bits(ac_pb, 1, 0);
2136 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2137 put_bits(ac_pb, 1, sign);
2140 put_bits(ac_pb, 1, sign);
2148 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2149 uint8_t *scan_table)
2151 int i, last_non_zero;
2154 const int last_index = s->block_last_index[n];
2157 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2158 /* mpeg4 based DC predictor */
2159 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2160 if(last_index<1) return len;
2163 len_tab = uni_mpeg4_intra_rl_len;
2165 if(last_index<0) return 0;
2168 len_tab = uni_mpeg4_inter_rl_len;
2172 last_non_zero = i - 1;
2173 for (; i < last_index; i++) {
2174 int level = block[ scan_table[i] ];
2176 int run = i - last_non_zero - 1;
2178 if((level&(~127)) == 0){
2179 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2180 len += len_tab[index];
2182 len += 7+2+1+6+1+12+1;
2187 /*if(i<=last_index)*/{
2188 int level = block[ scan_table[i] ];
2189 int run = i - last_non_zero - 1;
2191 if((level&(~127)) == 0){
2192 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2193 len += len_tab[index];
2195 len += 7+2+1+6+1+12+1;
2205 /***********************************************/
2208 static VLC intra_MCBPC_vlc;
2209 static VLC inter_MCBPC_vlc;
2210 static VLC cbpy_vlc;
2212 static VLC dc_lum, dc_chrom;
2213 static VLC sprite_trajectory;
2214 static VLC mb_type_b_vlc;
2216 void init_vlc_rl(RLTable *rl)
2220 init_vlc(&rl->vlc, 9, rl->n + 1,
2221 &rl->table_vlc[0][1], 4, 2,
2222 &rl->table_vlc[0][0], 4, 2);
2225 for(q=0; q<32; q++){
2234 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2235 for(i=0; i<rl->vlc.table_size; i++){
2236 int code= rl->vlc.table[i][0];
2237 int len = rl->vlc.table[i][1];
2240 if(len==0){ // illegal code
2243 }else if(len<0){ //more bits needed
2247 if(code==rl->n){ //esc
2251 run= rl->table_run [code] + 1;
2252 level= rl->table_level[code] * qmul + qadd;
2253 if(code >= rl->last) run+=192;
2256 rl->rl_vlc[q][i].len= len;
2257 rl->rl_vlc[q][i].level= level;
2258 rl->rl_vlc[q][i].run= run;
2265 /* XXX: find a better solution to handle static init */
2266 void h263_decode_init_vlc(MpegEncContext *s)
2268 static int done = 0;
2273 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
2274 intra_MCBPC_bits, 1, 1,
2275 intra_MCBPC_code, 1, 1);
2276 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
2277 inter_MCBPC_bits, 1, 1,
2278 inter_MCBPC_code, 1, 1);
2279 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2280 &cbpy_tab[0][1], 2, 1,
2281 &cbpy_tab[0][0], 2, 1);
2282 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2284 &mvtab[0][0], 2, 1);
2287 init_rl(&rvlc_rl_inter);
2288 init_rl(&rvlc_rl_intra);
2289 init_rl(&rl_intra_aic);
2290 init_vlc_rl(&rl_inter);
2291 init_vlc_rl(&rl_intra);
2292 init_vlc_rl(&rvlc_rl_inter);
2293 init_vlc_rl(&rvlc_rl_intra);
2294 init_vlc_rl(&rl_intra_aic);
2295 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2296 &DCtab_lum[0][1], 2, 1,
2297 &DCtab_lum[0][0], 2, 1);
2298 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2299 &DCtab_chrom[0][1], 2, 1,
2300 &DCtab_chrom[0][0], 2, 1);
2301 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2302 &sprite_trajectory_tab[0][1], 4, 2,
2303 &sprite_trajectory_tab[0][0], 4, 2);
2304 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2305 &mb_type_b_tab[0][1], 2, 1,
2306 &mb_type_b_tab[0][0], 2, 1);
2311 * Get the GOB height based on picture height.
2313 int ff_h263_get_gob_height(MpegEncContext *s){
2314 if (s->height <= 400)
2316 else if (s->height <= 800)
2323 * decodes the group of blocks header.
2324 * @return <0 if an error occured
2326 static int h263_decode_gob_header(MpegEncContext *s)
2328 unsigned int val, gfid;
2331 /* Check for GOB Start Code */
2332 val = show_bits(&s->gb, 16);
2336 /* We have a GBSC probably with GSTUFF */
2337 skip_bits(&s->gb, 16); /* Drop the zeros */
2338 left= s->gb.size_in_bits - get_bits_count(&s->gb);
2339 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2340 for(;left>13; left--){
2341 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2347 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2349 s->gob_number = get_bits(&s->gb, 5); /* GN */
2350 gfid = get_bits(&s->gb, 2); /* GFID */
2351 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2355 s->mb_y= s->gob_index* s->gob_number;
2357 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2362 static inline void memsetw(short *tab, int val, int n)
2369 #ifdef CONFIG_ENCODERS
2371 void ff_mpeg4_init_partitions(MpegEncContext *s)
2373 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2374 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
2377 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2379 const int pb2_len = get_bit_count(&s->pb2 );
2380 const int tex_pb_len= get_bit_count(&s->tex_pb);
2381 const int bits= get_bit_count(&s->pb);
2383 if(s->pict_type==I_TYPE){
2384 put_bits(&s->pb, 19, DC_MARKER);
2385 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2386 s->i_tex_bits+= tex_pb_len;
2388 put_bits(&s->pb, 17, MOTION_MARKER);
2389 s->misc_bits+=17 + pb2_len;
2390 s->mv_bits+= bits - s->last_bits;
2391 s->p_tex_bits+= tex_pb_len;
2394 flush_put_bits(&s->pb2);
2395 flush_put_bits(&s->tex_pb);
2397 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
2398 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2399 s->last_bits= get_bit_count(&s->pb);
2402 #endif //CONFIG_ENCODERS
2404 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2405 switch(s->pict_type){
2410 return s->f_code+15;
2412 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2418 #ifdef CONFIG_ENCODERS
2420 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2422 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2424 ff_mpeg4_stuffing(&s->pb);
2425 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2426 put_bits(&s->pb, 1, 1);
2428 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2429 put_bits(&s->pb, s->quant_precision, s->qscale);
2430 put_bits(&s->pb, 1, 0); /* no HEC */
2433 #endif //CONFIG_ENCODERS
2436 * check if the next stuff is a resync marker or the end.
2439 static inline int mpeg4_is_resync(MpegEncContext *s){
2440 const int bits_count= get_bits_count(&s->gb);
2442 if(s->workaround_bugs&FF_BUG_NO_PADDING){
2446 if(bits_count + 8 >= s->gb.size_in_bits){
2447 int v= show_bits(&s->gb, 8);
2448 v|= 0x7F >> (7-(bits_count&7));
2453 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2455 GetBitContext gb= s->gb;
2457 skip_bits(&s->gb, 1);
2458 align_get_bits(&s->gb);
2460 for(len=0; len<32; len++){
2461 if(get_bits1(&s->gb)) break;
2466 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2474 * decodes the next video packet.
2475 * @return <0 if something went wrong
2477 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2479 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2480 int header_extension=0, mb_num, len;
2482 /* is there enough space left for a video packet + header */
2483 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2485 for(len=0; len<32; len++){
2486 if(get_bits1(&s->gb)) break;
2489 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2490 printf("marker does not match f_code\n");
2494 if(s->shape != RECT_SHAPE){
2495 header_extension= get_bits1(&s->gb);
2496 //FIXME more stuff here
2499 mb_num= get_bits(&s->gb, mb_num_bits);
2500 if(mb_num>=s->mb_num){
2501 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2504 if(s->pict_type == B_TYPE){
2505 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2506 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2509 s->mb_x= mb_num % s->mb_width;
2510 s->mb_y= mb_num / s->mb_width;
2512 if(s->shape != BIN_ONLY_SHAPE){
2513 int qscale= get_bits(&s->gb, s->quant_precision);
2518 if(s->shape == RECT_SHAPE){
2519 header_extension= get_bits1(&s->gb);
2521 if(header_extension){
2525 while (get_bits1(&s->gb) != 0)
2528 check_marker(&s->gb, "before time_increment in video packed header");
2529 time_increment= get_bits(&s->gb, s->time_increment_bits);
2530 check_marker(&s->gb, "before vop_coding_type in video packed header");
2532 skip_bits(&s->gb, 2); /* vop coding type */
2533 //FIXME not rect stuff here
2535 if(s->shape != BIN_ONLY_SHAPE){
2536 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2537 //FIXME dont just ignore everything
2538 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2539 mpeg4_decode_sprite_trajectory(s);
2540 fprintf(stderr, "untested\n");
2543 //FIXME reduced res stuff here
2545 if (s->pict_type != I_TYPE) {
2546 int f_code = get_bits(&s->gb, 3); /* fcode_for */
2548 printf("Error, video packet header damaged (f_code=0)\n");
2551 if (s->pict_type == B_TYPE) {
2552 int b_code = get_bits(&s->gb, 3);
2554 printf("Error, video packet header damaged (b_code=0)\n");
2559 //FIXME new-pred stuff
2561 //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));
2566 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2568 int c_wrap, c_xy, l_wrap, l_xy;
2570 l_wrap= s->block_wrap[0];
2571 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2572 c_wrap= s->block_wrap[4];
2573 c_xy= s->mb_y*c_wrap + s->mb_x;
2577 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2578 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2579 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2583 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2584 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
2585 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
2588 // we cant clear the MVs as they might be needed by a b frame
2589 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2590 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2591 s->last_mv[0][0][0]=
2592 s->last_mv[0][0][1]=
2593 s->last_mv[1][0][0]=
2594 s->last_mv[1][0][1]= 0;
2598 * decodes the group of blocks / video packet header.
2599 * @return <0 if no resync found
2601 int ff_h263_resync(MpegEncContext *s){
2604 if(s->codec_id==CODEC_ID_MPEG4)
2607 align_get_bits(&s->gb);
2609 if(show_bits(&s->gb, 16)==0){
2610 if(s->codec_id==CODEC_ID_MPEG4)
2611 ret= mpeg4_decode_video_packet_header(s);
2613 ret= h263_decode_gob_header(s);
2617 //ok, its not where its supposed to be ...
2618 s->gb= s->last_resync_gb;
2619 align_get_bits(&s->gb);
2620 left= s->gb.size_in_bits - get_bits_count(&s->gb);
2622 for(;left>16+1+5+5; left-=8){
2623 if(show_bits(&s->gb, 16)==0){
2624 GetBitContext bak= s->gb;
2626 if(s->codec_id==CODEC_ID_MPEG4)
2627 ret= mpeg4_decode_video_packet_header(s);
2629 ret= h263_decode_gob_header(s);
2635 skip_bits(&s->gb, 8);
2642 * gets the average motion vector for a GMC MB.
2643 * @param n either 0 for the x component or 1 for y
2644 * @returns the average MV for a GMC MB
2646 static inline int get_amv(MpegEncContext *s, int n){
2647 int x, y, mb_v, sum, dx, dy, shift;
2648 int len = 1 << (s->f_code + 4);
2649 const int a= s->sprite_warping_accuracy;
2651 if(s->real_sprite_warping_points==1){
2652 if(s->divx_version==500 && s->divx_build==413)
2653 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2655 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2657 dx= s->sprite_delta[n][0];
2658 dy= s->sprite_delta[n][1];
2659 shift= s->sprite_shift[0];
2660 if(n) dy -= 1<<(shift + a + 1);
2661 else dx -= 1<<(shift + a + 1);
2662 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2665 for(y=0; y<16; y++){
2669 //XXX FIXME optimize
2670 for(x=0; x<16; x++){
2675 sum= RSHIFT(sum, a+8-s->quarter_sample);
2678 if (sum < -len) sum= -len;
2679 else if (sum >= len) sum= len-1;
2685 * decodes first partition.
2686 * @return number of MBs decoded or <0 if an error occured
2688 static int mpeg4_decode_partition_a(MpegEncContext *s){
2690 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2692 /* decode first partition */
2694 s->first_slice_line=1;
2695 for(; s->mb_y<s->mb_height; s->mb_y++){
2696 ff_init_block_index(s);
2697 for(; s->mb_x<s->mb_width; s->mb_x++){
2698 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2703 ff_update_block_index(s);
2704 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2705 s->first_slice_line=0;
2707 if(s->pict_type==I_TYPE){
2710 if(show_bits_long(&s->gb, 19)==DC_MARKER){
2714 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2717 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2720 s->cbp_table[xy]= cbpc & 3;
2721 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2725 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2727 s->current_picture.qscale_table[xy]= s->qscale;
2729 s->mbintra_table[xy]= 1;
2732 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2734 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2738 if(dc_pred_dir) dir|=1;
2740 s->pred_dir_table[xy]= dir;
2741 }else{ /* P/S_TYPE */
2742 int mx, my, pred_x, pred_y, bits;
2743 int16_t * const mot_val= s->motion_val[s->block_index[0]];
2744 const int stride= s->block_wrap[0]*2;
2746 bits= show_bits(&s->gb, 17);
2747 if(bits==MOTION_MARKER){
2753 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2754 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2758 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
2761 mot_val[0 ]= mot_val[2 ]=
2762 mot_val[0+stride]= mot_val[2+stride]= mx;
2763 mot_val[1 ]= mot_val[3 ]=
2764 mot_val[1+stride]= mot_val[3+stride]= my;
2766 if(s->mbintra_table[xy])
2767 ff_clean_intra_table_entries(s);
2770 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2772 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2777 else if (cbpc == 20)
2778 fprintf(stderr, "Stuffing !");
2779 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2781 s->mb_intra = ((cbpc & 4) != 0);
2784 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2785 s->mbintra_table[xy]= 1;
2786 mot_val[0 ]= mot_val[2 ]=
2787 mot_val[0+stride]= mot_val[2+stride]= 0;
2788 mot_val[1 ]= mot_val[3 ]=
2789 mot_val[1+stride]= mot_val[3+stride]= 0;
2791 if(s->mbintra_table[xy])
2792 ff_clean_intra_table_entries(s);
2794 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2795 s->mcsel= get_bits1(&s->gb);
2798 if ((cbpc & 16) == 0) {
2799 /* 16x16 motion prediction */
2801 h263_pred_motion(s, 0, &pred_x, &pred_y);
2803 mx = h263_decode_motion(s, pred_x, s->f_code);
2807 my = h263_decode_motion(s, pred_y, s->f_code);
2810 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
2814 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2817 mot_val[0 ]= mot_val[2 ] =
2818 mot_val[0+stride]= mot_val[2+stride]= mx;
2819 mot_val[1 ]= mot_val[3 ]=
2820 mot_val[1+stride]= mot_val[3+stride]= my;
2823 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
2825 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2826 mx = h263_decode_motion(s, pred_x, s->f_code);
2830 my = h263_decode_motion(s, pred_y, s->f_code);
2847 * decode second partition.
2848 * @return <0 if an error occured
2850 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2852 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2854 s->mb_x= s->resync_mb_x;
2855 s->first_slice_line=1;
2856 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2857 ff_init_block_index(s);
2858 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
2859 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2862 ff_update_block_index(s);
2863 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2864 s->first_slice_line=0;
2866 if(s->pict_type==I_TYPE){
2867 int ac_pred= get_bits1(&s->gb);
2868 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2870 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2874 s->cbp_table[xy]|= cbpy<<2;
2875 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
2876 }else{ /* P || S_TYPE */
2877 if(IS_INTRA(s->current_picture.mb_type[xy])){
2879 int ac_pred = get_bits1(&s->gb);
2880 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2883 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2887 if(s->cbp_table[xy] & 8) {
2888 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2890 s->current_picture.qscale_table[xy]= s->qscale;
2894 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2896 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2900 if(dc_pred_dir) dir|=1;
2902 s->cbp_table[xy]&= 3; //remove dquant
2903 s->cbp_table[xy]|= cbpy<<2;
2904 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
2905 s->pred_dir_table[xy]= dir;
2906 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
2907 s->current_picture.qscale_table[xy]= s->qscale;
2908 s->cbp_table[xy]= 0;
2910 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2913 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2917 if(s->cbp_table[xy] & 8) {
2918 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2920 s->current_picture.qscale_table[xy]= s->qscale;
2922 s->cbp_table[xy]&= 3; //remove dquant
2923 s->cbp_table[xy]|= (cbpy^0xf)<<2;
2927 if(mb_num >= mb_count) return 0;
2934 * decodes the first & second partition
2935 * @return <0 if error (and sets error type in the error_status_table)
2937 int ff_mpeg4_decode_partitions(MpegEncContext *s)
2940 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
2941 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
2943 mb_num= mpeg4_decode_partition_a(s);
2945 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2949 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2950 fprintf(stderr, "slice below monitor ...\n");
2951 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
2955 s->mb_num_left= mb_num;
2957 if(s->pict_type==I_TYPE){
2958 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
2959 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2963 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2964 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2968 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
2970 if( mpeg4_decode_partition_b(s, mb_num) < 0){
2971 if(s->pict_type==P_TYPE)
2972 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
2975 if(s->pict_type==P_TYPE)
2976 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
2983 * decode partition C of one MB.
2984 * @return <0 if an error occured
2986 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
2989 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2991 mb_type= s->current_picture.mb_type[xy];
2992 cbp = s->cbp_table[xy];
2994 if(s->current_picture.qscale_table[xy] != s->qscale){
2995 s->qscale= s->current_picture.qscale_table[xy];
2996 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2997 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3000 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3003 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3004 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3006 s->mb_intra = IS_INTRA(mb_type);
3008 if (IS_SKIP(mb_type)) {
3011 s->block_last_index[i] = -1;
3012 s->mv_dir = MV_DIR_FORWARD;
3013 s->mv_type = MV_TYPE_16X16;
3014 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3021 }else if(s->mb_intra){
3022 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3023 }else if(!s->mb_intra){
3024 // s->mcsel= 0; //FIXME do we need to init that
3026 s->mv_dir = MV_DIR_FORWARD;
3027 if (IS_8X8(mb_type)) {
3028 s->mv_type = MV_TYPE_8X8;
3030 s->mv_type = MV_TYPE_16X16;
3033 } else { /* I-Frame */
3035 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3038 if (!IS_SKIP(mb_type)) {
3040 /* decode each block */
3041 for (i = 0; i < 6; i++) {
3042 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3043 fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3050 /* per-MB end of slice check */
3052 if(--s->mb_num_left <= 0){
3053 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3054 if(mpeg4_is_resync(s))
3059 if(mpeg4_is_resync(s)){
3060 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3061 if(s->cbp_table[xy+delta])
3068 int ff_h263_decode_mb(MpegEncContext *s,
3069 DCTELEM block[6][64])
3071 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3073 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3074 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3076 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3077 if (get_bits1(&s->gb)) {
3081 s->block_last_index[i] = -1;
3082 s->mv_dir = MV_DIR_FORWARD;
3083 s->mv_type = MV_TYPE_16X16;
3084 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3085 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3087 s->mv[0][0][0]= get_amv(s, 0);
3088 s->mv[0][0][1]= get_amv(s, 1);
3092 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3100 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3101 //fprintf(stderr, "\tCBPC: %d", cbpc);
3106 else if (cbpc == 20)
3107 fprintf(stderr, "Stuffing !");
3110 s->mb_intra = ((cbpc & 4) != 0);
3111 if (s->mb_intra) goto intra;
3113 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3114 s->mcsel= get_bits1(&s->gb);
3116 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3117 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3119 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3121 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3122 s->interlaced_dct= get_bits1(&s->gb);
3124 s->mv_dir = MV_DIR_FORWARD;
3125 if ((cbpc & 16) == 0) {
3127 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3128 /* 16x16 global motion prediction */
3129 s->mv_type = MV_TYPE_16X16;
3132 s->mv[0][0][0] = mx;
3133 s->mv[0][0][1] = my;
3134 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3135 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
3136 /* 16x8 field motion prediction */
3137 s->mv_type= MV_TYPE_FIELD;
3139 s->field_select[0][0]= get_bits1(&s->gb);
3140 s->field_select[0][1]= get_bits1(&s->gb);
3142 h263_pred_motion(s, 0, &pred_x, &pred_y);
3145 mx = h263_decode_motion(s, pred_x, s->f_code);
3149 my = h263_decode_motion(s, pred_y/2, s->f_code);
3153 s->mv[0][i][0] = mx;
3154 s->mv[0][i][1] = my;
3157 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3158 /* 16x16 motion prediction */
3159 s->mv_type = MV_TYPE_16X16;
3160 h263_pred_motion(s, 0, &pred_x, &pred_y);
3162 mx = h263p_decode_umotion(s, pred_x);
3164 mx = h263_decode_motion(s, pred_x, s->f_code);
3170 my = h263p_decode_umotion(s, pred_y);
3172 my = h263_decode_motion(s, pred_y, s->f_code);
3176 s->mv[0][0][0] = mx;
3177 s->mv[0][0][1] = my;
3179 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3180 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3183 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3184 s->mv_type = MV_TYPE_8X8;
3186 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3188 mx = h263p_decode_umotion(s, pred_x);
3190 mx = h263_decode_motion(s, pred_x, s->f_code);
3195 my = h263p_decode_umotion(s, pred_y);
3197 my = h263_decode_motion(s, pred_y, s->f_code);
3200 s->mv[0][i][0] = mx;
3201 s->mv[0][i][1] = my;
3202 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3203 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3208 } else if(s->pict_type==B_TYPE) {
3209 int modb1; // first bit of modb
3210 int modb2; // second bit of modb
3213 s->mb_intra = 0; //B-frames never contain intra blocks
3214 s->mcsel=0; // ... true gmc blocks
3218 s->last_mv[i][0][0]=
3219 s->last_mv[i][0][1]=
3220 s->last_mv[i][1][0]=
3221 s->last_mv[i][1][1]= 0;
3225 /* if we skipped it in the future P Frame than skip it now too */
3226 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
3231 s->block_last_index[i] = -1;
3233 s->mv_dir = MV_DIR_FORWARD;
3234 s->mv_type = MV_TYPE_16X16;
3239 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3243 modb1= get_bits1(&s->gb);
3245 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3248 modb2= get_bits1(&s->gb);
3249 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3251 printf("illegal MB_type\n");
3254 mb_type= mb_type_b_map[ mb_type ];
3256 else cbp= get_bits(&s->gb, 6);
3258 if ((!IS_DIRECT(mb_type)) && cbp) {
3259 if(get_bits1(&s->gb)){
3260 change_qscale(s, get_bits1(&s->gb)*4 - 2);
3264 if(!s->progressive_sequence){
3266 s->interlaced_dct= get_bits1(&s->gb);
3268 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3269 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3270 mb_type &= ~MB_TYPE_16x16;
3272 if(USES_LIST(mb_type, 0)){
3273 s->field_select[0][0]= get_bits1(&s->gb);
3274 s->field_select[0][1]= get_bits1(&s->gb);
3276 if(USES_LIST(mb_type, 1)){
3277 s->field_select[1][0]= get_bits1(&s->gb);
3278 s->field_select[1][1]= get_bits1(&s->gb);
3284 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3285 s->mv_type= MV_TYPE_16X16;
3287 if(USES_LIST(mb_type, 0)){
3288 s->mv_dir = MV_DIR_FORWARD;
3290 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3291 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3292 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3293 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3296 if(USES_LIST(mb_type, 1)){
3297 s->mv_dir |= MV_DIR_BACKWARD;
3299 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3300 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3301 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3302 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3304 }else if(!IS_DIRECT(mb_type)){
3305 s->mv_type= MV_TYPE_FIELD;
3307 if(USES_LIST(mb_type, 0)){
3308 s->mv_dir = MV_DIR_FORWARD;
3311 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
3312 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3313 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
3314 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3318 if(USES_LIST(mb_type, 1)){
3319 s->mv_dir |= MV_DIR_BACKWARD;
3322 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
3323 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3324 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
3325 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3331 if(IS_DIRECT(mb_type)){
3332 if(IS_SKIP(mb_type))
3335 mx = h263_decode_motion(s, 0, 1);
3336 my = h263_decode_motion(s, 0, 1);
3339 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3340 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3342 s->current_picture.mb_type[xy]= mb_type;
3343 } else { /* I-Frame */
3344 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
3350 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3351 if (s->h263_pred || s->h263_aic) {
3352 s->ac_pred = get_bits1(&s->gb);
3354 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3357 s->h263_aic_dir = get_bits1(&s->gb);
3362 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3363 if(cbpy<0) return -1;
3364 cbp = (cbpc & 3) | (cbpy << 2);
3366 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3369 if(!s->progressive_sequence)
3370 s->interlaced_dct= get_bits1(&s->gb);
3372 /* decode each block */
3374 for (i = 0; i < 6; i++) {
3375 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3380 for (i = 0; i < 6; i++) {
3381 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3389 /* decode each block */
3391 for (i = 0; i < 6; i++) {
3392 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3397 for (i = 0; i < 6; i++) {
3398 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3405 /* per-MB end of slice check */
3406 if(s->codec_id==CODEC_ID_MPEG4){
3407 if(mpeg4_is_resync(s)){
3408 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3409 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3414 int v= show_bits(&s->gb, 16);
3416 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3417 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3427 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3429 int code, val, sign, shift, l;
3430 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3437 sign = get_bits1(&s->gb);
3441 val = (val - 1) << shift;
3442 val |= get_bits(&s->gb, shift);
3449 /* modulo decoding */
3450 if (!s->h263_long_vectors) {
3451 l = 1 << (f_code + 4);
3452 val = ((val + l)&(l*2-1)) - l;
3454 /* horrible h263 long vector mode */
3455 if (pred < -31 && val < -63)
3457 if (pred > 32 && val > 63)
3464 /* Decodes RVLC of H.263+ UMV */
3465 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3469 if (get_bits1(&s->gb)) /* Motion difference = 0 */
3472 code = 2 + get_bits1(&s->gb);
3474 while (get_bits1(&s->gb))
3477 code += get_bits1(&s->gb);
3482 code = (sign) ? (pred - code) : (pred + code);
3484 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3490 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3493 int code, level, i, j, last, run;
3494 RLTable *rl = &rl_inter;
3495 const uint8_t *scan_table;
3497 scan_table = s->intra_scantable.permutated;
3498 if (s->h263_aic && s->mb_intra) {
3502 if (s->h263_aic_dir)
3503 scan_table = s->intra_v_scantable.permutated; /* left */
3505 scan_table = s->intra_h_scantable.permutated; /* top */
3507 } else if (s->mb_intra) {
3510 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3511 int component, diff;
3512 component = (n <= 3 ? 0 : n - 4 + 1);
3513 level = s->last_dc[component];
3514 if (s->rv10_first_dc_coded[component]) {
3515 diff = rv_decode_dc(s, n);
3519 level = level & 0xff; /* handle wrap round */
3520 s->last_dc[component] = level;
3522 s->rv10_first_dc_coded[component] = 1;
3525 level = get_bits(&s->gb, 8);
3528 level = get_bits(&s->gb, 8);
3529 if((level&0x7F) == 0){
3530 fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3542 if (s->mb_intra && s->h263_aic)
3544 s->block_last_index[n] = i - 1;
3549 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3551 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3554 if (code == rl->n) {
3556 last = get_bits1(&s->gb);
3557 run = get_bits(&s->gb, 6);
3558 level = (int8_t)get_bits(&s->gb, 8);
3561 /* XXX: should patch encoder too */
3562 level = get_sbits(&s->gb, 12);
3564 level = get_bits(&s->gb, 5);
3565 level |= get_sbits(&s->gb, 6)<<5;
3569 run = rl->table_run[code];
3570 level = rl->table_level[code];
3571 last = code >= rl->last;
3572 if (get_bits1(&s->gb))
3577 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3587 if (s->mb_intra && s->h263_aic) {
3588 h263_pred_acdc(s, block, n);
3591 s->block_last_index[n] = i;
3596 * decodes the dc value.
3597 * @param n block index (0-3 are luma, 4-5 are chroma)
3598 * @param dir_ptr the prediction direction will be stored here
3599 * @return the quantized dc
3601 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3603 int level, pred, code;
3607 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3609 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3610 if (code < 0 || code > 9 /* && s->nbit<9 */){
3611 fprintf(stderr, "illegal dc vlc\n");
3619 level= 2*get_bits1(&s->gb)-1;
3621 if(get_bits1(&s->gb))
3622 level = get_bits(&s->gb, code-1) + (1<<(code-1));
3624 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
3627 level = get_xbits(&s->gb, code);
3631 if(get_bits1(&s->gb)==0){ /* marker */
3632 if(s->error_resilience>=2){
3633 fprintf(stderr, "dc marker bit missing\n");
3639 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3642 if(s->error_resilience>=3){
3643 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3649 *dc_val = level * s->y_dc_scale;
3651 *dc_val = level * s->c_dc_scale;
3654 *dc_val = level * 8;
3656 if(s->error_resilience>=3){
3657 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3658 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3667 * @return <0 if an error occured
3669 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3670 int n, int coded, int intra, int rvlc)
3672 int level, i, last, run;
3675 RL_VLC_ELEM * rl_vlc;
3676 const uint8_t * scan_table;
3679 //Note intra & rvlc should be optimized away if this is inlined
3683 if(s->partitioned_frame){
3684 level = s->dc_val[0][ s->block_index[n] ];
3685 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
3686 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
3687 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
3689 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3699 rl = &rvlc_rl_intra;
3700 rl_vlc = rvlc_rl_intra.rl_vlc[0];
3703 rl_vlc = rl_intra.rl_vlc[0];
3706 if (dc_pred_dir == 0)
3707 scan_table = s->intra_v_scantable.permutated; /* left */
3709 scan_table = s->intra_h_scantable.permutated; /* top */
3711 scan_table = s->intra_scantable.permutated;
3718 s->block_last_index[n] = i;
3721 if(rvlc) rl = &rvlc_rl_inter;
3722 else rl = &rl_inter;
3724 scan_table = s->intra_scantable.permutated;
3730 rl_vlc = rvlc_rl_inter.rl_vlc[0];
3732 rl_vlc = rl_inter.rl_vlc[0];
3735 qmul = s->qscale << 1;
3736 qadd = (s->qscale - 1) | 1;
3738 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
3740 rl_vlc = rl_inter.rl_vlc[s->qscale];
3745 OPEN_READER(re, &s->gb);
3747 UPDATE_CACHE(re, &s->gb);
3748 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3752 if(SHOW_UBITS(re, &s->gb, 1)==0){
3753 fprintf(stderr, "1. marker bit missing in rvlc esc\n");
3755 }; SKIP_CACHE(re, &s->gb, 1);
3757 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3758 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3759 SKIP_COUNTER(re, &s->gb, 1+1+6);
3760 UPDATE_CACHE(re, &s->gb);
3762 if(SHOW_UBITS(re, &s->gb, 1)==0){
3763 fprintf(stderr, "2. marker bit missing in rvlc esc\n");
3765 }; SKIP_CACHE(re, &s->gb, 1);
3767 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3769 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3770 fprintf(stderr, "reverse esc missing\n");
3772 }; SKIP_CACHE(re, &s->gb, 5);
3774 level= level * qmul + qadd;
3775 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
3776 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
3782 cache= GET_CACHE(re, &s->gb);
3785 cache ^= 0xC0000000;
3787 if (cache&0x80000000) {
3788 if (cache&0x40000000) {
3790 SKIP_CACHE(re, &s->gb, 2);
3791 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3792 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3793 SKIP_COUNTER(re, &s->gb, 2+1+6);
3794 UPDATE_CACHE(re, &s->gb);
3797 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
3799 if(SHOW_UBITS(re, &s->gb, 1)==0){
3800 fprintf(stderr, "1. marker bit missing in 3. esc\n");
3802 }; SKIP_CACHE(re, &s->gb, 1);
3804 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3806 if(SHOW_UBITS(re, &s->gb, 1)==0){
3807 fprintf(stderr, "2. marker bit missing in 3. esc\n");
3809 }; LAST_SKIP_CACHE(re, &s->gb, 1);
3811 SKIP_COUNTER(re, &s->gb, 1+12+1);
3814 if(level*s->qscale>1024 || level*s->qscale<-1024){
3815 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3820 const int abs_level= ABS(level);
3821 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
3822 const int run1= run - rl->max_run[last][abs_level] - 1;
3823 if(abs_level <= rl->max_level[last][run]){
3824 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3827 if(s->error_resilience > FF_ER_COMPLIANT){
3828 if(abs_level <= rl->max_level[last][run]*2){
3829 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3832 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3833 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3840 if (level>0) level= level * qmul + qadd;
3841 else level= level * qmul - qadd;
3847 #if MIN_CACHE_BITS < 20
3848 LAST_SKIP_BITS(re, &s->gb, 2);
3849 UPDATE_CACHE(re, &s->gb);
3851 SKIP_BITS(re, &s->gb, 2);
3853 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3854 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3855 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3856 LAST_SKIP_BITS(re, &s->gb, 1);
3860 #if MIN_CACHE_BITS < 19
3861 LAST_SKIP_BITS(re, &s->gb, 1);
3862 UPDATE_CACHE(re, &s->gb);
3864 SKIP_BITS(re, &s->gb, 1);
3866 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3868 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3869 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3870 LAST_SKIP_BITS(re, &s->gb, 1);
3875 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3876 LAST_SKIP_BITS(re, &s->gb, 1);
3881 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3885 block[scan_table[i]] = level;
3889 block[scan_table[i]] = level;
3891 CLOSE_READER(re, &s->gb);
3895 mpeg4_pred_ac(s, block, n, dc_pred_dir);
3897 i = 63; /* XXX: not optimal */
3900 s->block_last_index[n] = i;
3904 /* most is hardcoded. should extend to handle all h263 streams */
3905 int h263_decode_picture_header(MpegEncContext *s)
3907 int format, width, height, i;
3910 align_get_bits(&s->gb);
3912 startcode= get_bits(&s->gb, 22-8);
3914 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>0; i--) {
3915 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
3917 if(startcode == 0x20)
3921 if (startcode != 0x20) {
3922 fprintf(stderr, "Bad picture start code\n");
3925 /* temporal reference */
3926 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3928 /* PTYPE starts here */
3929 if (get_bits1(&s->gb) != 1) {
3931 fprintf(stderr, "Bad marker\n");
3934 if (get_bits1(&s->gb) != 0) {
3935 fprintf(stderr, "Bad H263 id\n");
3936 return -1; /* h263 id */
3938 skip_bits1(&s->gb); /* split screen off */
3939 skip_bits1(&s->gb); /* camera off */
3940 skip_bits1(&s->gb); /* freeze picture release off */
3942 /* Reset GOB number */
3945 format = get_bits(&s->gb, 3);
3950 7 extended PTYPE (PLUSPTYPE)
3953 if (format != 7 && format != 6) {
3956 width = h263_format[format][0];
3957 height = h263_format[format][1];
3963 s->pict_type = I_TYPE + get_bits1(&s->gb);
3965 s->unrestricted_mv = get_bits1(&s->gb);
3966 s->h263_long_vectors = s->unrestricted_mv;
3968 if (get_bits1(&s->gb) != 0) {
3969 fprintf(stderr, "H263 SAC not supported\n");
3970 return -1; /* SAC: off */
3972 if (get_bits1(&s->gb) != 0) {
3973 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3976 if (get_bits1(&s->gb) != 0) {
3977 fprintf(stderr, "H263 PB frame not supported\n");
3978 return -1; /* not PB frame */
3980 s->qscale = get_bits(&s->gb, 5);
3981 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
3987 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3989 /* ufep other than 0 and 1 are reserved */
3992 format = get_bits(&s->gb, 3);
3993 dprintf("ufep=1, format: %d\n", format);
3994 skip_bits(&s->gb,1); /* Custom PCF */
3995 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3996 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3997 if (get_bits1(&s->gb) != 0) {
3998 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4000 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
4004 if (get_bits1(&s->gb) != 0) {
4005 fprintf(stderr, "Deblocking Filter not supported\n");
4007 if (get_bits1(&s->gb) != 0) {
4008 fprintf(stderr, "Slice Structured not supported\n");
4010 if (get_bits1(&s->gb) != 0) {
4011 fprintf(stderr, "Reference Picture Selection not supported\n");
4013 if (get_bits1(&s->gb) != 0) {
4014 fprintf(stderr, "Independent Segment Decoding not supported\n");
4016 if (get_bits1(&s->gb) != 0) {
4017 fprintf(stderr, "Alternative Inter VLC not supported\n");
4019 if (get_bits1(&s->gb) != 0) {
4020 fprintf(stderr, "Modified Quantization not supported\n");
4023 skip_bits(&s->gb, 1); /* Prevent start code emulation */
4025 skip_bits(&s->gb, 3); /* Reserved */
4026 } else if (ufep != 0) {
4027 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
4032 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4033 dprintf("pict_type: %d\n", s->pict_type);
4034 if (s->pict_type != I_TYPE &&
4035 s->pict_type != P_TYPE)
4037 skip_bits(&s->gb, 2);
4038 s->no_rounding = get_bits1(&s->gb);
4039 dprintf("RTYPE: %d\n", s->no_rounding);
4040 skip_bits(&s->gb, 4);
4042 /* Get the picture dimensions */
4045 /* Custom Picture Format (CPFMT) */
4046 s->aspect_ratio_info = get_bits(&s->gb, 4);
4047 dprintf("aspect: %d\n", s->aspect_ratio_info);
4052 3 - 10:11 (525-type 4:3)
4053 4 - 16:11 (CIF 16:9)
4054 5 - 40:33 (525-type 16:9)
4057 width = (get_bits(&s->gb, 9) + 1) * 4;
4059 height = get_bits(&s->gb, 9) * 4;
4060 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4061 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4062 /* aspected dimensions */
4063 s->aspected_width = get_bits(&s->gb, 8);
4064 s->aspected_height = get_bits(&s->gb, 8);
4066 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4067 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4070 width = h263_format[format][0];
4071 height = h263_format[format][1];
4073 if ((width == 0) || (height == 0))
4078 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4083 s->qscale = get_bits(&s->gb, 5);
4086 while (get_bits1(&s->gb) != 0) {
4087 skip_bits(&s->gb, 8);
4092 s->y_dc_scale_table=
4093 s->c_dc_scale_table= h263_aic_dc_scale_table;
4095 s->y_dc_scale_table=
4096 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4099 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4100 printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n",
4101 s->qscale, av_get_pict_type_char(s->pict_type),
4102 s->gb.size_in_bits, 1-s->no_rounding,
4103 s->mv_type == MV_TYPE_8X8 ? "ADV" : "",
4104 s->umvplus ? "UMV" : "",
4105 s->h263_long_vectors ? "LONG" : "",
4106 s->h263_plus ? "+" : ""
4114 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4117 int a= 2<<s->sprite_warping_accuracy;
4118 int rho= 3-s->sprite_warping_accuracy;
4120 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4121 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4122 int sprite_ref[4][2];
4123 int virtual_ref[2][2];
4125 int alpha=0, beta=0;
4130 for(i=0; i<s->num_sprite_warping_points; i++){
4134 length= get_vlc(&s->gb, &sprite_trajectory);
4136 x= get_xbits(&s->gb, length);
4138 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4140 length= get_vlc(&s->gb, &sprite_trajectory);
4142 y=get_xbits(&s->gb, length);
4144 skip_bits1(&s->gb); /* marker bit */
4145 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4150 while((1<<alpha)<w) alpha++;
4151 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4155 // Note, the 4th point isnt used for GMC
4156 if(s->divx_version==500 && s->divx_build==413){
4157 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4158 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4159 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4160 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4161 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4162 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4164 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4165 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4166 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4167 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4168 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4169 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4171 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4172 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4174 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4175 // perhaps it should be reordered to be more readable ...
4176 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4177 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4178 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
4179 + 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);
4180 virtual_ref[0][1]= 16*vop_ref[0][1]
4181 + 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);
4182 virtual_ref[1][0]= 16*vop_ref[0][0]
4183 + 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);
4184 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
4185 + 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);
4187 switch(s->num_sprite_warping_points)
4190 s->sprite_offset[0][0]= 0;
4191 s->sprite_offset[0][1]= 0;
4192 s->sprite_offset[1][0]= 0;
4193 s->sprite_offset[1][1]= 0;
4194 s->sprite_delta[0][0]= a;
4195 s->sprite_delta[0][1]= 0;
4196 s->sprite_delta[1][0]= 0;
4197 s->sprite_delta[1][1]= a;
4198 s->sprite_shift[0]= 0;
4199 s->sprite_shift[1]= 0;
4202 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4203 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4204 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4205 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4206 s->sprite_delta[0][0]= a;
4207 s->sprite_delta[0][1]= 0;
4208 s->sprite_delta[1][0]= 0;
4209 s->sprite_delta[1][1]= a;
4210 s->sprite_shift[0]= 0;
4211 s->sprite_shift[1]= 0;
4214 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4215 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4216 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4217 + (1<<(alpha+rho-1));
4218 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4219 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4220 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4221 + (1<<(alpha+rho-1));
4222 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4223 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4224 +2*w2*r*sprite_ref[0][0]
4226 + (1<<(alpha+rho+1)));
4227 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
4228 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4229 +2*w2*r*sprite_ref[0][1]
4231 + (1<<(alpha+rho+1)));
4232 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4233 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4234 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4235 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4237 s->sprite_shift[0]= alpha+rho;
4238 s->sprite_shift[1]= alpha+rho+2;
4241 min_ab= FFMIN(alpha, beta);
4244 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4245 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4246 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4247 + (1<<(alpha+beta+rho-min_ab-1));
4248 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4249 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4250 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4251 + (1<<(alpha+beta+rho-min_ab-1));
4252 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4253 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4254 + 2*w2*h3*r*sprite_ref[0][0]
4256 + (1<<(alpha+beta+rho-min_ab+1));
4257 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4258 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4259 + 2*w2*h3*r*sprite_ref[0][1]
4261 + (1<<(alpha+beta+rho-min_ab+1));
4262 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4263 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4264 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4265 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4267 s->sprite_shift[0]= alpha + beta + rho - min_ab;
4268 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4271 /* try to simplify the situation */
4272 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4273 && s->sprite_delta[0][1] == 0
4274 && s->sprite_delta[1][0] == 0
4275 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4277 s->sprite_offset[0][0]>>=s->sprite_shift[0];
4278 s->sprite_offset[0][1]>>=s->sprite_shift[0];
4279 s->sprite_offset[1][0]>>=s->sprite_shift[1];
4280 s->sprite_offset[1][1]>>=s->sprite_shift[1];
4281 s->sprite_delta[0][0]= a;
4282 s->sprite_delta[0][1]= 0;
4283 s->sprite_delta[1][0]= 0;
4284 s->sprite_delta[1][1]= a;
4285 s->sprite_shift[0]= 0;
4286 s->sprite_shift[1]= 0;
4287 s->real_sprite_warping_points=1;
4290 int shift_y= 16 - s->sprite_shift[0];
4291 int shift_c= 16 - s->sprite_shift[1];
4292 //printf("shifts %d %d\n", shift_y, shift_c);
4294 s->sprite_offset[0][i]<<= shift_y;
4295 s->sprite_offset[1][i]<<= shift_c;
4296 s->sprite_delta[0][i]<<= shift_y;
4297 s->sprite_delta[1][i]<<= shift_y;
4298 s->sprite_shift[i]= 16;
4300 s->real_sprite_warping_points= s->num_sprite_warping_points;
4303 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4304 vop_ref[0][0], vop_ref[0][1],
4305 vop_ref[1][0], vop_ref[1][1],
4306 vop_ref[2][0], vop_ref[2][1],
4307 sprite_ref[0][0], sprite_ref[0][1],
4308 sprite_ref[1][0], sprite_ref[1][1],
4309 sprite_ref[2][0], sprite_ref[2][1],
4310 virtual_ref[0][0], virtual_ref[0][1],
4311 virtual_ref[1][0], virtual_ref[1][1]
4314 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4315 s->sprite_offset[0][0], s->sprite_offset[0][1],
4316 s->sprite_delta[0][0], s->sprite_delta[0][1],
4317 s->sprite_delta[1][0], s->sprite_delta[1][1],
4323 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4324 int hours, minutes, seconds;
4326 hours= get_bits(gb, 5);
4327 minutes= get_bits(gb, 6);
4329 seconds= get_bits(gb, 6);
4331 s->time_base= seconds + 60*(minutes + 60*hours);
4339 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4340 int width, height, vo_ver_id;
4343 skip_bits(gb, 1); /* random access */
4344 s->vo_type= get_bits(gb, 8);
4345 if (get_bits1(gb) != 0) { /* is_ol_id */
4346 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4347 skip_bits(gb, 3); /* vo_priority */
4351 //printf("vo type:%d\n",s->vo_type);
4352 s->aspect_ratio_info= get_bits(gb, 4);
4353 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
4354 s->aspected_width = get_bits(gb, 8); // par_width
4355 s->aspected_height = get_bits(gb, 8); // par_height
4357 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4358 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4361 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4362 int chroma_format= get_bits(gb, 2);
4363 if(chroma_format!=1){
4364 printf("illegal chroma format\n");
4366 s->low_delay= get_bits1(gb);
4367 if(get_bits1(gb)){ /* vbv parameters */
4368 get_bits(gb, 15); /* first_half_bitrate */
4369 skip_bits1(gb); /* marker */
4370 get_bits(gb, 15); /* latter_half_bitrate */
4371 skip_bits1(gb); /* marker */
4372 get_bits(gb, 15); /* first_half_vbv_buffer_size */
4373 skip_bits1(gb); /* marker */
4374 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
4375 get_bits(gb, 11); /* first_half_vbv_occupancy */
4376 skip_bits1(gb); /* marker */
4377 get_bits(gb, 15); /* latter_half_vbv_occupancy */
4378 skip_bits1(gb); /* marker */
4381 // set low delay flag only once so the smart? low delay detection wont be overriden
4382 if(s->picture_number==0)
4386 s->shape = get_bits(gb, 2); /* vol shape */
4387 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4388 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4389 printf("Gray shape not supported\n");
4390 skip_bits(gb, 4); //video_object_layer_shape_extension
4393 skip_bits1(gb); /* marker */
4395 s->time_increment_resolution = get_bits(gb, 16);
4397 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4398 if (s->time_increment_bits < 1)
4399 s->time_increment_bits = 1;
4400 skip_bits1(gb); /* marker */
4402 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
4403 skip_bits(gb, s->time_increment_bits);
4406 if (s->shape != BIN_ONLY_SHAPE) {
4407 if (s->shape == RECT_SHAPE) {
4408 skip_bits1(gb); /* marker */
4409 width = get_bits(gb, 13);
4410 skip_bits1(gb); /* marker */
4411 height = get_bits(gb, 13);
4412 skip_bits1(gb); /* marker */
4413 if(width && height){ /* they should be non zero but who knows ... */
4416 // printf("width/height: %d %d\n", width, height);
4420 s->progressive_sequence= get_bits1(gb)^1;
4421 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
4422 printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
4423 if (vo_ver_id == 1) {
4424 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4426 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4428 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4429 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4430 if(s->vol_sprite_usage==STATIC_SPRITE){
4431 s->sprite_width = get_bits(gb, 13);
4432 skip_bits1(gb); /* marker */
4433 s->sprite_height= get_bits(gb, 13);
4434 skip_bits1(gb); /* marker */
4435 s->sprite_left = get_bits(gb, 13);
4436 skip_bits1(gb); /* marker */
4437 s->sprite_top = get_bits(gb, 13);
4438 skip_bits1(gb); /* marker */
4440 s->num_sprite_warping_points= get_bits(gb, 6);
4441 s->sprite_warping_accuracy = get_bits(gb, 2);
4442 s->sprite_brightness_change= get_bits1(gb);
4443 if(s->vol_sprite_usage==STATIC_SPRITE)
4444 s->low_latency_sprite= get_bits1(gb);
4446 // FIXME sadct disable bit if verid!=1 && shape not rect
4448 if (get_bits1(gb) == 1) { /* not_8_bit */
4449 s->quant_precision = get_bits(gb, 4); /* quant_precision */
4450 if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4451 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4453 s->quant_precision = 5;
4456 // FIXME a bunch of grayscale shape things
4458 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4461 /* load default matrixes */
4462 for(i=0; i<64; i++){
4463 int j= s->dsp.idct_permutation[i];
4464 v= ff_mpeg4_default_intra_matrix[i];
4465 s->intra_matrix[j]= v;
4466 s->chroma_intra_matrix[j]= v;
4468 v= ff_mpeg4_default_non_intra_matrix[i];
4469 s->inter_matrix[j]= v;
4470 s->chroma_inter_matrix[j]= v;
4473 /* load custom intra matrix */
4476 for(i=0; i<64; i++){
4482 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4483 s->intra_matrix[j]= v;
4484 s->chroma_intra_matrix[j]= v;
4487 /* replicate last value */
4489 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4490 s->intra_matrix[j]= v;
4491 s->chroma_intra_matrix[j]= v;
4495 /* load custom non intra matrix */
4498 for(i=0; i<64; i++){
4504 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4505 s->inter_matrix[j]= v;
4506 s->chroma_inter_matrix[j]= v;
4509 /* replicate last value */
4511 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4512 s->inter_matrix[j]= last;
4513 s->chroma_inter_matrix[j]= last;
4517 // FIXME a bunch of grayscale shape things
4521 s->quarter_sample= get_bits1(gb);
4522 else s->quarter_sample=0;
4524 if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4526 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4528 s->data_partitioning= get_bits1(gb);
4529 if(s->data_partitioning){
4530 s->rvlc= get_bits1(gb);
4533 if(vo_ver_id != 1) {
4534 s->new_pred= get_bits1(gb);
4536 printf("new pred not supported\n");
4537 skip_bits(gb, 2); /* requested upstream message type */
4538 skip_bits1(gb); /* newpred segment type */
4540 s->reduced_res_vop= get_bits1(gb);
4541 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4545 s->reduced_res_vop= 0;
4548 s->scalability= get_bits1(gb);
4550 if (s->scalability) {
4551 GetBitContext bak= *gb;
4553 int ref_layer_sampling_dir;
4554 int h_sampling_factor_n;
4555 int h_sampling_factor_m;
4556 int v_sampling_factor_n;
4557 int v_sampling_factor_m;
4559 s->hierachy_type= get_bits1(gb);
4560 ref_layer_id= get_bits(gb, 4);
4561 ref_layer_sampling_dir= get_bits1(gb);
4562 h_sampling_factor_n= get_bits(gb, 5);
4563 h_sampling_factor_m= get_bits(gb, 5);
4564 v_sampling_factor_n= get_bits(gb, 5);
4565 v_sampling_factor_m= get_bits(gb, 5);
4566 s->enhancement_type= get_bits1(gb);
4568 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
4569 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4571 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4576 printf("scalability not supported\n");
4578 // bin shape stuff FIXME
4585 * decodes the user data stuff in the header.
4586 * allso inits divx/xvid/lavc_version/build
4588 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4592 int ver, build, ver2, ver3;
4595 buf[0]= show_bits(gb, 8);
4596 for(i=1; i<256; i++){
4597 buf[i]= show_bits(gb, 16)&0xFF;
4598 if(buf[i]==0) break;
4603 /* divx detection */
4604 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
4606 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
4608 s->divx_version= ver;
4609 s->divx_build= build;
4610 s->divx_packed= e==3 && last=='p';
4611 if(s->picture_number==0){
4612 printf("This file was encoded with DivX%d Build%d", ver, build);
4620 /* ffmpeg detection */
4621 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4623 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
4625 if(strcmp(buf, "ffmpeg")==0){
4626 s->ffmpeg_version= 0x000406;
4627 s->lavc_build= 4600;
4631 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4632 s->lavc_build= build;
4633 if(s->picture_number==0)
4634 printf("This file was encoded with libavcodec build %d\n", build);
4637 /* xvid detection */
4638 e=sscanf(buf, "XviD%d", &build);
4640 s->xvid_build= build;
4641 if(s->picture_number==0)
4642 printf("This file was encoded with XviD build %d\n", build);
4645 //printf("User Data: %s\n", buf);
4649 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4650 int time_incr, time_increment;
4652 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
4653 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
4654 printf("low_delay flag set, but shouldnt, clearing it\n");
4658 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4659 if(s->partitioned_frame)
4660 s->decode_mb= mpeg4_decode_partitioned_mb;
4662 s->decode_mb= ff_h263_decode_mb;
4664 if(s->time_increment_resolution==0){
4665 s->time_increment_resolution=1;
4666 // fprintf(stderr, "time_increment_resolution is illegal\n");
4669 while (get_bits1(gb) != 0)
4672 check_marker(gb, "before time_increment");
4674 if(s->picture_number==0 && (show_bits(gb, s->time_increment_bits+1)&1)==0){
4675 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4678 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
4679 if(show_bits(gb, s->time_increment_bits+1)&1) break;
4681 printf("my guess is %d bits ;)\n",s->time_increment_bits);
4684 time_increment= get_bits(gb, s->time_increment_bits);
4685 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4686 if(s->pict_type!=B_TYPE){
4687 s->last_time_base= s->time_base;
4688 s->time_base+= time_incr;
4689 s->time= s->time_base*s->time_increment_resolution + time_increment;
4690 if(s->workaround_bugs&FF_BUG_UMP4){
4691 if(s->time < s->last_non_b_time){
4692 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4694 s->time+= s->time_increment_resolution;
4697 s->pp_time= s->time - s->last_non_b_time;
4698 s->last_non_b_time= s->time;
4700 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4701 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4702 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4703 // printf("messed up order, seeking?, skiping current b frame\n");
4704 return FRAME_SKIPED;
4707 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4708 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4709 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4710 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4711 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4712 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
4713 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4716 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4717 if(s->avctx->debug&FF_DEBUG_PTS)
4718 printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4720 check_marker(gb, "before vop_coded");
4723 if (get_bits1(gb) != 1){
4724 printf("vop not coded\n");
4725 return FRAME_SKIPED;
4727 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4728 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4729 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4730 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4731 /* rounding type for motion estimation */
4732 s->no_rounding = get_bits1(gb);
4736 //FIXME reduced res stuff
4738 if (s->shape != RECT_SHAPE) {
4739 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4740 int width, height, hor_spat_ref, ver_spat_ref;
4742 width = get_bits(gb, 13);
4743 skip_bits1(gb); /* marker */
4744 height = get_bits(gb, 13);
4745 skip_bits1(gb); /* marker */
4746 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4747 skip_bits1(gb); /* marker */
4748 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4750 skip_bits1(gb); /* change_CR_disable */
4752 if (get_bits1(gb) != 0) {
4753 skip_bits(gb, 8); /* constant_alpha_value */
4756 //FIXME complexity estimation stuff
4758 if (s->shape != BIN_ONLY_SHAPE) {
4760 t=get_bits(gb, 3); /* intra dc VLC threshold */
4761 //printf("threshold %d\n", t);
4762 if(!s->progressive_sequence){
4763 s->top_field_first= get_bits1(gb);
4764 s->alternate_scan= get_bits1(gb);
4766 s->alternate_scan= 0;
4769 if(s->alternate_scan){
4770 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
4771 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
4772 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
4773 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
4775 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
4776 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
4777 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4778 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
4781 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4782 mpeg4_decode_sprite_trajectory(s);
4783 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4784 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4787 if (s->shape != BIN_ONLY_SHAPE) {
4788 s->qscale = get_bits(gb, s->quant_precision);
4790 printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4791 return -1; // makes no sense to continue, as there is nothing left from the image then
4794 if (s->pict_type != I_TYPE) {
4795 s->f_code = get_bits(gb, 3); /* fcode_for */
4797 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4798 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4803 if (s->pict_type == B_TYPE) {
4804 s->b_code = get_bits(gb, 3);
4808 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4809 printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d\n",
4810 s->qscale, s->f_code, s->b_code,
4811 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4812 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
4813 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4814 s->sprite_warping_accuracy, 1-s->no_rounding);
4817 if(!s->scalability){
4818 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4819 skip_bits1(gb); // vop shape coding type
4822 if(s->enhancement_type){
4823 int load_backward_shape= get_bits1(gb);
4824 if(load_backward_shape){
4825 printf("load backward shape isnt supported\n");
4828 skip_bits(gb, 2); //ref_select_code
4831 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4832 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4833 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4834 printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4838 s->picture_number++; // better than pic number==0 allways ;)
4840 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
4841 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4843 if(!(s->workaround_bugs&FF_BUG_EDGE)){
4844 s->h_edge_pos= s->width;
4845 s->v_edge_pos= s->height;
4851 * decode mpeg4 headers
4852 * @return <0 if no VOP found (or a damaged one)
4853 * FRAME_SKIPPED if a not coded VOP is found
4854 * 0 if a VOP is found
4856 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
4860 /* search next start code */
4864 v = get_bits(gb, 8);
4865 startcode = ((startcode << 8) | v) & 0xffffffff;
4867 if(get_bits_count(gb) >= gb->size_in_bits){
4868 if(gb->size_in_bits==8 && s->divx_version){
4869 printf("frame skip %d\n", gb->size_in_bits);
4870 return FRAME_SKIPED; //divx bug
4872 return -1; //end of stream
4875 if((startcode&0xFFFFFF00) != 0x100)
4876 continue; //no startcode
4878 if(s->avctx->debug&FF_DEBUG_STARTCODE){
4879 printf("startcode: %3X ", startcode);
4880 if (startcode<=0x11F) printf("Video Object Start");
4881 else if(startcode<=0x12F) printf("Video Object Layer Start");
4882 else if(startcode<=0x13F) printf("Reserved");
4883 else if(startcode<=0x15F) printf("FGS bp start");
4884 else if(startcode<=0x1AF) printf("Reserved");
4885 else if(startcode==0x1B0) printf("Visual Object Seq Start");
4886 else if(startcode==0x1B1) printf("Visual Object Seq End");
4887 else if(startcode==0x1B2) printf("User Data");
4888 else if(startcode==0x1B3) printf("Group of VOP start");
4889 else if(startcode==0x1B4) printf("Video Session Error");
4890 else if(startcode==0x1B5) printf("Visual Object Start");
4891 else if(startcode==0x1B6) printf("Video Object Plane start");
4892 else if(startcode==0x1B7) printf("slice start");
4893 else if(startcode==0x1B8) printf("extension start");
4894 else if(startcode==0x1B9) printf("fgs start");
4895 else if(startcode==0x1BA) printf("FBA Object start");
4896 else if(startcode==0x1BB) printf("FBA Object Plane start");
4897 else if(startcode==0x1BC) printf("Mesh Object start");
4898 else if(startcode==0x1BD) printf("Mesh Object Plane start");
4899 else if(startcode==0x1BE) printf("Still Textutre Object start");
4900 else if(startcode==0x1BF) printf("Textutre Spatial Layer start");
4901 else if(startcode==0x1C0) printf("Textutre SNR Layer start");
4902 else if(startcode==0x1C1) printf("Textutre Tile start");
4903 else if(startcode==0x1C2) printf("Textutre Shape Layer start");
4904 else if(startcode==0x1C3) printf("stuffing start");
4905 else if(startcode<=0x1C5) printf("reserved");
4906 else if(startcode<=0x1FF) printf("System start");
4907 printf(" at %d\n", get_bits_count(gb));
4912 decode_vol_header(s, gb);
4914 case USER_DATA_STARTCODE:
4915 decode_user_data(s, gb);
4918 mpeg4_decode_gop_header(s, gb);
4921 return decode_vop_header(s, gb);
4931 /* don't understand why they choose a different header ! */
4932 int intel_h263_decode_picture_header(MpegEncContext *s)
4936 /* picture header */
4937 if (get_bits_long(&s->gb, 22) != 0x20) {
4938 fprintf(stderr, "Bad picture start code\n");
4941 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4943 if (get_bits1(&s->gb) != 1) {
4944 fprintf(stderr, "Bad marker\n");
4945 return -1; /* marker */
4947 if (get_bits1(&s->gb) != 0) {
4948 fprintf(stderr, "Bad H263 id\n");
4949 return -1; /* h263 id */
4951 skip_bits1(&s->gb); /* split screen off */
4952 skip_bits1(&s->gb); /* camera off */
4953 skip_bits1(&s->gb); /* freeze picture release off */
4955 format = get_bits(&s->gb, 3);
4957 fprintf(stderr, "Intel H263 free format not supported\n");
4962 s->pict_type = I_TYPE + get_bits1(&s->gb);
4964 s->unrestricted_mv = get_bits1(&s->gb);
4965 s->h263_long_vectors = s->unrestricted_mv;
4967 if (get_bits1(&s->gb) != 0) {
4968 fprintf(stderr, "SAC not supported\n");
4969 return -1; /* SAC: off */
4971 if (get_bits1(&s->gb) != 0) {
4972 fprintf(stderr, "Advanced Prediction Mode not supported\n");
4973 return -1; /* advanced prediction mode: off */
4975 if (get_bits1(&s->gb) != 0) {
4976 fprintf(stderr, "PB frame mode no supported\n");
4977 return -1; /* PB frame mode */
4980 /* skip unknown header garbage */
4981 skip_bits(&s->gb, 41);
4983 s->qscale = get_bits(&s->gb, 5);
4984 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4987 while (get_bits1(&s->gb) != 0) {
4988 skip_bits(&s->gb, 8);
4992 s->y_dc_scale_table=
4993 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;