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 7
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 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
73 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
74 #endif //CONFIG_ENCODERS
75 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
76 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
78 #ifdef CONFIG_ENCODERS
79 static uint8_t uni_DCtab_lum_len[512];
80 static uint8_t uni_DCtab_chrom_len[512];
81 static uint16_t uni_DCtab_lum_bits[512];
82 static uint16_t uni_DCtab_chrom_bits[512];
84 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
85 static uint8_t fcode_tab[MAX_MV*2+1];
86 static uint8_t umv_fcode_tab[MAX_MV*2+1];
88 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
89 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
90 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
91 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
92 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
93 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
94 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
107 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit
108 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
113 int h263_get_picture_format(int width, int height)
117 if (width == 128 && height == 96)
119 else if (width == 176 && height == 144)
121 else if (width == 352 && height == 288)
123 else if (width == 704 && height == 576)
125 else if (width == 1408 && height == 1152)
132 #ifdef CONFIG_ENCODERS
134 static void float_aspect_to_info(MpegEncContext * s, float aspect){
137 aspect*= s->height/(double)s->width;
138 //printf("%f\n", aspect);
140 if(aspect==0) aspect= 1.0;
142 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
144 //printf("%d %d\n", s->aspected_width, s->aspected_height);
146 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
147 s->aspect_ratio_info=i;
152 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
155 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
159 align_put_bits(&s->pb);
161 put_bits(&s->pb, 17, 1);
162 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
163 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
164 s->avctx->frame_rate) & 0xff); /* TemporalReference */
165 if (s->width == 352 && s->height == 288)
167 else if (s->width == 176 && s->height == 144)
169 else if (s->width == 128 && s->height == 96)
171 else if (s->width == 320 && s->height == 240)
173 else if (s->width == 160 && s->height == 120)
175 else if (s->width <= 255 && s->height <= 255)
176 format = 0; /* use 1 byte width & height */
178 format = 1; /* use 2 bytes width & height */
179 put_bits(&s->pb, 3, format); /* PictureSize */
181 put_bits(&s->pb, 8, s->width);
182 put_bits(&s->pb, 8, s->height);
183 } else if (format == 1) {
184 put_bits(&s->pb, 16, s->width);
185 put_bits(&s->pb, 16, s->height);
187 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
188 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
189 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
190 put_bits(&s->pb, 1, 0); /* ExtraInformation */
194 s->c_dc_scale_table= h263_aic_dc_scale_table;
197 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
201 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
205 align_put_bits(&s->pb);
207 /* Update the pointer to last GOB */
208 s->ptr_lastgob = pbBufPtr(&s->pb);
211 put_bits(&s->pb, 22, 0x20); /* PSC */
212 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
213 s->avctx->frame_rate) & 0xff);
215 put_bits(&s->pb, 1, 1); /* marker */
216 put_bits(&s->pb, 1, 0); /* h263 id */
217 put_bits(&s->pb, 1, 0); /* split screen off */
218 put_bits(&s->pb, 1, 0); /* camera off */
219 put_bits(&s->pb, 1, 0); /* freeze picture release off */
221 format = h263_get_picture_format(s->width, s->height);
224 put_bits(&s->pb, 3, format);
225 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
226 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
227 of H.263v1 UMV implies to check the predicted MV after
228 calculation of the current MB to see if we're on the limits */
229 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
230 put_bits(&s->pb, 1, 0); /* SAC: off */
231 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
232 put_bits(&s->pb, 1, 0); /* not PB frame */
233 put_bits(&s->pb, 5, s->qscale);
234 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
237 /* H.263 Plus PTYPE */
238 put_bits(&s->pb, 3, 7);
239 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
241 put_bits(&s->pb,3,6); /* Custom Source Format */
243 put_bits(&s->pb, 3, format);
245 put_bits(&s->pb,1,0); /* Custom PCF: off */
246 s->umvplus = s->unrestricted_mv;
247 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
248 put_bits(&s->pb,1,0); /* SAC: off */
249 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
250 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
251 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
252 put_bits(&s->pb,1,0); /* Slice Structured: off */
253 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
254 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
255 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
256 put_bits(&s->pb,1,0); /* Modified Quantization: off */
257 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
258 put_bits(&s->pb,3,0); /* Reserved */
260 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
262 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
263 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
264 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
265 put_bits(&s->pb,2,0); /* Reserved */
266 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
268 /* This should be here if PLUSPTYPE */
269 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
272 /* Custom Picture Format (CPFMT) */
273 float_aspect_to_info(s, s->avctx->aspect_ratio);
275 put_bits(&s->pb,4,s->aspect_ratio_info);
276 put_bits(&s->pb,9,(s->width >> 2) - 1);
277 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278 put_bits(&s->pb,9,(s->height >> 2));
279 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
281 put_bits(&s->pb, 8, s->aspected_width);
282 put_bits(&s->pb, 8, s->aspected_height);
286 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
288 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
289 put_bits(&s->pb,2,1); /* unlimited */
291 put_bits(&s->pb, 5, s->qscale);
294 put_bits(&s->pb, 1, 0); /* no PEI */
298 s->c_dc_scale_table= h263_aic_dc_scale_table;
301 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
306 * Encodes a group of blocks header.
308 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
310 align_put_bits(&s->pb);
311 flush_put_bits(&s->pb);
312 /* Call the RTP callback to send the last GOB */
313 if (s->rtp_callback) {
314 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
315 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
317 put_bits(&s->pb, 17, 1); /* GBSC */
318 s->gob_number = mb_line / s->gob_index;
319 put_bits(&s->pb, 5, s->gob_number); /* GN */
320 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
321 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
322 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
326 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
328 int score0=0, score1=0;
330 int8_t * const qscale_table= s->current_picture.qscale_table;
333 int16_t *ac_val, *ac_val1;
335 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
338 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
340 ac_val-= s->block_wrap[n]*16;
341 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
344 const int level= block[n][s->dsp.idct_permutation[i ]];
346 score1+= ABS(level - ac_val[i+8]);
347 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
351 /* different qscale, we must rescale */
353 const int level= block[n][s->dsp.idct_permutation[i ]];
355 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
356 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
361 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
362 /* left prediction */
364 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
367 const int level= block[n][s->dsp.idct_permutation[i<<3]];
369 score1+= ABS(level - ac_val[i]);
371 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
374 /* different qscale, we must rescale */
376 const int level= block[n][s->dsp.idct_permutation[i<<3]];
378 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
380 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
386 return score0 > score1 ? 1 : 0;
390 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
392 void ff_clean_h263_qscales(MpegEncContext *s){
394 int8_t * const qscale_table= s->current_picture.qscale_table;
396 for(i=1; i<s->mb_num; i++){
397 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
398 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
400 for(i=s->mb_num-2; i>=0; i--){
401 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
402 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
407 * modify mb_type & qscale so that encoding is acually possible in mpeg4
409 void ff_clean_mpeg4_qscales(MpegEncContext *s){
411 int8_t * const qscale_table= s->current_picture.qscale_table;
413 ff_clean_h263_qscales(s);
415 for(i=1; i<s->mb_num; i++){
416 int mb_xy= s->mb_index2xy[i];
418 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
419 s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
420 s->mb_type[mb_xy]|= MB_TYPE_INTER;
424 if(s->pict_type== B_TYPE){
426 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
427 for the actual adaptive quantization */
429 for(i=0; i<s->mb_num; i++){
430 int mb_xy= s->mb_index2xy[i];
431 odd += qscale_table[mb_xy]&1;
434 if(2*odd > s->mb_num) odd=1;
437 for(i=0; i<s->mb_num; i++){
438 int mb_xy= s->mb_index2xy[i];
439 if((qscale_table[mb_xy]&1) != odd)
440 qscale_table[mb_xy]++;
441 if(qscale_table[mb_xy] > 31)
442 qscale_table[mb_xy]= 31;
445 for(i=1; i<s->mb_num; i++){
446 int mb_xy= s->mb_index2xy[i];
447 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
448 s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
449 s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
455 #endif //CONFIG_ENCODERS
458 * @return the mb_type
460 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
461 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
462 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
463 int xy= s->block_index[0];
464 uint16_t time_pp= s->pp_time;
465 uint16_t time_pb= s->pb_time;
468 //FIXME avoid divides
470 if(IS_8X8(colocated_mb_type)){
471 s->mv_type = MV_TYPE_8X8;
473 xy= s->block_index[i];
474 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
475 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
476 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
477 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
478 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
479 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
481 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
482 } else if(IS_INTERLACED(colocated_mb_type)){
483 s->mv_type = MV_TYPE_FIELD;
485 if(s->top_field_first){
486 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
487 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
489 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
490 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
492 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
493 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
494 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
495 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
496 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
497 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
499 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
501 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;
502 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;
503 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]
504 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
505 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]
506 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
507 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
508 s->mv_type= MV_TYPE_16X16;
510 s->mv_type= MV_TYPE_8X8;
511 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
515 void ff_h263_update_motion_val(MpegEncContext * s){
516 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
517 //FIXME a lot of thet is only needed for !low_delay
518 const int wrap = s->block_wrap[0];
519 const int xy = s->block_index[0];
521 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
523 if(s->mv_type != MV_TYPE_8X8){
524 int motion_x, motion_y;
528 } else if (s->mv_type == MV_TYPE_16X16) {
529 motion_x = s->mv[0][0][0];
530 motion_y = s->mv[0][0][1];
531 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
533 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
534 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
535 motion_x = (motion_x>>1) | (motion_x&1);
537 s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
538 s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
539 s->field_select_table[mb_xy][i]= s->field_select[0][i];
543 /* no update if 8X8 because it has been done during parsing */
544 s->motion_val[xy][0] = motion_x;
545 s->motion_val[xy][1] = motion_y;
546 s->motion_val[xy + 1][0] = motion_x;
547 s->motion_val[xy + 1][1] = motion_y;
548 s->motion_val[xy + wrap][0] = motion_x;
549 s->motion_val[xy + wrap][1] = motion_y;
550 s->motion_val[xy + 1 + wrap][0] = motion_x;
551 s->motion_val[xy + 1 + wrap][1] = motion_y;
554 if(s->encoding){ //FIXME encoding MUST be cleaned up
555 if (s->mv_type == MV_TYPE_8X8)
556 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
558 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
562 #ifdef CONFIG_ENCODERS
563 void mpeg4_encode_mb(MpegEncContext * s,
564 DCTELEM block[6][64],
565 int motion_x, int motion_y)
567 int cbpc, cbpy, pred_x, pred_y;
568 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
569 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
570 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
571 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
572 const int dquant_code[5]= {1,0,9,2,3};
574 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
578 for (i = 0; i < 6; i++) {
579 if (s->block_last_index[i] >= 0)
583 if(s->pict_type==B_TYPE){
584 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
585 int mb_type= mb_type_table[s->mv_dir];
591 s->last_mv[1][0][1]= 0;
594 assert(s->dquant>=-2 && s->dquant<=2);
595 assert((s->dquant&1)==0);
598 /* nothing to do if this MB was skiped in the next P Frame */
599 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
605 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
606 s->qscale -= s->dquant;
612 if ((cbp | motion_x | motion_y | mb_type) ==0) {
613 /* direct MB with MV={0,0} */
614 assert(s->dquant==0);
616 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
618 if(interleaved_stats){
626 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
627 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
628 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
629 if(cbp) put_bits(&s->pb, 6, cbp);
633 put_bits(&s->pb, 2, (s->dquant>>2)+3);
635 put_bits(&s->pb, 1, 0);
637 s->qscale -= s->dquant;
639 if(!s->progressive_sequence){
641 put_bits(&s->pb, 1, s->interlaced_dct);
642 if(mb_type) // not diect mode
643 put_bits(&s->pb, 1, 0); // no interlaced ME yet
646 if(interleaved_stats){
647 s->misc_bits+= get_bits_diff(s);
653 h263_encode_motion(s, motion_x, 1);
654 h263_encode_motion(s, motion_y, 1);
659 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
660 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
661 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
662 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
663 s->last_mv[0][0][0]= s->mv[0][0][0];
664 s->last_mv[0][0][1]= s->mv[0][0][1];
665 s->last_mv[1][0][0]= s->mv[1][0][0];
666 s->last_mv[1][0][1]= s->mv[1][0][1];
670 case 2: /* backward */
671 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
672 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
673 s->last_mv[1][0][0]= motion_x;
674 s->last_mv[1][0][1]= motion_y;
677 case 3: /* forward */
678 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
679 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
680 s->last_mv[0][0][0]= motion_x;
681 s->last_mv[0][0][1]= motion_y;
685 printf("unknown mb type\n");
689 if(interleaved_stats){
690 s->mv_bits+= get_bits_diff(s);
693 /* encode each block */
694 for (i = 0; i < 6; i++) {
695 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
698 if(interleaved_stats){
699 s->p_tex_bits+= get_bits_diff(s);
701 }else{ /* s->pict_type==B_TYPE */
702 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
703 /* check if the B frames can skip it too, as we must skip it if we skip here
704 why didnt they just compress the skip-mb bits instead of reusing them ?! */
705 if(s->max_b_frames>0){
712 if(x+16 > s->width) x= s->width-16;
713 if(y+16 > s->height) y= s->height-16;
715 offset= x + y*s->linesize;
716 p_pic= s->new_picture.data[0] + offset;
719 for(i=0; i<s->max_b_frames; i++){
722 Picture *pic= s->reordered_input_picture[i+1];
724 if(pic==NULL || pic->pict_type!=B_TYPE) break;
726 b_pic= pic->data[0] + offset + 16; //FIXME +16
727 diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
728 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
737 /* skip macroblock */
738 put_bits(&s->pb, 1, 1);
740 if(interleaved_stats){
750 put_bits(&s->pb, 1, 0); /* mb coded */
751 if(s->mv_type==MV_TYPE_16X16){
753 if(s->dquant) cbpc+= 8;
755 inter_MCBPC_bits[cbpc],
756 inter_MCBPC_code[cbpc]);
760 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
762 put_bits(pb2, 2, dquant_code[s->dquant+2]);
764 if(!s->progressive_sequence){
766 put_bits(pb2, 1, s->interlaced_dct);
767 put_bits(pb2, 1, 0); // no interlaced ME yet
770 if(interleaved_stats){
771 s->misc_bits+= get_bits_diff(s);
774 /* motion vectors: 16x16 mode */
775 h263_pred_motion(s, 0, &pred_x, &pred_y);
777 h263_encode_motion(s, motion_x - pred_x, s->f_code);
778 h263_encode_motion(s, motion_y - pred_y, s->f_code);
782 inter_MCBPC_bits[cbpc],
783 inter_MCBPC_code[cbpc]);
786 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
788 if(!s->progressive_sequence){
790 put_bits(pb2, 1, s->interlaced_dct);
793 if(interleaved_stats){
794 s->misc_bits+= get_bits_diff(s);
798 /* motion vectors: 8x8 mode*/
799 h263_pred_motion(s, i, &pred_x, &pred_y);
801 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
802 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
806 if(interleaved_stats){
807 s->mv_bits+= get_bits_diff(s);
810 /* encode each block */
811 for (i = 0; i < 6; i++) {
812 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
815 if(interleaved_stats){
816 s->p_tex_bits+= get_bits_diff(s);
822 int dc_diff[6]; //dc values with the dc prediction subtracted
823 int dir[6]; //prediction direction
824 int zigzag_last_index[6];
825 uint8_t *scan_table[6];
829 const int level= block[i][0];
832 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
834 *dc_ptr = level * s->y_dc_scale;
836 *dc_ptr = level * s->c_dc_scale;
840 s->ac_pred= decide_ac_pred(s, block, dir);
847 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
848 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
849 else st = s->intra_h_scantable.permutated; /* top */
851 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
852 if(block[i][st[last_index]]) break;
853 zigzag_last_index[i]= s->block_last_index[i];
854 s->block_last_index[i]= last_index;
859 scan_table[i]= s->intra_scantable.permutated;
864 for (i = 0; i < 6; i++) {
865 if (s->block_last_index[i] >= 1)
870 if (s->pict_type == I_TYPE) {
871 if(s->dquant) cbpc+=4;
873 intra_MCBPC_bits[cbpc],
874 intra_MCBPC_code[cbpc]);
876 if(s->dquant) cbpc+=8;
877 put_bits(&s->pb, 1, 0); /* mb coded */
879 inter_MCBPC_bits[cbpc + 4],
880 inter_MCBPC_code[cbpc + 4]);
882 put_bits(pb2, 1, s->ac_pred);
884 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
886 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
888 if(!s->progressive_sequence){
889 put_bits(dc_pb, 1, s->interlaced_dct);
892 if(interleaved_stats){
893 s->misc_bits+= get_bits_diff(s);
896 /* encode each block */
897 for (i = 0; i < 6; i++) {
898 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
901 if(interleaved_stats){
902 s->i_tex_bits+= get_bits_diff(s);
906 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
912 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
916 block[i][s->dsp.idct_permutation[j ]]= ac_val[j+8];
919 block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j ];
921 s->block_last_index[i]= zigzag_last_index[i];
927 void h263_encode_mb(MpegEncContext * s,
928 DCTELEM block[6][64],
929 int motion_x, int motion_y)
931 int cbpc, cbpy, i, cbp, pred_x, pred_y;
933 int16_t rec_intradc[6];
935 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
936 const int dquant_code[5]= {1,0,9,2,3};
938 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
942 for (i = 0; i < 6; i++) {
943 if (s->block_last_index[i] >= 0)
946 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
947 /* skip macroblock */
948 put_bits(&s->pb, 1, 1);
949 if(interleaved_stats){
955 put_bits(&s->pb, 1, 0); /* mb coded */
957 if(s->dquant) cbpc+= 8;
959 inter_MCBPC_bits[cbpc],
960 inter_MCBPC_code[cbpc]);
963 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
965 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
967 if(interleaved_stats){
968 s->misc_bits+= get_bits_diff(s);
971 /* motion vectors: 16x16 mode only now */
972 h263_pred_motion(s, 0, &pred_x, &pred_y);
975 h263_encode_motion(s, motion_x - pred_x, s->f_code);
976 h263_encode_motion(s, motion_y - pred_y, s->f_code);
979 h263p_encode_umotion(s, motion_x - pred_x);
980 h263p_encode_umotion(s, motion_y - pred_y);
981 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
982 /* To prevent Start Code emulation */
983 put_bits(&s->pb,1,1);
986 if(interleaved_stats){
987 s->mv_bits+= get_bits_diff(s);
990 int li = s->h263_aic ? 0 : 1;
995 if (s->h263_aic && s->mb_intra) {
996 int16_t level = block[i][0];
998 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1002 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
1004 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
1006 /* AIC can change CBP */
1007 if (level == 0 && s->block_last_index[i] == 0)
1008 s->block_last_index[i] = -1;
1009 else if (level < -127)
1011 else if (level > 127)
1014 block[i][0] = level;
1015 /* Reconstruction */
1016 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
1018 rec_intradc[i] |= 1;
1019 //if ((rec_intradc[i] % 2) == 0)
1020 // rec_intradc[i]++;
1022 if (rec_intradc[i] < 0)
1024 else if (rec_intradc[i] > 2047)
1025 rec_intradc[i] = 2047;
1027 /* Update AC/DC tables */
1028 *dc_ptr[i] = rec_intradc[i];
1031 if (s->block_last_index[i] >= li)
1032 cbp |= 1 << (5 - i);
1036 if (s->pict_type == I_TYPE) {
1037 if(s->dquant) cbpc+=4;
1039 intra_MCBPC_bits[cbpc],
1040 intra_MCBPC_code[cbpc]);
1042 if(s->dquant) cbpc+=8;
1043 put_bits(&s->pb, 1, 0); /* mb coded */
1045 inter_MCBPC_bits[cbpc + 4],
1046 inter_MCBPC_code[cbpc + 4]);
1049 /* XXX: currently, we do not try to use ac prediction */
1050 put_bits(&s->pb, 1, 0); /* no AC prediction */
1053 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1055 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1057 if(interleaved_stats){
1058 s->misc_bits+= get_bits_diff(s);
1062 for(i=0; i<6; i++) {
1063 /* encode each block */
1064 h263_encode_block(s, block[i], i);
1066 /* Update INTRADC for decoding */
1067 if (s->h263_aic && s->mb_intra) {
1068 block[i][0] = rec_intradc[i];
1073 if(interleaved_stats){
1075 s->p_tex_bits+= get_bits_diff(s);
1078 s->i_tex_bits+= get_bits_diff(s);
1085 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1087 int x, y, wrap, a, c, pred_dc, scale;
1088 int16_t *dc_val, *ac_val;
1090 /* find prediction */
1092 x = 2 * s->mb_x + 1 + (n & 1);
1093 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1094 wrap = s->mb_width * 2 + 2;
1095 dc_val = s->dc_val[0];
1096 ac_val = s->ac_val[0][0];
1097 scale = s->y_dc_scale;
1101 wrap = s->mb_width + 2;
1102 dc_val = s->dc_val[n - 4 + 1];
1103 ac_val = s->ac_val[n - 4 + 1][0];
1104 scale = s->c_dc_scale;
1109 a = dc_val[(x - 1) + (y) * wrap];
1110 c = dc_val[(x) + (y - 1) * wrap];
1112 /* No prediction outside GOB boundary */
1113 if (s->first_slice_line && ((n < 2) || (n > 3)))
1116 /* just DC prediction */
1117 if (a != 1024 && c != 1024)
1118 pred_dc = (a + c) >> 1;
1124 /* we assume pred is positive */
1125 //pred_dc = (pred_dc + (scale >> 1)) / scale;
1126 *dc_val_ptr = &dc_val[x + y * wrap];
1130 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1132 int x, y, wrap, a, c, pred_dc, scale, i;
1133 int16_t *dc_val, *ac_val, *ac_val1;
1135 /* find prediction */
1137 x = 2 * s->mb_x + 1 + (n & 1);
1138 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1139 wrap = s->mb_width * 2 + 2;
1140 dc_val = s->dc_val[0];
1141 ac_val = s->ac_val[0][0];
1142 scale = s->y_dc_scale;
1146 wrap = s->mb_width + 2;
1147 dc_val = s->dc_val[n - 4 + 1];
1148 ac_val = s->ac_val[n - 4 + 1][0];
1149 scale = s->c_dc_scale;
1152 ac_val += ((y) * wrap + (x)) * 16;
1158 a = dc_val[(x - 1) + (y) * wrap];
1159 c = dc_val[(x) + (y - 1) * wrap];
1161 /* No prediction outside GOB boundary */
1162 if (s->first_slice_line && ((n < 2) || (n > 3)))
1166 if (s->h263_aic_dir) {
1167 /* left prediction */
1171 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1176 /* top prediction */
1178 ac_val -= 16 * wrap;
1180 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1186 /* just DC prediction */
1187 if (a != 1024 && c != 1024)
1188 pred_dc = (a + c) >> 1;
1195 /* we assume pred is positive */
1196 block[0]=block[0]*scale + pred_dc;
1200 else if (!(block[0] & 1))
1203 /* Update AC/DC tables */
1204 dc_val[(x) + (y) * wrap] = block[0];
1208 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1211 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1214 int16_t *h263_pred_motion(MpegEncContext * s, int block,
1218 int16_t *A, *B, *C, *mot_val;
1219 static const int off[4]= {2, 1, 1, -1};
1221 wrap = s->block_wrap[0];
1222 xy = s->block_index[block];
1224 mot_val = s->motion_val[xy];
1226 A = s->motion_val[xy - 1];
1227 /* special case for first (slice) line */
1228 if (s->first_slice_line && block<3) {
1229 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1230 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1231 if(block==0){ //most common case
1232 if(s->mb_x == s->resync_mb_x){ //rare
1234 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1235 C = s->motion_val[xy + off[block] - wrap];
1240 *px = mid_pred(A[0], 0, C[0]);
1241 *py = mid_pred(A[1], 0, C[1]);
1248 if(s->mb_x + 1 == s->resync_mb_x){ //rare
1249 C = s->motion_val[xy + off[block] - wrap];
1250 *px = mid_pred(A[0], 0, C[0]);
1251 *py = mid_pred(A[1], 0, C[1]);
1256 }else{ /* block==2*/
1257 B = s->motion_val[xy - wrap];
1258 C = s->motion_val[xy + off[block] - wrap];
1259 if(s->mb_x == s->resync_mb_x) //rare
1262 *px = mid_pred(A[0], B[0], C[0]);
1263 *py = mid_pred(A[1], B[1], C[1]);
1266 B = s->motion_val[xy - wrap];
1267 C = s->motion_val[xy + off[block] - wrap];
1268 *px = mid_pred(A[0], B[0], C[0]);
1269 *py = mid_pred(A[1], B[1], C[1]);
1274 #ifdef CONFIG_ENCODERS
1275 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1277 int range, l, bit_size, sign, code, bits;
1282 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1284 bit_size = f_code - 1;
1285 range = 1 << bit_size;
1286 /* modulo encoding */
1293 val= (val^sign)-sign;
1298 } else if (val >= l) {
1302 assert(val>=-l && val<l);
1312 code = (val >> bit_size) + 1;
1313 bits = val & (range - 1);
1315 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1317 put_bits(&s->pb, bit_size, bits);
1323 /* Encode MV differences on H.263+ with Unrestricted MV mode */
1324 static void h263p_encode_umotion(MpegEncContext * s, int val)
1334 put_bits(&s->pb, 1, 1);
1336 put_bits(&s->pb, 3, 0);
1338 put_bits(&s->pb, 3, 2);
1341 sval = ((val < 0) ? (short)(-val):(short)val);
1344 while (temp_val != 0) {
1345 temp_val = temp_val >> 1;
1351 tcode = (sval & (1 << (i-1))) >> (i-1);
1352 tcode = (tcode << 1) | 1;
1353 code = (code << 2) | tcode;
1356 code = ((code << 1) | (val < 0)) << 1;
1357 put_bits(&s->pb, (2*n_bits)+1, code);
1358 //printf("\nVal = %d\tCode = %d", sval, code);
1362 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1367 if(mv_penalty==NULL)
1368 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1370 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1371 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1374 if(mv==0) len= mvtab[0][1];
1376 int val, bit_size, range, code;
1378 bit_size = s->f_code - 1;
1379 range = 1 << bit_size;
1385 code = (val >> bit_size) + 1;
1387 len= mvtab[code][1] + 1 + bit_size;
1389 len= mvtab[32][1] + 2 + bit_size;
1393 mv_penalty[f_code][mv+MAX_MV]= len;
1397 for(f_code=MAX_FCODE; f_code>0; f_code--){
1398 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1399 fcode_tab[mv+MAX_MV]= f_code;
1403 for(mv=0; mv<MAX_MV*2+1; mv++){
1404 umv_fcode_tab[mv]= 1;
1409 #ifdef CONFIG_ENCODERS
1411 static void init_uni_dc_tab(void)
1413 int level, uni_code, uni_len;
1415 for(level=-256; level<256; level++){
1417 /* find number of bits */
1426 l= (-level) ^ ((1 << size) - 1);
1431 uni_code= DCtab_lum[size][0];
1432 uni_len = DCtab_lum[size][1];
1435 uni_code<<=size; uni_code|=l;
1438 uni_code<<=1; uni_code|=1;
1442 uni_DCtab_lum_bits[level+256]= uni_code;
1443 uni_DCtab_lum_len [level+256]= uni_len;
1446 uni_code= DCtab_chrom[size][0];
1447 uni_len = DCtab_chrom[size][1];
1450 uni_code<<=size; uni_code|=l;
1453 uni_code<<=1; uni_code|=1;
1457 uni_DCtab_chrom_bits[level+256]= uni_code;
1458 uni_DCtab_chrom_len [level+256]= uni_len;
1463 #endif //CONFIG_ENCODERS
1465 #ifdef CONFIG_ENCODERS
1466 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1467 int slevel, run, last;
1469 assert(MAX_LEVEL >= 64);
1470 assert(MAX_RUN >= 63);
1472 for(slevel=-64; slevel<64; slevel++){
1473 if(slevel==0) continue;
1474 for(run=0; run<64; run++){
1475 for(last=0; last<=1; last++){
1476 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1477 int level= slevel < 0 ? -slevel : slevel;
1478 int sign= slevel < 0 ? 1 : 0;
1479 int bits, len, code;
1482 len_tab[index]= 100;
1485 code= get_rl_index(rl, last, run, level);
1486 bits= rl->table_vlc[code][0];
1487 len= rl->table_vlc[code][1];
1488 bits=bits*2+sign; len++;
1490 if(code!=rl->n && len < len_tab[index]){
1491 bits_tab[index]= bits;
1492 len_tab [index]= len;
1496 bits= rl->table_vlc[rl->n][0];
1497 len= rl->table_vlc[rl->n][1];
1498 bits=bits*2; len++; //esc1
1499 level1= level - rl->max_level[last][run];
1501 code= get_rl_index(rl, last, run, level1);
1502 bits<<= rl->table_vlc[code][1];
1503 len += rl->table_vlc[code][1];
1504 bits += rl->table_vlc[code][0];
1505 bits=bits*2+sign; len++;
1507 if(code!=rl->n && len < len_tab[index]){
1508 bits_tab[index]= bits;
1509 len_tab [index]= len;
1515 bits= rl->table_vlc[rl->n][0];
1516 len= rl->table_vlc[rl->n][1];
1517 bits=bits*4+2; len+=2; //esc2
1518 run1 = run - rl->max_run[last][level] - 1;
1520 code= get_rl_index(rl, last, run1, level);
1521 bits<<= rl->table_vlc[code][1];
1522 len += rl->table_vlc[code][1];
1523 bits += rl->table_vlc[code][0];
1524 bits=bits*2+sign; len++;
1526 if(code!=rl->n && len < len_tab[index]){
1527 bits_tab[index]= bits;
1528 len_tab [index]= len;
1533 bits= rl->table_vlc[rl->n][0];
1534 len = rl->table_vlc[rl->n][1];
1535 bits=bits*4+3; len+=2; //esc3
1536 bits=bits*2+last; len++;
1537 bits=bits*64+run; len+=6;
1538 bits=bits*2+1; len++; //marker
1539 bits=bits*4096+(slevel&0xfff); len+=12;
1540 bits=bits*2+1; len++; //marker
1542 if(len < len_tab[index]){
1543 bits_tab[index]= bits;
1544 len_tab [index]= len;
1551 void h263_encode_init(MpegEncContext *s)
1553 static int done = 0;
1562 init_rl(&rl_intra_aic);
1564 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1565 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1567 init_mv_penalty_and_fcode(s);
1569 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1571 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1572 switch(s->codec_id){
1573 case CODEC_ID_MPEG4:
1574 s->fcode_tab= fcode_tab;
1575 s->min_qcoeff= -2048;
1576 s->max_qcoeff= 2047;
1577 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
1578 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1579 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
1580 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1581 s->luma_dc_vlc_length= uni_DCtab_lum_len;
1582 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1583 s->ac_esc_length= 7+2+1+6+1+12+1;
1585 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1587 s->avctx->extradata= av_malloc(1024);
1588 init_put_bits(&s->pb, s->avctx->extradata, 1024, NULL, NULL);
1590 mpeg4_encode_visual_object_header(s);
1591 mpeg4_encode_vol_header(s, 0, 0);
1593 // ff_mpeg4_stuffing(&s->pb); ?
1594 flush_put_bits(&s->pb);
1595 s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3;
1599 case CODEC_ID_H263P:
1600 s->fcode_tab= umv_fcode_tab;
1601 s->min_qcoeff= -127;
1604 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1606 if (s->h263_flv > 1) {
1607 s->min_qcoeff= -1023;
1608 s->max_qcoeff= 1023;
1610 s->min_qcoeff= -127;
1613 s->y_dc_scale_table=
1614 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1616 default: //nothing needed default table allready set in mpegvideo.c
1617 s->min_qcoeff= -127;
1619 s->y_dc_scale_table=
1620 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1625 * encodes a 8x8 block.
1626 * @param block the 8x8 block
1627 * @param n block index (0-3 are luma, 4-5 are chroma)
1629 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1631 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1635 if (s->mb_intra && !s->h263_aic) {
1638 /* 255 cannot be represented, so we clamp */
1643 /* 0 cannot be represented also */
1644 else if (level < 1) {
1648 if (level == 128) //FIXME check rv10
1649 put_bits(&s->pb, 8, 0xff);
1651 put_bits(&s->pb, 8, level & 0xff);
1655 if (s->h263_aic && s->mb_intra)
1660 last_index = s->block_last_index[n];
1661 last_non_zero = i - 1;
1662 for (; i <= last_index; i++) {
1663 j = s->intra_scantable.permutated[i];
1666 run = i - last_non_zero - 1;
1667 last = (i == last_index);
1674 code = get_rl_index(rl, last, run, level);
1675 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1676 if (code == rl->n) {
1677 if(s->h263_flv <= 1){
1678 put_bits(&s->pb, 1, last);
1679 put_bits(&s->pb, 6, run);
1681 assert(slevel != 0);
1683 if(slevel < 128 && slevel > -128)
1684 put_bits(&s->pb, 8, slevel & 0xff);
1686 put_bits(&s->pb, 8, 128);
1687 put_bits(&s->pb, 5, slevel & 0x1f);
1688 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1691 if(slevel < 64 && slevel > -64) {
1693 put_bits(&s->pb, 1, 0);
1694 put_bits(&s->pb, 1, last);
1695 put_bits(&s->pb, 6, run);
1697 put_bits(&s->pb, 7, slevel & 0x7f);
1700 put_bits(&s->pb, 1, 1);
1701 put_bits(&s->pb, 1, last);
1702 put_bits(&s->pb, 6, run);
1704 put_bits(&s->pb, 11, slevel & 0x7ff);
1708 put_bits(&s->pb, 1, sign);
1716 #ifdef CONFIG_ENCODERS
1718 /***************************************************/
1720 * add mpeg4 stuffing bits (01...1)
1722 void ff_mpeg4_stuffing(PutBitContext * pbc)
1725 put_bits(pbc, 1, 0);
1726 length= (-get_bit_count(pbc))&7;
1727 if(length) put_bits(pbc, length, (1<<length)-1);
1730 /* must be called before writing the header */
1731 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1732 int time_div, time_mod;
1734 if(s->current_picture.pts)
1735 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1737 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1738 time_div= s->time/s->time_increment_resolution;
1739 time_mod= s->time%s->time_increment_resolution;
1741 if(s->pict_type==B_TYPE){
1742 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1744 s->last_time_base= s->time_base;
1745 s->time_base= time_div;
1746 s->pp_time= s->time - s->last_non_b_time;
1747 s->last_non_b_time= s->time;
1751 static void mpeg4_encode_gop_header(MpegEncContext * s){
1752 int hours, minutes, seconds;
1754 put_bits(&s->pb, 16, 0);
1755 put_bits(&s->pb, 16, GOP_STARTCODE);
1757 seconds= s->time/s->time_increment_resolution;
1758 minutes= seconds/60; seconds %= 60;
1759 hours= minutes/60; minutes %= 60;
1762 put_bits(&s->pb, 5, hours);
1763 put_bits(&s->pb, 6, minutes);
1764 put_bits(&s->pb, 1, 1);
1765 put_bits(&s->pb, 6, seconds);
1767 put_bits(&s->pb, 1, 0); //closed gov == NO
1768 put_bits(&s->pb, 1, 0); //broken link == NO
1770 ff_mpeg4_stuffing(&s->pb);
1773 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1774 int profile_and_level_indication;
1777 if(s->max_b_frames || s->quarter_sample){
1778 profile_and_level_indication= 0xF1; // adv simple level 1
1781 profile_and_level_indication= 0x01; // simple level 1
1786 put_bits(&s->pb, 16, 0);
1787 put_bits(&s->pb, 16, VOS_STARTCODE);
1789 put_bits(&s->pb, 8, profile_and_level_indication);
1791 put_bits(&s->pb, 16, 0);
1792 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1794 put_bits(&s->pb, 1, 1);
1795 put_bits(&s->pb, 4, vo_ver_id);
1796 put_bits(&s->pb, 3, 1); //priority
1798 put_bits(&s->pb, 4, 1); //visual obj type== video obj
1800 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1802 ff_mpeg4_stuffing(&s->pb);
1805 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
1809 if(s->max_b_frames || s->quarter_sample){
1811 s->vo_type= ADV_SIMPLE_VO_TYPE;
1814 s->vo_type= SIMPLE_VO_TYPE;
1817 put_bits(&s->pb, 16, 0);
1818 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
1819 put_bits(&s->pb, 16, 0);
1820 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
1822 put_bits(&s->pb, 1, 0); /* random access vol */
1823 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
1824 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1825 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1826 put_bits(&s->pb, 3, 1); /* is obj layer priority */
1828 float_aspect_to_info(s, s->avctx->aspect_ratio);
1830 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1831 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1833 put_bits(&s->pb, 8, s->aspected_width);
1834 put_bits(&s->pb, 8, s->aspected_height);
1838 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1839 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1840 put_bits(&s->pb, 1, s->low_delay);
1841 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1843 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
1846 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1847 put_bits(&s->pb, 1, 1); /* marker bit */
1849 put_bits(&s->pb, 16, s->time_increment_resolution);
1850 if (s->time_increment_bits < 1)
1851 s->time_increment_bits = 1;
1852 put_bits(&s->pb, 1, 1); /* marker bit */
1853 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1854 put_bits(&s->pb, 1, 1); /* marker bit */
1855 put_bits(&s->pb, 13, s->width); /* vol width */
1856 put_bits(&s->pb, 1, 1); /* marker bit */
1857 put_bits(&s->pb, 13, s->height); /* vol height */
1858 put_bits(&s->pb, 1, 1); /* marker bit */
1859 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1860 put_bits(&s->pb, 1, 1); /* obmc disable */
1861 if (vo_ver_id == 1) {
1862 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
1864 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
1867 s->quant_precision=5;
1868 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
1869 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1872 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
1873 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
1877 put_bits(&s->pb, 1, s->quarter_sample);
1878 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1879 s->resync_marker= s->rtp_mode;
1880 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1881 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1882 if(s->data_partitioning){
1883 put_bits(&s->pb, 1, 0); /* no rvlc */
1886 if (vo_ver_id != 1){
1887 put_bits(&s->pb, 1, 0); /* newpred */
1888 put_bits(&s->pb, 1, 0); /* reduced res vop */
1890 put_bits(&s->pb, 1, 0); /* scalability */
1892 ff_mpeg4_stuffing(&s->pb);
1895 if(!(s->flags & CODEC_FLAG_BITEXACT)){
1896 put_bits(&s->pb, 16, 0);
1897 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1898 put_string(&s->pb, LIBAVCODEC_IDENT);
1899 ff_mpeg4_stuffing(&s->pb);
1903 /* write mpeg4 VOP header */
1904 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1907 int time_div, time_mod;
1909 if(s->pict_type==I_TYPE){
1910 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1911 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
1912 mpeg4_encode_visual_object_header(s);
1913 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
1914 mpeg4_encode_vol_header(s, 0, 0);
1916 mpeg4_encode_gop_header(s);
1919 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1921 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1923 put_bits(&s->pb, 16, 0); /* vop header */
1924 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
1925 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1927 time_div= s->time/s->time_increment_resolution;
1928 time_mod= s->time%s->time_increment_resolution;
1929 time_incr= time_div - s->last_time_base;
1931 put_bits(&s->pb, 1, 1);
1933 put_bits(&s->pb, 1, 0);
1935 put_bits(&s->pb, 1, 1); /* marker */
1936 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1937 put_bits(&s->pb, 1, 1); /* marker */
1938 put_bits(&s->pb, 1, 1); /* vop coded */
1939 if ( s->pict_type == P_TYPE
1940 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1941 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1943 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1944 if(!s->progressive_sequence){
1945 put_bits(&s->pb, 1, s->top_field_first);
1946 put_bits(&s->pb, 1, s->alternate_scan);
1948 //FIXME sprite stuff
1950 put_bits(&s->pb, 5, s->qscale);
1952 if (s->pict_type != I_TYPE)
1953 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1954 if (s->pict_type == B_TYPE)
1955 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1956 // printf("****frame %d\n", picture_number);
1958 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1959 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1962 #endif //CONFIG_ENCODERS
1965 * change qscale by given dquant and update qscale dependant variables.
1967 static void change_qscale(MpegEncContext * s, int dquant)
1969 s->qscale += dquant;
1973 else if (s->qscale > 31)
1976 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1977 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1982 * @param n block index (0-3 are luma, 4-5 are chroma)
1983 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1984 * @param dir_ptr pointer to an integer where the prediction direction will be stored
1985 * @return the quantized predicted dc
1987 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
1989 int a, b, c, wrap, pred, scale;
1992 /* find prediction */
1994 scale = s->y_dc_scale;
1996 scale = s->c_dc_scale;
2001 wrap= s->block_wrap[n];
2002 dc_val = s->dc_val[0] + s->block_index[n];
2008 b = dc_val[ - 1 - wrap];
2009 c = dc_val[ - wrap];
2011 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2012 if(s->first_slice_line && n!=3){
2014 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2016 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2017 if(n==0 || n==4 || n==5)
2021 if (abs(a - b) < abs(b - c)) {
2023 *dir_ptr = 1; /* top */
2026 *dir_ptr = 0; /* left */
2028 /* we assume pred is positive */
2029 pred = FASTDIV((pred + (scale >> 1)), scale);
2031 /* prepare address for prediction update */
2032 *dc_val_ptr = &dc_val[0];
2039 * @param n block index (0-3 are luma, 4-5 are chroma)
2040 * @param dir the ac prediction direction
2042 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2046 int16_t *ac_val, *ac_val1;
2047 int8_t * const qscale_table= s->current_picture.qscale_table;
2049 /* find prediction */
2050 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2054 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2055 /* left prediction */
2058 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2061 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2064 /* different qscale, we must rescale */
2066 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2070 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2071 /* top prediction */
2072 ac_val -= 16 * s->block_wrap[n];
2074 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2077 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2080 /* different qscale, we must rescale */
2082 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2089 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2093 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2097 #ifdef CONFIG_ENCODERS
2099 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2104 int8_t * const qscale_table= s->current_picture.qscale_table;
2106 /* find prediction */
2107 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2110 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2111 /* left prediction */
2113 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2116 block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
2119 /* different qscale, we must rescale */
2121 block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2125 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2126 /* top prediction */
2127 ac_val -= 16 * s->block_wrap[n];
2128 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2131 block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
2134 /* different qscale, we must rescale */
2136 block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2143 * encodes the dc value.
2144 * @param n block index (0-3 are luma, 4-5 are chroma)
2146 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2149 // if(level<-255 || level>255) printf("dc overflow\n");
2153 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2156 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2160 /* find number of bits */
2170 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2173 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2176 /* encode remaining bits */
2179 level = (-level) ^ ((1 << size) - 1);
2180 put_bits(&s->pb, size, level);
2182 put_bits(&s->pb, 1, 1);
2188 * encodes a 8x8 block
2189 * @param n block index (0-3 are luma, 4-5 are chroma)
2191 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2192 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2194 int i, last_non_zero;
2195 #if 0 //variables for the outcommented version
2196 int code, sign, last;
2201 const int last_index = s->block_last_index[n];
2203 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2204 /* mpeg4 based DC predictor */
2205 mpeg4_encode_dc(dc_pb, intra_dc, n);
2206 if(last_index<1) return;
2209 bits_tab= uni_mpeg4_intra_rl_bits;
2210 len_tab = uni_mpeg4_intra_rl_len;
2212 if(last_index<0) return;
2215 bits_tab= uni_mpeg4_inter_rl_bits;
2216 len_tab = uni_mpeg4_inter_rl_len;
2220 last_non_zero = i - 1;
2222 for (; i < last_index; i++) {
2223 int level = block[ scan_table[i] ];
2225 int run = i - last_non_zero - 1;
2227 if((level&(~127)) == 0){
2228 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2229 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2231 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);
2236 /*if(i<=last_index)*/{
2237 int level = block[ scan_table[i] ];
2238 int run = i - last_non_zero - 1;
2240 if((level&(~127)) == 0){
2241 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2242 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2244 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);
2248 for (; i <= last_index; i++) {
2249 const int slevel = block[ scan_table[i] ];
2252 int run = i - last_non_zero - 1;
2253 last = (i == last_index);
2260 code = get_rl_index(rl, last, run, level);
2261 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2262 if (code == rl->n) {
2264 level1 = level - rl->max_level[last][run];
2267 code = get_rl_index(rl, last, run, level1);
2268 if (code == rl->n) {
2270 put_bits(ac_pb, 1, 1);
2271 if (level > MAX_LEVEL)
2273 run1 = run - rl->max_run[last][level] - 1;
2276 code = get_rl_index(rl, last, run1, level);
2277 if (code == rl->n) {
2280 put_bits(ac_pb, 1, 1);
2281 put_bits(ac_pb, 1, last);
2282 put_bits(ac_pb, 6, run);
2283 put_bits(ac_pb, 1, 1);
2284 put_bits(ac_pb, 12, slevel & 0xfff);
2285 put_bits(ac_pb, 1, 1);
2288 put_bits(ac_pb, 1, 0);
2289 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2290 put_bits(ac_pb, 1, sign);
2294 put_bits(ac_pb, 1, 0);
2295 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2296 put_bits(ac_pb, 1, sign);
2299 put_bits(ac_pb, 1, sign);
2307 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2308 uint8_t *scan_table)
2310 int i, last_non_zero;
2313 const int last_index = s->block_last_index[n];
2316 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2317 /* mpeg4 based DC predictor */
2318 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2319 if(last_index<1) return len;
2322 len_tab = uni_mpeg4_intra_rl_len;
2324 if(last_index<0) return 0;
2327 len_tab = uni_mpeg4_inter_rl_len;
2331 last_non_zero = i - 1;
2332 for (; i < last_index; i++) {
2333 int level = block[ scan_table[i] ];
2335 int run = i - last_non_zero - 1;
2337 if((level&(~127)) == 0){
2338 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2339 len += len_tab[index];
2341 len += 7+2+1+6+1+12+1;
2346 /*if(i<=last_index)*/{
2347 int level = block[ scan_table[i] ];
2348 int run = i - last_non_zero - 1;
2350 if((level&(~127)) == 0){
2351 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2352 len += len_tab[index];
2354 len += 7+2+1+6+1+12+1;
2364 /***********************************************/
2367 static VLC intra_MCBPC_vlc;
2368 static VLC inter_MCBPC_vlc;
2369 static VLC cbpy_vlc;
2371 static VLC dc_lum, dc_chrom;
2372 static VLC sprite_trajectory;
2373 static VLC mb_type_b_vlc;
2375 void init_vlc_rl(RLTable *rl)
2379 init_vlc(&rl->vlc, 9, rl->n + 1,
2380 &rl->table_vlc[0][1], 4, 2,
2381 &rl->table_vlc[0][0], 4, 2);
2384 for(q=0; q<32; q++){
2393 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2394 for(i=0; i<rl->vlc.table_size; i++){
2395 int code= rl->vlc.table[i][0];
2396 int len = rl->vlc.table[i][1];
2399 if(len==0){ // illegal code
2402 }else if(len<0){ //more bits needed
2406 if(code==rl->n){ //esc
2410 run= rl->table_run [code] + 1;
2411 level= rl->table_level[code] * qmul + qadd;
2412 if(code >= rl->last) run+=192;
2415 rl->rl_vlc[q][i].len= len;
2416 rl->rl_vlc[q][i].level= level;
2417 rl->rl_vlc[q][i].run= run;
2424 /* XXX: find a better solution to handle static init */
2425 void h263_decode_init_vlc(MpegEncContext *s)
2427 static int done = 0;
2432 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2433 intra_MCBPC_bits, 1, 1,
2434 intra_MCBPC_code, 1, 1);
2435 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2436 inter_MCBPC_bits, 1, 1,
2437 inter_MCBPC_code, 1, 1);
2438 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2439 &cbpy_tab[0][1], 2, 1,
2440 &cbpy_tab[0][0], 2, 1);
2441 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2443 &mvtab[0][0], 2, 1);
2446 init_rl(&rvlc_rl_inter);
2447 init_rl(&rvlc_rl_intra);
2448 init_rl(&rl_intra_aic);
2449 init_vlc_rl(&rl_inter);
2450 init_vlc_rl(&rl_intra);
2451 init_vlc_rl(&rvlc_rl_inter);
2452 init_vlc_rl(&rvlc_rl_intra);
2453 init_vlc_rl(&rl_intra_aic);
2454 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2455 &DCtab_lum[0][1], 2, 1,
2456 &DCtab_lum[0][0], 2, 1);
2457 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2458 &DCtab_chrom[0][1], 2, 1,
2459 &DCtab_chrom[0][0], 2, 1);
2460 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2461 &sprite_trajectory_tab[0][1], 4, 2,
2462 &sprite_trajectory_tab[0][0], 4, 2);
2463 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2464 &mb_type_b_tab[0][1], 2, 1,
2465 &mb_type_b_tab[0][0], 2, 1);
2470 * Get the GOB height based on picture height.
2472 int ff_h263_get_gob_height(MpegEncContext *s){
2473 if (s->height <= 400)
2475 else if (s->height <= 800)
2482 * decodes the group of blocks header.
2483 * @return <0 if an error occured
2485 static int h263_decode_gob_header(MpegEncContext *s)
2487 unsigned int val, gfid;
2490 /* Check for GOB Start Code */
2491 val = show_bits(&s->gb, 16);
2495 /* We have a GBSC probably with GSTUFF */
2496 skip_bits(&s->gb, 16); /* Drop the zeros */
2497 left= s->gb.size_in_bits - get_bits_count(&s->gb);
2498 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2499 for(;left>13; left--){
2500 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2506 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2508 s->gob_number = get_bits(&s->gb, 5); /* GN */
2509 gfid = get_bits(&s->gb, 2); /* GFID */
2510 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2514 s->mb_y= s->gob_index* s->gob_number;
2515 if(s->mb_y >= s->mb_height)
2518 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2523 static inline void memsetw(short *tab, int val, int n)
2530 #ifdef CONFIG_ENCODERS
2532 void ff_mpeg4_init_partitions(MpegEncContext *s)
2534 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2535 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
2538 void ff_mpeg4_merge_partitions(MpegEncContext *s)
2540 const int pb2_len = get_bit_count(&s->pb2 );
2541 const int tex_pb_len= get_bit_count(&s->tex_pb);
2542 const int bits= get_bit_count(&s->pb);
2544 if(s->pict_type==I_TYPE){
2545 put_bits(&s->pb, 19, DC_MARKER);
2546 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2547 s->i_tex_bits+= tex_pb_len;
2549 put_bits(&s->pb, 17, MOTION_MARKER);
2550 s->misc_bits+=17 + pb2_len;
2551 s->mv_bits+= bits - s->last_bits;
2552 s->p_tex_bits+= tex_pb_len;
2555 flush_put_bits(&s->pb2);
2556 flush_put_bits(&s->tex_pb);
2558 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
2559 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2560 s->last_bits= get_bit_count(&s->pb);
2563 #endif //CONFIG_ENCODERS
2565 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2566 switch(s->pict_type){
2571 return s->f_code+15;
2573 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
2579 #ifdef CONFIG_ENCODERS
2581 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
2583 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2585 ff_mpeg4_stuffing(&s->pb);
2586 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2587 put_bits(&s->pb, 1, 1);
2589 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2590 put_bits(&s->pb, s->quant_precision, s->qscale);
2591 put_bits(&s->pb, 1, 0); /* no HEC */
2594 #endif //CONFIG_ENCODERS
2597 * check if the next stuff is a resync marker or the end.
2600 static inline int mpeg4_is_resync(MpegEncContext *s){
2601 const int bits_count= get_bits_count(&s->gb);
2603 if(s->workaround_bugs&FF_BUG_NO_PADDING){
2607 if(bits_count + 8 >= s->gb.size_in_bits){
2608 int v= show_bits(&s->gb, 8);
2609 v|= 0x7F >> (7-(bits_count&7));
2614 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2616 GetBitContext gb= s->gb;
2618 skip_bits(&s->gb, 1);
2619 align_get_bits(&s->gb);
2621 for(len=0; len<32; len++){
2622 if(get_bits1(&s->gb)) break;
2627 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2635 * decodes the next video packet.
2636 * @return <0 if something went wrong
2638 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
2640 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2641 int header_extension=0, mb_num, len;
2643 /* is there enough space left for a video packet + header */
2644 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2646 for(len=0; len<32; len++){
2647 if(get_bits1(&s->gb)) break;
2650 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2651 printf("marker does not match f_code\n");
2655 if(s->shape != RECT_SHAPE){
2656 header_extension= get_bits1(&s->gb);
2657 //FIXME more stuff here
2660 mb_num= get_bits(&s->gb, mb_num_bits);
2661 if(mb_num>=s->mb_num){
2662 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2665 if(s->pict_type == B_TYPE){
2666 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2667 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
2670 s->mb_x= mb_num % s->mb_width;
2671 s->mb_y= mb_num / s->mb_width;
2673 if(s->shape != BIN_ONLY_SHAPE){
2674 int qscale= get_bits(&s->gb, s->quant_precision);
2679 if(s->shape == RECT_SHAPE){
2680 header_extension= get_bits1(&s->gb);
2682 if(header_extension){
2686 while (get_bits1(&s->gb) != 0)
2689 check_marker(&s->gb, "before time_increment in video packed header");
2690 time_increment= get_bits(&s->gb, s->time_increment_bits);
2691 check_marker(&s->gb, "before vop_coding_type in video packed header");
2693 skip_bits(&s->gb, 2); /* vop coding type */
2694 //FIXME not rect stuff here
2696 if(s->shape != BIN_ONLY_SHAPE){
2697 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2698 //FIXME dont just ignore everything
2699 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2700 mpeg4_decode_sprite_trajectory(s);
2701 fprintf(stderr, "untested\n");
2704 //FIXME reduced res stuff here
2706 if (s->pict_type != I_TYPE) {
2707 int f_code = get_bits(&s->gb, 3); /* fcode_for */
2709 printf("Error, video packet header damaged (f_code=0)\n");
2712 if (s->pict_type == B_TYPE) {
2713 int b_code = get_bits(&s->gb, 3);
2715 printf("Error, video packet header damaged (b_code=0)\n");
2720 //FIXME new-pred stuff
2722 //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));
2727 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2729 int c_wrap, c_xy, l_wrap, l_xy;
2731 l_wrap= s->block_wrap[0];
2732 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2733 c_wrap= s->block_wrap[4];
2734 c_xy= s->mb_y*c_wrap + s->mb_x;
2738 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2739 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2740 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2744 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
2745 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
2746 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
2749 // we cant clear the MVs as they might be needed by a b frame
2750 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2751 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2752 s->last_mv[0][0][0]=
2753 s->last_mv[0][0][1]=
2754 s->last_mv[1][0][0]=
2755 s->last_mv[1][0][1]= 0;
2759 * decodes the group of blocks / video packet header.
2760 * @return <0 if no resync found
2762 int ff_h263_resync(MpegEncContext *s){
2765 if(s->codec_id==CODEC_ID_MPEG4)
2768 align_get_bits(&s->gb);
2770 if(show_bits(&s->gb, 16)==0){
2771 if(s->codec_id==CODEC_ID_MPEG4)
2772 ret= mpeg4_decode_video_packet_header(s);
2774 ret= h263_decode_gob_header(s);
2778 //ok, its not where its supposed to be ...
2779 s->gb= s->last_resync_gb;
2780 align_get_bits(&s->gb);
2781 left= s->gb.size_in_bits - get_bits_count(&s->gb);
2783 for(;left>16+1+5+5; left-=8){
2784 if(show_bits(&s->gb, 16)==0){
2785 GetBitContext bak= s->gb;
2787 if(s->codec_id==CODEC_ID_MPEG4)
2788 ret= mpeg4_decode_video_packet_header(s);
2790 ret= h263_decode_gob_header(s);
2796 skip_bits(&s->gb, 8);
2803 * gets the average motion vector for a GMC MB.
2804 * @param n either 0 for the x component or 1 for y
2805 * @returns the average MV for a GMC MB
2807 static inline int get_amv(MpegEncContext *s, int n){
2808 int x, y, mb_v, sum, dx, dy, shift;
2809 int len = 1 << (s->f_code + 4);
2810 const int a= s->sprite_warping_accuracy;
2812 if(s->real_sprite_warping_points==1){
2813 if(s->divx_version==500 && s->divx_build==413)
2814 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2816 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2818 dx= s->sprite_delta[n][0];
2819 dy= s->sprite_delta[n][1];
2820 shift= s->sprite_shift[0];
2821 if(n) dy -= 1<<(shift + a + 1);
2822 else dx -= 1<<(shift + a + 1);
2823 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2826 for(y=0; y<16; y++){
2830 //XXX FIXME optimize
2831 for(x=0; x<16; x++){
2836 sum= RSHIFT(sum, a+8-s->quarter_sample);
2839 if (sum < -len) sum= -len;
2840 else if (sum >= len) sum= len-1;
2846 * decodes first partition.
2847 * @return number of MBs decoded or <0 if an error occured
2849 static int mpeg4_decode_partition_a(MpegEncContext *s){
2851 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2853 /* decode first partition */
2855 s->first_slice_line=1;
2856 for(; s->mb_y<s->mb_height; s->mb_y++){
2857 ff_init_block_index(s);
2858 for(; s->mb_x<s->mb_width; s->mb_x++){
2859 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2864 ff_update_block_index(s);
2865 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2866 s->first_slice_line=0;
2868 if(s->pict_type==I_TYPE){
2871 if(show_bits_long(&s->gb, 19)==DC_MARKER){
2876 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
2878 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2883 s->cbp_table[xy]= cbpc & 3;
2884 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2888 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
2890 s->current_picture.qscale_table[xy]= s->qscale;
2892 s->mbintra_table[xy]= 1;
2895 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2897 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2901 if(dc_pred_dir) dir|=1;
2903 s->pred_dir_table[xy]= dir;
2904 }else{ /* P/S_TYPE */
2905 int mx, my, pred_x, pred_y, bits;
2906 int16_t * const mot_val= s->motion_val[s->block_index[0]];
2907 const int stride= s->block_wrap[0]*2;
2910 bits= show_bits(&s->gb, 17);
2911 if(bits==MOTION_MARKER){
2917 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2918 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2922 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
2925 mot_val[0 ]= mot_val[2 ]=
2926 mot_val[0+stride]= mot_val[2+stride]= mx;
2927 mot_val[1 ]= mot_val[3 ]=
2928 mot_val[1+stride]= mot_val[3+stride]= my;
2930 if(s->mbintra_table[xy])
2931 ff_clean_intra_table_entries(s);
2935 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2937 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2940 // }while(cbpc == 20);
2942 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2944 s->mb_intra = ((cbpc & 4) != 0);
2947 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2948 s->mbintra_table[xy]= 1;
2949 mot_val[0 ]= mot_val[2 ]=
2950 mot_val[0+stride]= mot_val[2+stride]= 0;
2951 mot_val[1 ]= mot_val[3 ]=
2952 mot_val[1+stride]= mot_val[3+stride]= 0;
2954 if(s->mbintra_table[xy])
2955 ff_clean_intra_table_entries(s);
2957 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2958 s->mcsel= get_bits1(&s->gb);
2961 if ((cbpc & 16) == 0) {
2962 /* 16x16 motion prediction */
2964 h263_pred_motion(s, 0, &pred_x, &pred_y);
2966 mx = h263_decode_motion(s, pred_x, s->f_code);
2970 my = h263_decode_motion(s, pred_y, s->f_code);
2973 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
2977 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
2980 mot_val[0 ]= mot_val[2 ] =
2981 mot_val[0+stride]= mot_val[2+stride]= mx;
2982 mot_val[1 ]= mot_val[3 ]=
2983 mot_val[1+stride]= mot_val[3+stride]= my;
2986 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
2988 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2989 mx = h263_decode_motion(s, pred_x, s->f_code);
2993 my = h263_decode_motion(s, pred_y, s->f_code);
3010 * decode second partition.
3011 * @return <0 if an error occured
3013 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3015 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3017 s->mb_x= s->resync_mb_x;
3018 s->first_slice_line=1;
3019 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3020 ff_init_block_index(s);
3021 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3022 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3025 ff_update_block_index(s);
3026 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3027 s->first_slice_line=0;
3029 if(s->pict_type==I_TYPE){
3030 int ac_pred= get_bits1(&s->gb);
3031 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3033 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3037 s->cbp_table[xy]|= cbpy<<2;
3038 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3039 }else{ /* P || S_TYPE */
3040 if(IS_INTRA(s->current_picture.mb_type[xy])){
3042 int ac_pred = get_bits1(&s->gb);
3043 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3046 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3050 if(s->cbp_table[xy] & 8) {
3051 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3053 s->current_picture.qscale_table[xy]= s->qscale;
3057 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3059 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3063 if(dc_pred_dir) dir|=1;
3065 s->cbp_table[xy]&= 3; //remove dquant
3066 s->cbp_table[xy]|= cbpy<<2;
3067 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3068 s->pred_dir_table[xy]= dir;
3069 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
3070 s->current_picture.qscale_table[xy]= s->qscale;
3071 s->cbp_table[xy]= 0;
3073 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3076 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3080 if(s->cbp_table[xy] & 8) {
3081 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3083 s->current_picture.qscale_table[xy]= s->qscale;
3085 s->cbp_table[xy]&= 3; //remove dquant
3086 s->cbp_table[xy]|= (cbpy^0xf)<<2;
3090 if(mb_num >= mb_count) return 0;
3097 * decodes the first & second partition
3098 * @return <0 if error (and sets error type in the error_status_table)
3100 int ff_mpeg4_decode_partitions(MpegEncContext *s)
3103 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3104 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3106 mb_num= mpeg4_decode_partition_a(s);
3108 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3112 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3113 fprintf(stderr, "slice below monitor ...\n");
3114 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3118 s->mb_num_left= mb_num;
3120 if(s->pict_type==I_TYPE){
3121 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3122 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3126 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3127 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3131 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3133 if( mpeg4_decode_partition_b(s, mb_num) < 0){
3134 if(s->pict_type==P_TYPE)
3135 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3138 if(s->pict_type==P_TYPE)
3139 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3146 * decode partition C of one MB.
3147 * @return <0 if an error occured
3149 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3152 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3154 mb_type= s->current_picture.mb_type[xy];
3155 cbp = s->cbp_table[xy];
3157 if(s->current_picture.qscale_table[xy] != s->qscale){
3158 s->qscale= s->current_picture.qscale_table[xy];
3159 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3160 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3163 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3166 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3167 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3169 s->mb_intra = IS_INTRA(mb_type);
3171 if (IS_SKIP(mb_type)) {
3174 s->block_last_index[i] = -1;
3175 s->mv_dir = MV_DIR_FORWARD;
3176 s->mv_type = MV_TYPE_16X16;
3177 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3184 }else if(s->mb_intra){
3185 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3186 }else if(!s->mb_intra){
3187 // s->mcsel= 0; //FIXME do we need to init that
3189 s->mv_dir = MV_DIR_FORWARD;
3190 if (IS_8X8(mb_type)) {
3191 s->mv_type = MV_TYPE_8X8;
3193 s->mv_type = MV_TYPE_16X16;
3196 } else { /* I-Frame */
3198 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3201 if (!IS_SKIP(mb_type)) {
3203 /* decode each block */
3204 for (i = 0; i < 6; i++) {
3205 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3206 fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3213 /* per-MB end of slice check */
3215 if(--s->mb_num_left <= 0){
3216 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3217 if(mpeg4_is_resync(s))
3222 if(mpeg4_is_resync(s)){
3223 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3224 if(s->cbp_table[xy+delta])
3231 int ff_h263_decode_mb(MpegEncContext *s,
3232 DCTELEM block[6][64])
3234 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3236 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3237 const int xy= s->mb_x + s->mb_y * s->mb_stride;
3239 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3241 if (get_bits1(&s->gb)) {
3245 s->block_last_index[i] = -1;
3246 s->mv_dir = MV_DIR_FORWARD;
3247 s->mv_type = MV_TYPE_16X16;
3248 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3249 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3251 s->mv[0][0][0]= get_amv(s, 0);
3252 s->mv[0][0][1]= get_amv(s, 1);
3256 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3264 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3265 //fprintf(stderr, "\tCBPC: %d", cbpc);
3267 fprintf(stderr, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3273 s->mb_intra = ((cbpc & 4) != 0);
3274 if (s->mb_intra) goto intra;
3276 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3277 s->mcsel= get_bits1(&s->gb);
3279 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3280 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3282 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3284 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3285 s->interlaced_dct= get_bits1(&s->gb);
3287 s->mv_dir = MV_DIR_FORWARD;
3288 if ((cbpc & 16) == 0) {
3290 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3291 /* 16x16 global motion prediction */
3292 s->mv_type = MV_TYPE_16X16;
3295 s->mv[0][0][0] = mx;
3296 s->mv[0][0][1] = my;
3297 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3298 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
3299 /* 16x8 field motion prediction */
3300 s->mv_type= MV_TYPE_FIELD;
3302 s->field_select[0][0]= get_bits1(&s->gb);
3303 s->field_select[0][1]= get_bits1(&s->gb);
3305 h263_pred_motion(s, 0, &pred_x, &pred_y);
3308 mx = h263_decode_motion(s, pred_x, s->f_code);
3312 my = h263_decode_motion(s, pred_y/2, s->f_code);
3316 s->mv[0][i][0] = mx;
3317 s->mv[0][i][1] = my;
3320 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3321 /* 16x16 motion prediction */
3322 s->mv_type = MV_TYPE_16X16;
3323 h263_pred_motion(s, 0, &pred_x, &pred_y);
3325 mx = h263p_decode_umotion(s, pred_x);
3327 mx = h263_decode_motion(s, pred_x, s->f_code);
3333 my = h263p_decode_umotion(s, pred_y);
3335 my = h263_decode_motion(s, pred_y, s->f_code);
3339 s->mv[0][0][0] = mx;
3340 s->mv[0][0][1] = my;
3342 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3343 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3346 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3347 s->mv_type = MV_TYPE_8X8;
3349 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3351 mx = h263p_decode_umotion(s, pred_x);
3353 mx = h263_decode_motion(s, pred_x, s->f_code);
3358 my = h263p_decode_umotion(s, pred_y);
3360 my = h263_decode_motion(s, pred_y, s->f_code);
3363 s->mv[0][i][0] = mx;
3364 s->mv[0][i][1] = my;
3365 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3366 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3371 } else if(s->pict_type==B_TYPE) {
3372 int modb1; // first bit of modb
3373 int modb2; // second bit of modb
3376 s->mb_intra = 0; //B-frames never contain intra blocks
3377 s->mcsel=0; // ... true gmc blocks
3381 s->last_mv[i][0][0]=
3382 s->last_mv[i][0][1]=
3383 s->last_mv[i][1][0]=
3384 s->last_mv[i][1][1]= 0;
3388 /* if we skipped it in the future P Frame than skip it now too */
3389 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
3394 s->block_last_index[i] = -1;
3396 s->mv_dir = MV_DIR_FORWARD;
3397 s->mv_type = MV_TYPE_16X16;
3402 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3406 modb1= get_bits1(&s->gb);
3408 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3411 modb2= get_bits1(&s->gb);
3412 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3414 printf("illegal MB_type\n");
3417 mb_type= mb_type_b_map[ mb_type ];
3419 else cbp= get_bits(&s->gb, 6);
3421 if ((!IS_DIRECT(mb_type)) && cbp) {
3422 if(get_bits1(&s->gb)){
3423 change_qscale(s, get_bits1(&s->gb)*4 - 2);
3427 if(!s->progressive_sequence){
3429 s->interlaced_dct= get_bits1(&s->gb);
3431 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
3432 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
3433 mb_type &= ~MB_TYPE_16x16;
3435 if(USES_LIST(mb_type, 0)){
3436 s->field_select[0][0]= get_bits1(&s->gb);
3437 s->field_select[0][1]= get_bits1(&s->gb);
3439 if(USES_LIST(mb_type, 1)){
3440 s->field_select[1][0]= get_bits1(&s->gb);
3441 s->field_select[1][1]= get_bits1(&s->gb);
3447 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
3448 s->mv_type= MV_TYPE_16X16;
3450 if(USES_LIST(mb_type, 0)){
3451 s->mv_dir = MV_DIR_FORWARD;
3453 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3454 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3455 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3456 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3459 if(USES_LIST(mb_type, 1)){
3460 s->mv_dir |= MV_DIR_BACKWARD;
3462 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3463 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3464 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3465 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3467 }else if(!IS_DIRECT(mb_type)){
3468 s->mv_type= MV_TYPE_FIELD;
3470 if(USES_LIST(mb_type, 0)){
3471 s->mv_dir = MV_DIR_FORWARD;
3474 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
3475 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3476 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
3477 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3481 if(USES_LIST(mb_type, 1)){
3482 s->mv_dir |= MV_DIR_BACKWARD;
3485 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
3486 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3487 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
3488 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3494 if(IS_DIRECT(mb_type)){
3495 if(IS_SKIP(mb_type))
3498 mx = h263_decode_motion(s, 0, 1);
3499 my = h263_decode_motion(s, 0, 1);
3502 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3503 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3505 s->current_picture.mb_type[xy]= mb_type;
3506 } else { /* I-Frame */
3508 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3510 fprintf(stderr, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3518 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3519 if (s->h263_pred || s->h263_aic) {
3520 s->ac_pred = get_bits1(&s->gb);
3522 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3525 s->h263_aic_dir = get_bits1(&s->gb);
3530 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3532 fprintf(stderr, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3535 cbp = (cbpc & 3) | (cbpy << 2);
3537 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3540 if(!s->progressive_sequence)
3541 s->interlaced_dct= get_bits1(&s->gb);
3543 /* decode each block */
3545 for (i = 0; i < 6; i++) {
3546 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3551 for (i = 0; i < 6; i++) {
3552 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3560 /* decode each block */
3562 for (i = 0; i < 6; i++) {
3563 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3568 for (i = 0; i < 6; i++) {
3569 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3576 /* per-MB end of slice check */
3577 if(s->codec_id==CODEC_ID_MPEG4){
3578 if(mpeg4_is_resync(s)){
3579 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3580 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
3585 int v= show_bits(&s->gb, 16);
3587 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3588 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3598 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3600 int code, val, sign, shift, l;
3601 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3608 sign = get_bits1(&s->gb);
3612 val = (val - 1) << shift;
3613 val |= get_bits(&s->gb, shift);
3620 /* modulo decoding */
3621 if (!s->h263_long_vectors) {
3622 l = 1 << (f_code + 4);
3623 val = ((val + l)&(l*2-1)) - l;
3625 /* horrible h263 long vector mode */
3626 if (pred < -31 && val < -63)
3628 if (pred > 32 && val > 63)
3635 /* Decodes RVLC of H.263+ UMV */
3636 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3640 if (get_bits1(&s->gb)) /* Motion difference = 0 */
3643 code = 2 + get_bits1(&s->gb);
3645 while (get_bits1(&s->gb))
3648 code += get_bits1(&s->gb);
3653 code = (sign) ? (pred - code) : (pred + code);
3655 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3661 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3664 int code, level, i, j, last, run;
3665 RLTable *rl = &rl_inter;
3666 const uint8_t *scan_table;
3668 scan_table = s->intra_scantable.permutated;
3669 if (s->h263_aic && s->mb_intra) {
3673 if (s->h263_aic_dir)
3674 scan_table = s->intra_v_scantable.permutated; /* left */
3676 scan_table = s->intra_h_scantable.permutated; /* top */
3678 } else if (s->mb_intra) {
3681 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3682 int component, diff;
3683 component = (n <= 3 ? 0 : n - 4 + 1);
3684 level = s->last_dc[component];
3685 if (s->rv10_first_dc_coded[component]) {
3686 diff = rv_decode_dc(s, n);
3690 level = level & 0xff; /* handle wrap round */
3691 s->last_dc[component] = level;
3693 s->rv10_first_dc_coded[component] = 1;
3696 level = get_bits(&s->gb, 8);
3699 level = get_bits(&s->gb, 8);
3700 if((level&0x7F) == 0){
3701 fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3713 if (s->mb_intra && s->h263_aic)
3715 s->block_last_index[n] = i - 1;
3720 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3722 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3725 if (code == rl->n) {
3727 if (s->h263_flv > 1) {
3728 int is11 = get_bits1(&s->gb);
3729 last = get_bits1(&s->gb);
3730 run = get_bits(&s->gb, 6);
3732 level = get_sbits(&s->gb, 11);
3734 level = get_sbits(&s->gb, 7);
3737 last = get_bits1(&s->gb);
3738 run = get_bits(&s->gb, 6);
3739 level = (int8_t)get_bits(&s->gb, 8);
3742 /* XXX: should patch encoder too */
3743 level = get_sbits(&s->gb, 12);
3745 level = get_bits(&s->gb, 5);
3746 level |= get_sbits(&s->gb, 6)<<5;
3751 run = rl->table_run[code];
3752 level = rl->table_level[code];
3753 last = code >= rl->last;
3754 if (get_bits1(&s->gb))
3759 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
3769 if (s->mb_intra && s->h263_aic) {
3770 h263_pred_acdc(s, block, n);
3773 s->block_last_index[n] = i;
3778 * decodes the dc value.
3779 * @param n block index (0-3 are luma, 4-5 are chroma)
3780 * @param dir_ptr the prediction direction will be stored here
3781 * @return the quantized dc
3783 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3785 int level, pred, code;
3789 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3791 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3792 if (code < 0 || code > 9 /* && s->nbit<9 */){
3793 fprintf(stderr, "illegal dc vlc\n");
3801 level= 2*get_bits1(&s->gb)-1;
3803 if(get_bits1(&s->gb))
3804 level = get_bits(&s->gb, code-1) + (1<<(code-1));
3806 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
3809 level = get_xbits(&s->gb, code);
3813 if(get_bits1(&s->gb)==0){ /* marker */
3814 if(s->error_resilience>=2){
3815 fprintf(stderr, "dc marker bit missing\n");
3821 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3824 if(s->error_resilience>=3){
3825 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3831 *dc_val = level * s->y_dc_scale;
3833 *dc_val = level * s->c_dc_scale;
3836 *dc_val = level * 8;
3838 if(s->error_resilience>=3){
3839 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3840 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3849 * @return <0 if an error occured
3851 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3852 int n, int coded, int intra, int rvlc)
3854 int level, i, last, run;
3857 RL_VLC_ELEM * rl_vlc;
3858 const uint8_t * scan_table;
3861 //Note intra & rvlc should be optimized away if this is inlined
3865 if(s->partitioned_frame){
3866 level = s->dc_val[0][ s->block_index[n] ];
3867 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
3868 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
3869 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
3871 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3881 rl = &rvlc_rl_intra;
3882 rl_vlc = rvlc_rl_intra.rl_vlc[0];
3885 rl_vlc = rl_intra.rl_vlc[0];
3888 if (dc_pred_dir == 0)
3889 scan_table = s->intra_v_scantable.permutated; /* left */
3891 scan_table = s->intra_h_scantable.permutated; /* top */
3893 scan_table = s->intra_scantable.permutated;
3900 s->block_last_index[n] = i;
3903 if(rvlc) rl = &rvlc_rl_inter;
3904 else rl = &rl_inter;
3906 scan_table = s->intra_scantable.permutated;
3912 rl_vlc = rvlc_rl_inter.rl_vlc[0];
3914 rl_vlc = rl_inter.rl_vlc[0];
3917 qmul = s->qscale << 1;
3918 qadd = (s->qscale - 1) | 1;
3920 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
3922 rl_vlc = rl_inter.rl_vlc[s->qscale];
3927 OPEN_READER(re, &s->gb);
3929 UPDATE_CACHE(re, &s->gb);
3930 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3934 if(SHOW_UBITS(re, &s->gb, 1)==0){
3935 fprintf(stderr, "1. marker bit missing in rvlc esc\n");
3937 }; SKIP_CACHE(re, &s->gb, 1);
3939 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3940 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3941 SKIP_COUNTER(re, &s->gb, 1+1+6);
3942 UPDATE_CACHE(re, &s->gb);
3944 if(SHOW_UBITS(re, &s->gb, 1)==0){
3945 fprintf(stderr, "2. marker bit missing in rvlc esc\n");
3947 }; SKIP_CACHE(re, &s->gb, 1);
3949 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3951 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3952 fprintf(stderr, "reverse esc missing\n");
3954 }; SKIP_CACHE(re, &s->gb, 5);
3956 level= level * qmul + qadd;
3957 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
3958 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
3964 cache= GET_CACHE(re, &s->gb);
3967 cache ^= 0xC0000000;
3969 if (cache&0x80000000) {
3970 if (cache&0x40000000) {
3972 SKIP_CACHE(re, &s->gb, 2);
3973 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3974 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3975 SKIP_COUNTER(re, &s->gb, 2+1+6);
3976 UPDATE_CACHE(re, &s->gb);
3979 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
3981 if(SHOW_UBITS(re, &s->gb, 1)==0){
3982 fprintf(stderr, "1. marker bit missing in 3. esc\n");
3984 }; SKIP_CACHE(re, &s->gb, 1);
3986 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3988 if(SHOW_UBITS(re, &s->gb, 1)==0){
3989 fprintf(stderr, "2. marker bit missing in 3. esc\n");
3991 }; LAST_SKIP_CACHE(re, &s->gb, 1);
3993 SKIP_COUNTER(re, &s->gb, 1+12+1);
3996 if(level*s->qscale>1024 || level*s->qscale<-1024){
3997 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4002 const int abs_level= ABS(level);
4003 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
4004 const int run1= run - rl->max_run[last][abs_level] - 1;
4005 if(abs_level <= rl->max_level[last][run]){
4006 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
4009 if(s->error_resilience > FF_ER_COMPLIANT){
4010 if(abs_level <= rl->max_level[last][run]*2){
4011 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4014 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4015 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4022 if (level>0) level= level * qmul + qadd;
4023 else level= level * qmul - qadd;
4029 #if MIN_CACHE_BITS < 20
4030 LAST_SKIP_BITS(re, &s->gb, 2);
4031 UPDATE_CACHE(re, &s->gb);
4033 SKIP_BITS(re, &s->gb, 2);
4035 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4036 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4037 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4038 LAST_SKIP_BITS(re, &s->gb, 1);
4042 #if MIN_CACHE_BITS < 19
4043 LAST_SKIP_BITS(re, &s->gb, 1);
4044 UPDATE_CACHE(re, &s->gb);
4046 SKIP_BITS(re, &s->gb, 1);
4048 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4050 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4051 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4052 LAST_SKIP_BITS(re, &s->gb, 1);
4057 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4058 LAST_SKIP_BITS(re, &s->gb, 1);
4063 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4067 block[scan_table[i]] = level;
4071 block[scan_table[i]] = level;
4073 CLOSE_READER(re, &s->gb);
4077 mpeg4_pred_ac(s, block, n, dc_pred_dir);
4079 i = 63; /* XXX: not optimal */
4082 s->block_last_index[n] = i;
4086 /* most is hardcoded. should extend to handle all h263 streams */
4087 int h263_decode_picture_header(MpegEncContext *s)
4089 int format, width, height, i;
4092 align_get_bits(&s->gb);
4094 startcode= get_bits(&s->gb, 22-8);
4096 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4097 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4099 if(startcode == 0x20)
4103 if (startcode != 0x20) {
4104 fprintf(stderr, "Bad picture start code\n");
4107 /* temporal reference */
4108 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4110 /* PTYPE starts here */
4111 if (get_bits1(&s->gb) != 1) {
4113 fprintf(stderr, "Bad marker\n");
4116 if (get_bits1(&s->gb) != 0) {
4117 fprintf(stderr, "Bad H263 id\n");
4118 return -1; /* h263 id */
4120 skip_bits1(&s->gb); /* split screen off */
4121 skip_bits1(&s->gb); /* camera off */
4122 skip_bits1(&s->gb); /* freeze picture release off */
4124 /* Reset GOB number */
4127 format = get_bits(&s->gb, 3);
4132 7 extended PTYPE (PLUSPTYPE)
4135 if (format != 7 && format != 6) {
4138 width = h263_format[format][0];
4139 height = h263_format[format][1];
4143 s->pict_type = I_TYPE + get_bits1(&s->gb);
4145 s->unrestricted_mv = get_bits1(&s->gb);
4146 s->h263_long_vectors = s->unrestricted_mv;
4148 if (get_bits1(&s->gb) != 0) {
4149 fprintf(stderr, "H263 SAC not supported\n");
4150 return -1; /* SAC: off */
4152 if (get_bits1(&s->gb) != 0) {
4153 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4156 if (get_bits1(&s->gb) != 0) {
4157 fprintf(stderr, "H263 PB frame not supported\n");
4158 return -1; /* not PB frame */
4160 s->qscale = get_bits(&s->gb, 5);
4161 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4170 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4172 /* ufep other than 0 and 1 are reserved */
4175 format = get_bits(&s->gb, 3);
4176 dprintf("ufep=1, format: %d\n", format);
4177 skip_bits(&s->gb,1); /* Custom PCF */
4178 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4179 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
4180 if (get_bits1(&s->gb) != 0) {
4181 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4183 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
4187 if (get_bits1(&s->gb) != 0) {
4188 fprintf(stderr, "Deblocking Filter not supported\n");
4190 if (get_bits1(&s->gb) != 0) {
4191 fprintf(stderr, "Slice Structured not supported\n");
4193 if (get_bits1(&s->gb) != 0) {
4194 fprintf(stderr, "Reference Picture Selection not supported\n");
4196 if (get_bits1(&s->gb) != 0) {
4197 fprintf(stderr, "Independent Segment Decoding not supported\n");
4199 if (get_bits1(&s->gb) != 0) {
4200 fprintf(stderr, "Alternative Inter VLC not supported\n");
4202 if (get_bits1(&s->gb) != 0) {
4203 fprintf(stderr, "Modified Quantization not supported\n");
4206 skip_bits(&s->gb, 1); /* Prevent start code emulation */
4208 skip_bits(&s->gb, 3); /* Reserved */
4209 } else if (ufep != 0) {
4210 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
4215 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4216 dprintf("pict_type: %d\n", s->pict_type);
4217 if (s->pict_type != I_TYPE &&
4218 s->pict_type != P_TYPE)
4220 skip_bits(&s->gb, 2);
4221 s->no_rounding = get_bits1(&s->gb);
4222 dprintf("RTYPE: %d\n", s->no_rounding);
4223 skip_bits(&s->gb, 4);
4225 /* Get the picture dimensions */
4228 /* Custom Picture Format (CPFMT) */
4229 s->aspect_ratio_info = get_bits(&s->gb, 4);
4230 dprintf("aspect: %d\n", s->aspect_ratio_info);
4235 3 - 10:11 (525-type 4:3)
4236 4 - 16:11 (CIF 16:9)
4237 5 - 40:33 (525-type 16:9)
4240 width = (get_bits(&s->gb, 9) + 1) * 4;
4242 height = get_bits(&s->gb, 9) * 4;
4243 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4244 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4245 /* aspected dimensions */
4246 s->aspected_width = get_bits(&s->gb, 8);
4247 s->aspected_height = get_bits(&s->gb, 8);
4249 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4250 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4253 width = h263_format[format][0];
4254 height = h263_format[format][1];
4256 if ((width == 0) || (height == 0))
4261 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4266 s->qscale = get_bits(&s->gb, 5);
4269 while (get_bits1(&s->gb) != 0) {
4270 skip_bits(&s->gb, 8);
4275 s->y_dc_scale_table=
4276 s->c_dc_scale_table= h263_aic_dc_scale_table;
4278 s->y_dc_scale_table=
4279 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4282 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4283 printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n",
4284 s->qscale, av_get_pict_type_char(s->pict_type),
4285 s->gb.size_in_bits, 1-s->no_rounding,
4286 s->mv_type == MV_TYPE_8X8 ? "ADV" : "",
4287 s->umvplus ? "UMV" : "",
4288 s->h263_long_vectors ? "LONG" : "",
4289 s->h263_plus ? "+" : ""
4297 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
4300 int a= 2<<s->sprite_warping_accuracy;
4301 int rho= 3-s->sprite_warping_accuracy;
4303 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
4304 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
4305 int sprite_ref[4][2];
4306 int virtual_ref[2][2];
4308 int alpha=0, beta=0;
4313 for(i=0; i<s->num_sprite_warping_points; i++){
4317 length= get_vlc(&s->gb, &sprite_trajectory);
4319 x= get_xbits(&s->gb, length);
4321 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4323 length= get_vlc(&s->gb, &sprite_trajectory);
4325 y=get_xbits(&s->gb, length);
4327 skip_bits1(&s->gb); /* marker bit */
4328 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4333 while((1<<alpha)<w) alpha++;
4334 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
4338 // Note, the 4th point isnt used for GMC
4339 if(s->divx_version==500 && s->divx_build==413){
4340 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4341 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4342 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
4343 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
4344 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
4345 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
4347 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
4348 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
4349 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
4350 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
4351 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
4352 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
4354 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4355 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4357 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4358 // perhaps it should be reordered to be more readable ...
4359 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4360 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4361 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
4362 + 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);
4363 virtual_ref[0][1]= 16*vop_ref[0][1]
4364 + 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);
4365 virtual_ref[1][0]= 16*vop_ref[0][0]
4366 + 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);
4367 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
4368 + 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);
4370 switch(s->num_sprite_warping_points)
4373 s->sprite_offset[0][0]= 0;
4374 s->sprite_offset[0][1]= 0;
4375 s->sprite_offset[1][0]= 0;
4376 s->sprite_offset[1][1]= 0;
4377 s->sprite_delta[0][0]= a;
4378 s->sprite_delta[0][1]= 0;
4379 s->sprite_delta[1][0]= 0;
4380 s->sprite_delta[1][1]= a;
4381 s->sprite_shift[0]= 0;
4382 s->sprite_shift[1]= 0;
4385 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
4386 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
4387 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
4388 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
4389 s->sprite_delta[0][0]= a;
4390 s->sprite_delta[0][1]= 0;
4391 s->sprite_delta[1][0]= 0;
4392 s->sprite_delta[1][1]= a;
4393 s->sprite_shift[0]= 0;
4394 s->sprite_shift[1]= 0;
4397 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
4398 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
4399 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
4400 + (1<<(alpha+rho-1));
4401 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
4402 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
4403 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
4404 + (1<<(alpha+rho-1));
4405 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4406 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4407 +2*w2*r*sprite_ref[0][0]
4409 + (1<<(alpha+rho+1)));
4410 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
4411 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4412 +2*w2*r*sprite_ref[0][1]
4414 + (1<<(alpha+rho+1)));
4415 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4416 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4417 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4418 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4420 s->sprite_shift[0]= alpha+rho;
4421 s->sprite_shift[1]= alpha+rho+2;
4424 min_ab= FFMIN(alpha, beta);
4427 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
4428 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
4429 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
4430 + (1<<(alpha+beta+rho-min_ab-1));
4431 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
4432 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
4433 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
4434 + (1<<(alpha+beta+rho-min_ab-1));
4435 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
4436 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
4437 + 2*w2*h3*r*sprite_ref[0][0]
4439 + (1<<(alpha+beta+rho-min_ab+1));
4440 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
4441 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
4442 + 2*w2*h3*r*sprite_ref[0][1]
4444 + (1<<(alpha+beta+rho-min_ab+1));
4445 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
4446 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4447 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4448 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4450 s->sprite_shift[0]= alpha + beta + rho - min_ab;
4451 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4454 /* try to simplify the situation */
4455 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4456 && s->sprite_delta[0][1] == 0
4457 && s->sprite_delta[1][0] == 0
4458 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
4460 s->sprite_offset[0][0]>>=s->sprite_shift[0];
4461 s->sprite_offset[0][1]>>=s->sprite_shift[0];
4462 s->sprite_offset[1][0]>>=s->sprite_shift[1];
4463 s->sprite_offset[1][1]>>=s->sprite_shift[1];
4464 s->sprite_delta[0][0]= a;
4465 s->sprite_delta[0][1]= 0;
4466 s->sprite_delta[1][0]= 0;
4467 s->sprite_delta[1][1]= a;
4468 s->sprite_shift[0]= 0;
4469 s->sprite_shift[1]= 0;
4470 s->real_sprite_warping_points=1;
4473 int shift_y= 16 - s->sprite_shift[0];
4474 int shift_c= 16 - s->sprite_shift[1];
4475 //printf("shifts %d %d\n", shift_y, shift_c);
4477 s->sprite_offset[0][i]<<= shift_y;
4478 s->sprite_offset[1][i]<<= shift_c;
4479 s->sprite_delta[0][i]<<= shift_y;
4480 s->sprite_delta[1][i]<<= shift_y;
4481 s->sprite_shift[i]= 16;
4483 s->real_sprite_warping_points= s->num_sprite_warping_points;
4486 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
4487 vop_ref[0][0], vop_ref[0][1],
4488 vop_ref[1][0], vop_ref[1][1],
4489 vop_ref[2][0], vop_ref[2][1],
4490 sprite_ref[0][0], sprite_ref[0][1],
4491 sprite_ref[1][0], sprite_ref[1][1],
4492 sprite_ref[2][0], sprite_ref[2][1],
4493 virtual_ref[0][0], virtual_ref[0][1],
4494 virtual_ref[1][0], virtual_ref[1][1]
4497 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4498 s->sprite_offset[0][0], s->sprite_offset[0][1],
4499 s->sprite_delta[0][0], s->sprite_delta[0][1],
4500 s->sprite_delta[1][0], s->sprite_delta[1][1],
4506 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
4507 int hours, minutes, seconds;
4509 hours= get_bits(gb, 5);
4510 minutes= get_bits(gb, 6);
4512 seconds= get_bits(gb, 6);
4514 s->time_base= seconds + 60*(minutes + 60*hours);
4522 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
4523 int width, height, vo_ver_id;
4526 skip_bits(gb, 1); /* random access */
4527 s->vo_type= get_bits(gb, 8);
4528 if (get_bits1(gb) != 0) { /* is_ol_id */
4529 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
4530 skip_bits(gb, 3); /* vo_priority */
4534 //printf("vo type:%d\n",s->vo_type);
4535 s->aspect_ratio_info= get_bits(gb, 4);
4536 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
4537 s->aspected_width = get_bits(gb, 8); // par_width
4538 s->aspected_height = get_bits(gb, 8); // par_height
4540 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4541 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
4544 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4545 int chroma_format= get_bits(gb, 2);
4546 if(chroma_format!=1){
4547 printf("illegal chroma format\n");
4549 s->low_delay= get_bits1(gb);
4550 if(get_bits1(gb)){ /* vbv parameters */
4551 get_bits(gb, 15); /* first_half_bitrate */
4552 skip_bits1(gb); /* marker */
4553 get_bits(gb, 15); /* latter_half_bitrate */
4554 skip_bits1(gb); /* marker */
4555 get_bits(gb, 15); /* first_half_vbv_buffer_size */
4556 skip_bits1(gb); /* marker */
4557 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
4558 get_bits(gb, 11); /* first_half_vbv_occupancy */
4559 skip_bits1(gb); /* marker */
4560 get_bits(gb, 15); /* latter_half_vbv_occupancy */
4561 skip_bits1(gb); /* marker */
4564 // set low delay flag only once so the smart? low delay detection wont be overriden
4565 if(s->picture_number==0)
4569 s->shape = get_bits(gb, 2); /* vol shape */
4570 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
4571 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4572 printf("Gray shape not supported\n");
4573 skip_bits(gb, 4); //video_object_layer_shape_extension
4576 check_marker(gb, "before time_increment_resolution");
4578 s->time_increment_resolution = get_bits(gb, 16);
4580 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
4581 if (s->time_increment_bits < 1)
4582 s->time_increment_bits = 1;
4584 check_marker(gb, "before fixed_vop_rate");
4586 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
4587 skip_bits(gb, s->time_increment_bits);
4590 if (s->shape != BIN_ONLY_SHAPE) {
4591 if (s->shape == RECT_SHAPE) {
4592 skip_bits1(gb); /* marker */
4593 width = get_bits(gb, 13);
4594 skip_bits1(gb); /* marker */
4595 height = get_bits(gb, 13);
4596 skip_bits1(gb); /* marker */
4597 if(width && height){ /* they should be non zero but who knows ... */
4600 // printf("width/height: %d %d\n", width, height);
4604 s->progressive_sequence= get_bits1(gb)^1;
4605 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
4606 printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
4607 if (vo_ver_id == 1) {
4608 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4610 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4612 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
4613 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4614 if(s->vol_sprite_usage==STATIC_SPRITE){
4615 s->sprite_width = get_bits(gb, 13);
4616 skip_bits1(gb); /* marker */
4617 s->sprite_height= get_bits(gb, 13);
4618 skip_bits1(gb); /* marker */
4619 s->sprite_left = get_bits(gb, 13);
4620 skip_bits1(gb); /* marker */
4621 s->sprite_top = get_bits(gb, 13);
4622 skip_bits1(gb); /* marker */
4624 s->num_sprite_warping_points= get_bits(gb, 6);
4625 s->sprite_warping_accuracy = get_bits(gb, 2);
4626 s->sprite_brightness_change= get_bits1(gb);
4627 if(s->vol_sprite_usage==STATIC_SPRITE)
4628 s->low_latency_sprite= get_bits1(gb);
4630 // FIXME sadct disable bit if verid!=1 && shape not rect
4632 if (get_bits1(gb) == 1) { /* not_8_bit */
4633 s->quant_precision = get_bits(gb, 4); /* quant_precision */
4634 if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4635 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
4637 s->quant_precision = 5;
4640 // FIXME a bunch of grayscale shape things
4642 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4645 /* load default matrixes */
4646 for(i=0; i<64; i++){
4647 int j= s->dsp.idct_permutation[i];
4648 v= ff_mpeg4_default_intra_matrix[i];
4649 s->intra_matrix[j]= v;
4650 s->chroma_intra_matrix[j]= v;
4652 v= ff_mpeg4_default_non_intra_matrix[i];
4653 s->inter_matrix[j]= v;
4654 s->chroma_inter_matrix[j]= v;
4657 /* load custom intra matrix */
4660 for(i=0; i<64; i++){
4666 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4667 s->intra_matrix[j]= v;
4668 s->chroma_intra_matrix[j]= v;
4671 /* replicate last value */
4673 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4674 s->intra_matrix[j]= last;
4675 s->chroma_intra_matrix[j]= last;
4679 /* load custom non intra matrix */
4682 for(i=0; i<64; i++){
4688 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4689 s->inter_matrix[j]= v;
4690 s->chroma_inter_matrix[j]= v;
4693 /* replicate last value */
4695 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4696 s->inter_matrix[j]= last;
4697 s->chroma_inter_matrix[j]= last;
4701 // FIXME a bunch of grayscale shape things
4705 s->quarter_sample= get_bits1(gb);
4706 else s->quarter_sample=0;
4708 if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
4710 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4712 s->data_partitioning= get_bits1(gb);
4713 if(s->data_partitioning){
4714 s->rvlc= get_bits1(gb);
4717 if(vo_ver_id != 1) {
4718 s->new_pred= get_bits1(gb);
4720 printf("new pred not supported\n");
4721 skip_bits(gb, 2); /* requested upstream message type */
4722 skip_bits1(gb); /* newpred segment type */
4724 s->reduced_res_vop= get_bits1(gb);
4725 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4729 s->reduced_res_vop= 0;
4732 s->scalability= get_bits1(gb);
4734 if (s->scalability) {
4735 GetBitContext bak= *gb;
4737 int ref_layer_sampling_dir;
4738 int h_sampling_factor_n;
4739 int h_sampling_factor_m;
4740 int v_sampling_factor_n;
4741 int v_sampling_factor_m;
4743 s->hierachy_type= get_bits1(gb);
4744 ref_layer_id= get_bits(gb, 4);
4745 ref_layer_sampling_dir= get_bits1(gb);
4746 h_sampling_factor_n= get_bits(gb, 5);
4747 h_sampling_factor_m= get_bits(gb, 5);
4748 v_sampling_factor_n= get_bits(gb, 5);
4749 v_sampling_factor_m= get_bits(gb, 5);
4750 s->enhancement_type= get_bits1(gb);
4752 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
4753 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
4755 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4760 printf("scalability not supported\n");
4762 // bin shape stuff FIXME
4769 * decodes the user data stuff in the header.
4770 * allso inits divx/xvid/lavc_version/build
4772 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
4776 int ver, build, ver2, ver3;
4779 buf[0]= show_bits(gb, 8);
4780 for(i=1; i<256; i++){
4781 buf[i]= show_bits(gb, 16)&0xFF;
4782 if(buf[i]==0) break;
4787 /* divx detection */
4788 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
4790 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
4792 s->divx_version= ver;
4793 s->divx_build= build;
4794 s->divx_packed= e==3 && last=='p';
4797 /* ffmpeg detection */
4798 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
4800 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
4802 if(strcmp(buf, "ffmpeg")==0){
4803 s->ffmpeg_version= 0x000406;
4804 s->lavc_build= 4600;
4808 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4809 s->lavc_build= build;
4812 /* xvid detection */
4813 e=sscanf(buf, "XviD%d", &build);
4815 s->xvid_build= build;
4818 //printf("User Data: %s\n", buf);
4822 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4823 int time_incr, time_increment;
4825 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
4826 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
4827 printf("low_delay flag set, but shouldnt, clearing it\n");
4831 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4832 if(s->partitioned_frame)
4833 s->decode_mb= mpeg4_decode_partitioned_mb;
4835 s->decode_mb= ff_h263_decode_mb;
4837 if(s->time_increment_resolution==0){
4838 s->time_increment_resolution=1;
4839 // fprintf(stderr, "time_increment_resolution is illegal\n");
4842 while (get_bits1(gb) != 0)
4845 check_marker(gb, "before time_increment");
4847 if(s->time_increment_bits==0){
4848 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4850 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
4851 if(show_bits(gb, s->time_increment_bits+1)&1) break;
4854 printf("my guess is %d bits ;)\n",s->time_increment_bits);
4857 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
4858 else time_increment= get_bits(gb, s->time_increment_bits);
4860 // printf("%d %X\n", s->time_increment_bits, time_increment);
4861 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4862 if(s->pict_type!=B_TYPE){
4863 s->last_time_base= s->time_base;
4864 s->time_base+= time_incr;
4865 s->time= s->time_base*s->time_increment_resolution + time_increment;
4866 if(s->workaround_bugs&FF_BUG_UMP4){
4867 if(s->time < s->last_non_b_time){
4868 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4870 s->time+= s->time_increment_resolution;
4873 s->pp_time= s->time - s->last_non_b_time;
4874 s->last_non_b_time= s->time;
4876 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4877 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4878 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4879 // printf("messed up order, seeking?, skiping current b frame\n");
4880 return FRAME_SKIPED;
4883 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4884 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4885 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4886 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4887 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4888 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
4889 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4892 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4893 if(s->avctx->debug&FF_DEBUG_PTS)
4894 printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4896 check_marker(gb, "before vop_coded");
4899 if (get_bits1(gb) != 1){
4900 printf("vop not coded\n");
4901 return FRAME_SKIPED;
4903 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4904 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4905 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4906 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4907 /* rounding type for motion estimation */
4908 s->no_rounding = get_bits1(gb);
4912 //FIXME reduced res stuff
4914 if (s->shape != RECT_SHAPE) {
4915 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4916 int width, height, hor_spat_ref, ver_spat_ref;
4918 width = get_bits(gb, 13);
4919 skip_bits1(gb); /* marker */
4920 height = get_bits(gb, 13);
4921 skip_bits1(gb); /* marker */
4922 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
4923 skip_bits1(gb); /* marker */
4924 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4926 skip_bits1(gb); /* change_CR_disable */
4928 if (get_bits1(gb) != 0) {
4929 skip_bits(gb, 8); /* constant_alpha_value */
4932 //FIXME complexity estimation stuff
4934 if (s->shape != BIN_ONLY_SHAPE) {
4936 t=get_bits(gb, 3); /* intra dc VLC threshold */
4937 //printf("threshold %d\n", t);
4938 if(!s->progressive_sequence){
4939 s->top_field_first= get_bits1(gb);
4940 s->alternate_scan= get_bits1(gb);
4942 s->alternate_scan= 0;
4945 if(s->alternate_scan){
4946 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
4947 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
4948 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
4949 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
4951 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
4952 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
4953 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4954 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
4957 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4958 mpeg4_decode_sprite_trajectory(s);
4959 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4960 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4963 if (s->shape != BIN_ONLY_SHAPE) {
4964 s->qscale = get_bits(gb, s->quant_precision);
4966 printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4967 return -1; // makes no sense to continue, as there is nothing left from the image then
4970 if (s->pict_type != I_TYPE) {
4971 s->f_code = get_bits(gb, 3); /* fcode_for */
4973 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4974 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4979 if (s->pict_type == B_TYPE) {
4980 s->b_code = get_bits(gb, 3);
4984 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4985 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 vot:%d%s\n",
4986 s->qscale, s->f_code, s->b_code,
4987 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4988 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
4989 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4990 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ");
4993 if(!s->scalability){
4994 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4995 skip_bits1(gb); // vop shape coding type
4998 if(s->enhancement_type){
4999 int load_backward_shape= get_bits1(gb);
5000 if(load_backward_shape){
5001 printf("load backward shape isnt supported\n");
5004 skip_bits(gb, 2); //ref_select_code
5007 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
5008 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
5009 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5010 printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5014 s->picture_number++; // better than pic number==0 allways ;)
5016 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5017 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5019 if(s->workaround_bugs&FF_BUG_EDGE){
5020 s->h_edge_pos= s->width;
5021 s->v_edge_pos= s->height;
5027 * decode mpeg4 headers
5028 * @return <0 if no VOP found (or a damaged one)
5029 * FRAME_SKIPPED if a not coded VOP is found
5030 * 0 if a VOP is found
5032 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
5036 /* search next start code */
5040 v = get_bits(gb, 8);
5041 startcode = ((startcode << 8) | v) & 0xffffffff;
5043 if(get_bits_count(gb) >= gb->size_in_bits){
5044 if(gb->size_in_bits==8 && s->divx_version){
5045 printf("frame skip %d\n", gb->size_in_bits);
5046 return FRAME_SKIPED; //divx bug
5048 return -1; //end of stream
5051 if((startcode&0xFFFFFF00) != 0x100)
5052 continue; //no startcode
5054 if(s->avctx->debug&FF_DEBUG_STARTCODE){
5055 printf("startcode: %3X ", startcode);
5056 if (startcode<=0x11F) printf("Video Object Start");
5057 else if(startcode<=0x12F) printf("Video Object Layer Start");
5058 else if(startcode<=0x13F) printf("Reserved");
5059 else if(startcode<=0x15F) printf("FGS bp start");
5060 else if(startcode<=0x1AF) printf("Reserved");
5061 else if(startcode==0x1B0) printf("Visual Object Seq Start");
5062 else if(startcode==0x1B1) printf("Visual Object Seq End");
5063 else if(startcode==0x1B2) printf("User Data");
5064 else if(startcode==0x1B3) printf("Group of VOP start");
5065 else if(startcode==0x1B4) printf("Video Session Error");
5066 else if(startcode==0x1B5) printf("Visual Object Start");
5067 else if(startcode==0x1B6) printf("Video Object Plane start");
5068 else if(startcode==0x1B7) printf("slice start");
5069 else if(startcode==0x1B8) printf("extension start");
5070 else if(startcode==0x1B9) printf("fgs start");
5071 else if(startcode==0x1BA) printf("FBA Object start");
5072 else if(startcode==0x1BB) printf("FBA Object Plane start");
5073 else if(startcode==0x1BC) printf("Mesh Object start");
5074 else if(startcode==0x1BD) printf("Mesh Object Plane start");
5075 else if(startcode==0x1BE) printf("Still Textutre Object start");
5076 else if(startcode==0x1BF) printf("Textutre Spatial Layer start");
5077 else if(startcode==0x1C0) printf("Textutre SNR Layer start");
5078 else if(startcode==0x1C1) printf("Textutre Tile start");
5079 else if(startcode==0x1C2) printf("Textutre Shape Layer start");
5080 else if(startcode==0x1C3) printf("stuffing start");
5081 else if(startcode<=0x1C5) printf("reserved");
5082 else if(startcode<=0x1FF) printf("System start");
5083 printf(" at %d\n", get_bits_count(gb));
5088 if(decode_vol_header(s, gb) < 0)
5091 case USER_DATA_STARTCODE:
5092 decode_user_data(s, gb);
5095 mpeg4_decode_gop_header(s, gb);
5098 return decode_vop_header(s, gb);
5108 /* don't understand why they choose a different header ! */
5109 int intel_h263_decode_picture_header(MpegEncContext *s)
5113 /* picture header */
5114 if (get_bits_long(&s->gb, 22) != 0x20) {
5115 fprintf(stderr, "Bad picture start code\n");
5118 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5120 if (get_bits1(&s->gb) != 1) {
5121 fprintf(stderr, "Bad marker\n");
5122 return -1; /* marker */
5124 if (get_bits1(&s->gb) != 0) {
5125 fprintf(stderr, "Bad H263 id\n");
5126 return -1; /* h263 id */
5128 skip_bits1(&s->gb); /* split screen off */
5129 skip_bits1(&s->gb); /* camera off */
5130 skip_bits1(&s->gb); /* freeze picture release off */
5132 format = get_bits(&s->gb, 3);
5134 fprintf(stderr, "Intel H263 free format not supported\n");
5139 s->pict_type = I_TYPE + get_bits1(&s->gb);
5141 s->unrestricted_mv = get_bits1(&s->gb);
5142 s->h263_long_vectors = s->unrestricted_mv;
5144 if (get_bits1(&s->gb) != 0) {
5145 fprintf(stderr, "SAC not supported\n");
5146 return -1; /* SAC: off */
5148 if (get_bits1(&s->gb) != 0) {
5149 fprintf(stderr, "Advanced Prediction Mode not supported\n");
5150 return -1; /* advanced prediction mode: off */
5152 if (get_bits1(&s->gb) != 0) {
5153 fprintf(stderr, "PB frame mode no supported\n");
5154 return -1; /* PB frame mode */
5157 /* skip unknown header garbage */
5158 skip_bits(&s->gb, 41);
5160 s->qscale = get_bits(&s->gb, 5);
5161 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5164 while (get_bits1(&s->gb) != 0) {
5165 skip_bits(&s->gb, 8);
5169 s->y_dc_scale_table=
5170 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5175 int flv_h263_decode_picture_header(MpegEncContext *s)
5177 int format, width, height;
5179 /* picture header */
5180 if (get_bits_long(&s->gb, 17) != 1) {
5181 fprintf(stderr, "Bad picture start code\n");
5184 format = get_bits(&s->gb, 5);
5185 if (format != 0 && format != 1) {
5186 fprintf(stderr, "Bad picture format\n");
5189 s->h263_flv = format+1;
5190 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5191 format = get_bits(&s->gb, 3);
5194 width = get_bits(&s->gb, 8);
5195 height = get_bits(&s->gb, 8);
5198 width = get_bits(&s->gb, 16);
5199 height = get_bits(&s->gb, 16);
5225 if ((width == 0) || (height == 0))
5230 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
5231 if (s->pict_type > P_TYPE)
5232 s->pict_type = P_TYPE;
5233 skip_bits1(&s->gb); /* deblocking flag */
5234 s->qscale = get_bits(&s->gb, 5);
5238 s->unrestricted_mv = 1;
5239 s->h263_long_vectors = 0;
5242 while (get_bits1(&s->gb) != 0) {
5243 skip_bits(&s->gb, 8);
5247 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
5248 printf("%c esc_type:%d, qp:%d num:%d\n",
5249 av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
5252 s->y_dc_scale_table=
5253 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;