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>
30 #include "mpegvideo.h"
32 #include "mpeg4data.h"
34 //rounded divison & shift
35 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
37 #define PRINT_MB_TYPE(a) {}
38 //#define PRINT_MB_TYPE(a) printf(a)
40 #define INTRA_MCBPC_VLC_BITS 6
41 #define INTER_MCBPC_VLC_BITS 6
42 #define CBPY_VLC_BITS 6
45 #define SPRITE_TRAJ_VLC_BITS 6
46 #define MB_TYPE_B_VLC_BITS 4
47 #define TEX_VLC_BITS 9
49 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
51 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
52 static void h263p_encode_umotion(MpegEncContext * s, int val);
53 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
54 int n, int dc, UINT8 *scan_table,
55 PutBitContext *dc_pb, PutBitContext *ac_pb);
56 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
57 static int h263p_decode_umotion(MpegEncContext * s, int pred);
58 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
60 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
61 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
62 int n, int coded, int intra);
63 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
64 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
66 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
68 extern UINT32 inverse[256];
70 static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
71 static UINT8 fcode_tab[MAX_MV*2+1];
72 static UINT8 umv_fcode_tab[MAX_MV*2+1];
74 static UINT16 uni_DCtab_lum [512][2];
75 static UINT16 uni_DCtab_chrom[512][2];
76 static UINT32 uni_mpeg4_intra_rl_bits[64*64*2*2];
77 static UINT8 uni_mpeg4_intra_rl_len [64*64*2*2];
78 static UINT32 uni_mpeg4_inter_rl_bits[64*64*2*2];
79 static UINT8 uni_mpeg4_inter_rl_len [64*64*2*2];
80 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
81 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
93 int h263_get_picture_format(int width, int height)
97 if (width == 128 && height == 96)
99 else if (width == 176 && height == 144)
101 else if (width == 352 && height == 288)
103 else if (width == 704 && height == 576)
105 else if (width == 1408 && height == 1152)
112 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
116 align_put_bits(&s->pb);
118 /* Update the pointer to last GOB */
119 s->ptr_lastgob = pbBufPtr(&s->pb);
122 put_bits(&s->pb, 22, 0x20); /* PSC */
123 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
124 s->frame_rate) & 0xff);
126 put_bits(&s->pb, 1, 1); /* marker */
127 put_bits(&s->pb, 1, 0); /* h263 id */
128 put_bits(&s->pb, 1, 0); /* split screen off */
129 put_bits(&s->pb, 1, 0); /* camera off */
130 put_bits(&s->pb, 1, 0); /* freeze picture release off */
132 format = h263_get_picture_format(s->width, s->height);
135 put_bits(&s->pb, 3, format);
136 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
137 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
138 of H.263v1 UMV implies to check the predicted MV after
139 calculation of the current MB to see if we're on the limits */
140 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
141 put_bits(&s->pb, 1, 0); /* SAC: off */
142 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
143 put_bits(&s->pb, 1, 0); /* not PB frame */
144 put_bits(&s->pb, 5, s->qscale);
145 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
148 /* H.263 Plus PTYPE */
149 put_bits(&s->pb, 3, 7);
150 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
152 put_bits(&s->pb,3,6); /* Custom Source Format */
154 put_bits(&s->pb, 3, format);
156 put_bits(&s->pb,1,0); /* Custom PCF: off */
157 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
158 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
159 put_bits(&s->pb,1,0); /* SAC: off */
160 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
161 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
162 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
163 put_bits(&s->pb,1,0); /* Slice Structured: off */
164 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
165 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
166 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
167 put_bits(&s->pb,1,0); /* Modified Quantization: off */
168 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
169 put_bits(&s->pb,3,0); /* Reserved */
171 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
173 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
174 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
175 if (s->pict_type == I_TYPE)
179 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
180 put_bits(&s->pb,2,0); /* Reserved */
181 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
183 /* This should be here if PLUSPTYPE */
184 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
187 /* Custom Picture Format (CPFMT) */
189 if (s->aspect_ratio_info)
190 put_bits(&s->pb,4,s->aspect_ratio_info);
192 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
193 put_bits(&s->pb,9,(s->width >> 2) - 1);
194 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
195 put_bits(&s->pb,9,(s->height >> 2));
198 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
200 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
201 put_bits(&s->pb, 5, s->qscale);
204 put_bits(&s->pb, 1, 0); /* no PEI */
208 s->c_dc_scale_table= h263_aic_dc_scale_table;
211 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
215 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
219 /* Check to see if we need to put a new GBSC */
220 /* for RTP packetization */
222 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
223 if (pdif >= s->rtp_payload_size) {
224 /* Bad luck, packet must be cut before */
225 align_put_bits(&s->pb);
226 flush_put_bits(&s->pb);
227 /* Call the RTP callback to send the last GOB */
228 if (s->rtp_callback) {
229 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
230 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
232 s->ptr_lastgob = pbBufPtr(&s->pb);
233 put_bits(&s->pb, 17, 1); /* GBSC */
234 s->gob_number = mb_line / s->gob_index;
235 put_bits(&s->pb, 5, s->gob_number); /* GN */
236 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
237 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
238 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
240 } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
241 /* Cut the packet before we can't */
242 align_put_bits(&s->pb);
243 flush_put_bits(&s->pb);
244 /* Call the RTP callback to send the last GOB */
245 if (s->rtp_callback) {
246 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
247 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
249 s->ptr_lastgob = pbBufPtr(&s->pb);
250 put_bits(&s->pb, 17, 1); /* GBSC */
251 s->gob_number = mb_line / s->gob_index;
252 put_bits(&s->pb, 5, s->gob_number); /* GN */
253 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
254 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
255 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
262 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
264 int score0=0, score1=0;
268 INT16 *ac_val, *ac_val1;
270 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
273 ac_val-= s->block_wrap[n]*16;
275 const int level= block[n][block_permute_op(i )];
277 score1+= ABS(level - ac_val[i+8]);
278 ac_val1[i ]= block[n][block_permute_op(i<<3)];
284 const int level= block[n][block_permute_op(i<<3)];
286 score1+= ABS(level - ac_val[i]);
288 ac_val1[i+8]= block[n][block_permute_op(i )];
293 return score0 > score1 ? 1 : 0;
296 void mpeg4_encode_mb(MpegEncContext * s,
297 DCTELEM block[6][64],
298 int motion_x, int motion_y)
300 int cbpc, cbpy, i, pred_x, pred_y;
302 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
303 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
304 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
305 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
307 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
311 for (i = 0; i < 6; i++) {
312 if (s->block_last_index[i] >= 0)
316 if(s->pict_type==B_TYPE){
317 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
318 int mb_type= mb_type_table[s->mv_dir];
324 s->last_mv[1][0][1]= 0;
327 /* nothing to do if this MB was skiped in the next P Frame */
328 if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
334 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
338 if ((cbp | motion_x | motion_y | mb_type) ==0) {
339 /* direct MB with MV={0,0} */
340 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
342 if(interleaved_stats){
349 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
350 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
351 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
352 if(cbp) put_bits(&s->pb, 6, cbp);
355 put_bits(&s->pb, 1, 0); /* no q-scale change */
357 if(interleaved_stats){
358 bits= get_bit_count(&s->pb);
359 s->misc_bits+= bits - s->last_bits;
366 h263_encode_motion(s, motion_x, 1);
367 h263_encode_motion(s, motion_y, 1);
372 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
373 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
374 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
375 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
376 s->last_mv[0][0][0]= s->mv[0][0][0];
377 s->last_mv[0][0][1]= s->mv[0][0][1];
378 s->last_mv[1][0][0]= s->mv[1][0][0];
379 s->last_mv[1][0][1]= s->mv[1][0][1];
383 case 2: /* backward */
384 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
385 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
386 s->last_mv[1][0][0]= motion_x;
387 s->last_mv[1][0][1]= motion_y;
390 case 3: /* forward */
391 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
392 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
393 s->last_mv[0][0][0]= motion_x;
394 s->last_mv[0][0][1]= motion_y;
398 printf("unknown mb type\n");
402 if(interleaved_stats){
403 bits= get_bit_count(&s->pb);
404 s->mv_bits+= bits - s->last_bits;
408 /* encode each block */
409 for (i = 0; i < 6; i++) {
410 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb);
413 if(interleaved_stats){
414 bits= get_bit_count(&s->pb);
415 s->p_tex_bits+= bits - s->last_bits;
418 }else{ /* s->pict_type==B_TYPE */
419 if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
420 /* check if the B frames can skip it too, as we must skip it if we skip here
421 why didnt they just compress the skip-mb bits instead of reusing them ?! */
422 if(s->max_b_frames>0){
429 if(x+16 > s->width) x= s->width-16;
430 if(y+16 > s->height) y= s->height-16;
432 offset= x + y*s->linesize;
433 p_pic= s->new_picture[0] + offset;
436 for(i=0; i<s->max_b_frames; i++){
440 if(s->coded_order[i+1].pict_type!=B_TYPE) break;
442 b_pic= s->coded_order[i+1].picture[0] + offset;
443 diff= pix_abs16x16(p_pic, b_pic, s->linesize);
444 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
453 /* skip macroblock */
454 put_bits(&s->pb, 1, 1);
456 if(interleaved_stats){
465 put_bits(&s->pb, 1, 0); /* mb coded */
466 if(s->mv_type==MV_TYPE_16X16){
469 inter_MCBPC_bits[cbpc],
470 inter_MCBPC_code[cbpc]);
473 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
475 if(interleaved_stats){
476 bits= get_bit_count(&s->pb);
477 s->misc_bits+= bits - s->last_bits;
481 /* motion vectors: 16x16 mode */
482 h263_pred_motion(s, 0, &pred_x, &pred_y);
484 h263_encode_motion(s, motion_x - pred_x, s->f_code);
485 h263_encode_motion(s, motion_y - pred_y, s->f_code);
489 inter_MCBPC_bits[cbpc],
490 inter_MCBPC_code[cbpc]);
493 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
495 if(interleaved_stats){
496 bits= get_bit_count(&s->pb);
497 s->misc_bits+= bits - s->last_bits;
502 /* motion vectors: 8x8 mode*/
503 h263_pred_motion(s, i, &pred_x, &pred_y);
505 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
506 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
510 if(interleaved_stats){
511 bits= get_bit_count(&s->pb);
512 s->mv_bits+= bits - s->last_bits;
516 /* encode each block */
517 for (i = 0; i < 6; i++) {
518 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb);
521 if(interleaved_stats){
522 bits= get_bit_count(&s->pb);
523 s->p_tex_bits+= bits - s->last_bits;
530 int dc_diff[6]; //dc values with the dc prediction subtracted
531 int dir[6]; //prediction direction
532 int zigzag_last_index[6];
533 UINT8 *scan_table[6];
536 const int level= block[i][0];
539 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
541 *dc_ptr = level * s->y_dc_scale;
543 *dc_ptr = level * s->c_dc_scale;
547 s->ac_pred= decide_ac_pred(s, block, dir);
554 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
555 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
556 else st = ff_alternate_horizontal_scan; /* top */
558 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
559 if(block[i][st[last_index]]) break;
560 zigzag_last_index[i]= s->block_last_index[i];
561 s->block_last_index[i]= last_index;
566 scan_table[i]= zigzag_direct;
571 for (i = 0; i < 6; i++) {
572 if (s->block_last_index[i] >= 1)
577 if (s->pict_type == I_TYPE) {
579 intra_MCBPC_bits[cbpc],
580 intra_MCBPC_code[cbpc]);
582 put_bits(&s->pb, 1, 0); /* mb coded */
584 inter_MCBPC_bits[cbpc + 4],
585 inter_MCBPC_code[cbpc + 4]);
587 put_bits(pb2, 1, s->ac_pred);
589 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
591 if(interleaved_stats){
592 bits= get_bit_count(&s->pb);
593 s->misc_bits+= bits - s->last_bits;
597 /* encode each block */
598 for (i = 0; i < 6; i++) {
599 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
602 if(interleaved_stats){
603 bits= get_bit_count(&s->pb);
604 s->i_tex_bits+= bits - s->last_bits;
609 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
615 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
619 block[i][block_permute_op(j )]= ac_val[j+8];
622 block[i][block_permute_op(j<<3)]= ac_val[j ];
624 s->block_last_index[i]= zigzag_last_index[i];
630 void h263_encode_mb(MpegEncContext * s,
631 DCTELEM block[6][64],
632 int motion_x, int motion_y)
634 int cbpc, cbpy, i, cbp, pred_x, pred_y;
636 INT16 rec_intradc[6];
639 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
643 for (i = 0; i < 6; i++) {
644 if (s->block_last_index[i] >= 0)
647 if ((cbp | motion_x | motion_y) == 0) {
648 /* skip macroblock */
649 put_bits(&s->pb, 1, 1);
652 put_bits(&s->pb, 1, 0); /* mb coded */
655 inter_MCBPC_bits[cbpc],
656 inter_MCBPC_code[cbpc]);
659 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
661 /* motion vectors: 16x16 mode only now */
662 h263_pred_motion(s, 0, &pred_x, &pred_y);
665 h263_encode_motion(s, motion_x - pred_x, s->f_code);
666 h263_encode_motion(s, motion_y - pred_y, s->f_code);
669 h263p_encode_umotion(s, motion_x - pred_x);
670 h263p_encode_umotion(s, motion_y - pred_y);
671 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
672 /* To prevent Start Code emulation */
673 put_bits(&s->pb,1,1);
676 int li = s->h263_aic ? 0 : 1;
681 if (s->h263_aic && s->mb_intra) {
682 INT16 level = block[i][0];
684 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
688 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
690 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
692 /* AIC can change CBP */
693 if (level == 0 && s->block_last_index[i] == 0)
694 s->block_last_index[i] = -1;
695 else if (level < -127)
697 else if (level > 127)
702 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
705 //if ((rec_intradc[i] % 2) == 0)
708 if (rec_intradc[i] < 0)
710 else if (rec_intradc[i] > 2047)
711 rec_intradc[i] = 2047;
713 /* Update AC/DC tables */
714 *dc_ptr[i] = rec_intradc[i];
717 if (s->block_last_index[i] >= li)
722 if (s->pict_type == I_TYPE) {
724 intra_MCBPC_bits[cbpc],
725 intra_MCBPC_code[cbpc]);
727 put_bits(&s->pb, 1, 0); /* mb coded */
729 inter_MCBPC_bits[cbpc + 4],
730 inter_MCBPC_code[cbpc + 4]);
733 /* XXX: currently, we do not try to use ac prediction */
734 put_bits(&s->pb, 1, 0); /* no AC prediction */
737 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
741 /* encode each block */
742 h263_encode_block(s, block[i], i);
744 /* Update INTRADC for decoding */
745 if (s->h263_aic && s->mb_intra) {
746 block[i][0] = rec_intradc[i];
752 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
754 int x, y, wrap, a, c, pred_dc, scale;
755 INT16 *dc_val, *ac_val;
757 /* find prediction */
759 x = 2 * s->mb_x + 1 + (n & 1);
760 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
761 wrap = s->mb_width * 2 + 2;
762 dc_val = s->dc_val[0];
763 ac_val = s->ac_val[0][0];
764 scale = s->y_dc_scale;
768 wrap = s->mb_width + 2;
769 dc_val = s->dc_val[n - 4 + 1];
770 ac_val = s->ac_val[n - 4 + 1][0];
771 scale = s->c_dc_scale;
776 a = dc_val[(x - 1) + (y) * wrap];
777 c = dc_val[(x) + (y - 1) * wrap];
779 /* No prediction outside GOB boundary */
780 if (s->first_slice_line && ((n < 2) || (n > 3)))
783 /* just DC prediction */
784 if (a != 1024 && c != 1024)
785 pred_dc = (a + c) >> 1;
791 /* we assume pred is positive */
792 //pred_dc = (pred_dc + (scale >> 1)) / scale;
793 *dc_val_ptr = &dc_val[x + y * wrap];
798 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
800 int x, y, wrap, a, c, pred_dc, scale, i;
801 INT16 *dc_val, *ac_val, *ac_val1;
803 /* find prediction */
805 x = 2 * s->mb_x + 1 + (n & 1);
806 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
807 wrap = s->mb_width * 2 + 2;
808 dc_val = s->dc_val[0];
809 ac_val = s->ac_val[0][0];
810 scale = s->y_dc_scale;
814 wrap = s->mb_width + 2;
815 dc_val = s->dc_val[n - 4 + 1];
816 ac_val = s->ac_val[n - 4 + 1][0];
817 scale = s->c_dc_scale;
820 ac_val += ((y) * wrap + (x)) * 16;
826 a = dc_val[(x - 1) + (y) * wrap];
827 c = dc_val[(x) + (y - 1) * wrap];
829 /* No prediction outside GOB boundary */
830 if (s->first_slice_line && ((n < 2) || (n > 3)))
834 if (s->h263_aic_dir) {
835 /* left prediction */
839 block[block_permute_op(i*8)] += ac_val[i];
848 block[block_permute_op(i)] += ac_val[i + 8];
854 /* just DC prediction */
855 if (a != 1024 && c != 1024)
856 pred_dc = (a + c) >> 1;
863 /* we assume pred is positive */
864 block[0]=block[0]*scale + pred_dc;
868 else if (!(block[0] & 1))
871 /* Update AC/DC tables */
872 dc_val[(x) + (y) * wrap] = block[0];
876 ac_val1[i] = block[block_permute_op(i * 8)];
879 ac_val1[8 + i] = block[block_permute_op(i)];
882 INT16 *h263_pred_motion(MpegEncContext * s, int block,
886 INT16 *A, *B, *C, *mot_val;
887 static const int off[4]= {2, 1, 1, -1};
889 wrap = s->block_wrap[0];
890 xy = s->block_index[block];
892 mot_val = s->motion_val[xy];
894 A = s->motion_val[xy - 1];
895 /* special case for first (slice) line */
896 if ((s->mb_y == 0 || s->first_slice_line) && block<3) {
897 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
898 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
899 if(block==0){ //most common case
900 if(s->mb_x == s->resync_mb_x){ //rare
902 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
903 C = s->motion_val[xy + off[block] - wrap];
908 *px = mid_pred(A[0], 0, C[0]);
909 *py = mid_pred(A[1], 0, C[1]);
916 if(s->mb_x + 1 == s->resync_mb_x){ //rare
917 C = s->motion_val[xy + off[block] - wrap];
918 *px = mid_pred(A[0], 0, C[0]);
919 *py = mid_pred(A[1], 0, C[1]);
925 B = s->motion_val[xy - wrap];
926 C = s->motion_val[xy + off[block] - wrap];
927 if(s->mb_x == s->resync_mb_x) //rare
930 *px = mid_pred(A[0], B[0], C[0]);
931 *py = mid_pred(A[1], B[1], C[1]);
934 B = s->motion_val[xy - wrap];
935 C = s->motion_val[xy + off[block] - wrap];
936 *px = mid_pred(A[0], B[0], C[0]);
937 *py = mid_pred(A[1], B[1], C[1]);
942 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
944 int range, l, m, bit_size, sign, code, bits;
949 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
951 bit_size = f_code - 1;
952 range = 1 << bit_size;
953 /* modulo encoding */
958 } else if (val >= l) {
969 code = (val >> bit_size) + 1;
970 bits = val & (range - 1);
972 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
974 put_bits(&s->pb, bit_size, bits);
979 /* Encode MV differences on H.263+ with Unrestricted MV mode */
980 static void h263p_encode_umotion(MpegEncContext * s, int val)
990 put_bits(&s->pb, 1, 1);
992 put_bits(&s->pb, 3, 0);
994 put_bits(&s->pb, 3, 2);
997 sval = ((val < 0) ? (short)(-val):(short)val);
1000 while (temp_val != 0) {
1001 temp_val = temp_val >> 1;
1007 tcode = (sval & (1 << (i-1))) >> (i-1);
1008 tcode = (tcode << 1) | 1;
1009 code = (code << 2) | tcode;
1012 code = ((code << 1) | (val < 0)) << 1;
1013 put_bits(&s->pb, (2*n_bits)+1, code);
1014 //printf("\nVal = %d\tCode = %d", sval, code);
1018 static void init_mv_penalty_and_fcode(MpegEncContext *s)
1022 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1023 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1026 if(mv==0) len= mvtab[0][1];
1028 int val, bit_size, range, code;
1030 bit_size = s->f_code - 1;
1031 range = 1 << bit_size;
1037 code = (val >> bit_size) + 1;
1039 len= mvtab[code][1] + 1 + bit_size;
1041 len= mvtab[32][1] + 2 + bit_size;
1045 mv_penalty[f_code][mv+MAX_MV]= len;
1049 for(f_code=MAX_FCODE; f_code>0; f_code--){
1050 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1051 fcode_tab[mv+MAX_MV]= f_code;
1055 for(mv=0; mv<MAX_MV*2+1; mv++){
1056 umv_fcode_tab[mv]= 1;
1060 static void init_uni_dc_tab(void)
1062 int level, uni_code, uni_len;
1064 for(level=-256; level<256; level++){
1066 /* find number of bits */
1075 l= (-level) ^ ((1 << size) - 1);
1080 uni_code= DCtab_lum[size][0];
1081 uni_len = DCtab_lum[size][1];
1084 uni_code<<=size; uni_code|=l;
1087 uni_code<<=1; uni_code|=1;
1091 uni_DCtab_lum[level+256][0]= uni_code;
1092 uni_DCtab_lum[level+256][1]= uni_len;
1095 uni_code= DCtab_chrom[size][0];
1096 uni_len = DCtab_chrom[size][1];
1099 uni_code<<=size; uni_code|=l;
1102 uni_code<<=1; uni_code|=1;
1106 uni_DCtab_chrom[level+256][0]= uni_code;
1107 uni_DCtab_chrom[level+256][1]= uni_len;
1112 static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1113 int slevel, run, last;
1115 assert(MAX_LEVEL >= 64);
1116 assert(MAX_RUN >= 63);
1118 for(slevel=-64; slevel<64; slevel++){
1119 if(slevel==0) continue;
1120 for(run=0; run<64; run++){
1121 for(last=0; last<=1; last++){
1122 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1123 int level= slevel < 0 ? -slevel : slevel;
1124 int sign= slevel < 0 ? 1 : 0;
1125 int bits, len, code;
1128 len_tab[index]= 100;
1131 code= get_rl_index(rl, last, run, level);
1132 bits= rl->table_vlc[code][0];
1133 len= rl->table_vlc[code][1];
1134 bits=bits*2+sign; len++;
1136 if(code!=rl->n && len < len_tab[index]){
1137 bits_tab[index]= bits;
1138 len_tab [index]= len;
1142 bits= rl->table_vlc[rl->n][0];
1143 len= rl->table_vlc[rl->n][1];
1144 bits=bits*2; len++; //esc1
1145 level1= level - rl->max_level[last][run];
1147 code= get_rl_index(rl, last, run, level1);
1148 bits<<= rl->table_vlc[code][1];
1149 len += rl->table_vlc[code][1];
1150 bits += rl->table_vlc[code][0];
1151 bits=bits*2+sign; len++;
1153 if(code!=rl->n && len < len_tab[index]){
1154 bits_tab[index]= bits;
1155 len_tab [index]= len;
1161 bits= rl->table_vlc[rl->n][0];
1162 len= rl->table_vlc[rl->n][1];
1163 bits=bits*4+2; len+=2; //esc2
1164 run1 = run - rl->max_run[last][level] - 1;
1166 code= get_rl_index(rl, last, run1, level);
1167 bits<<= rl->table_vlc[code][1];
1168 len += rl->table_vlc[code][1];
1169 bits += rl->table_vlc[code][0];
1170 bits=bits*2+sign; len++;
1172 if(code!=rl->n && len < len_tab[index]){
1173 bits_tab[index]= bits;
1174 len_tab [index]= len;
1179 bits= rl->table_vlc[rl->n][0];
1180 len = rl->table_vlc[rl->n][1];
1181 bits=bits*4+3; len+=2; //esc3
1182 bits=bits*2+last; len++;
1183 bits=bits*64+run; len+=6;
1184 bits=bits*2+1; len++; //marker
1185 bits=bits*4096+(slevel&0xfff); len+=12;
1186 bits=bits*2+1; len++; //marker
1188 if(len < len_tab[index]){
1189 bits_tab[index]= bits;
1190 len_tab [index]= len;
1197 void h263_encode_init(MpegEncContext *s)
1199 static int done = 0;
1208 init_rl(&rl_intra_aic);
1210 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1211 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1213 init_mv_penalty_and_fcode(s);
1215 s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1217 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1218 switch(s->codec_id){
1219 case CODEC_ID_MPEG4:
1220 s->fcode_tab= fcode_tab;
1221 s->min_qcoeff= -2048;
1222 s->max_qcoeff= 2047;
1224 case CODEC_ID_H263P:
1225 s->fcode_tab= umv_fcode_tab;
1226 s->min_qcoeff= -128;
1229 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1230 default: //nothing needed default table allready set in mpegvideo.c
1231 s->min_qcoeff= -128;
1233 s->y_dc_scale_table=
1234 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1238 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1239 s->inter_quant_bias= 0;
1241 s->intra_quant_bias=0;
1242 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1246 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1248 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1252 if (s->mb_intra && !s->h263_aic) {
1255 /* 255 cannot be represented, so we clamp */
1260 /* 0 cannot be represented also */
1266 put_bits(&s->pb, 8, 0xff);
1268 put_bits(&s->pb, 8, level & 0xff);
1272 if (s->h263_aic && s->mb_intra)
1277 last_index = s->block_last_index[n];
1278 last_non_zero = i - 1;
1279 for (; i <= last_index; i++) {
1280 j = zigzag_direct[i];
1283 run = i - last_non_zero - 1;
1284 last = (i == last_index);
1291 code = get_rl_index(rl, last, run, level);
1292 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1293 if (code == rl->n) {
1294 put_bits(&s->pb, 1, last);
1295 put_bits(&s->pb, 6, run);
1296 put_bits(&s->pb, 8, slevel & 0xff);
1298 put_bits(&s->pb, 1, sign);
1305 /***************************************************/
1307 void ff_mpeg4_stuffing(PutBitContext * pbc)
1310 put_bits(pbc, 1, 0);
1311 length= (-get_bit_count(pbc))&7;
1312 if(length) put_bits(pbc, length, (1<<length)-1);
1315 /* must be called before writing the header */
1316 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1317 int time_div, time_mod;
1319 if(s->pict_type==I_TYPE){ //we will encode a vol header
1320 s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1321 if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1323 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1327 s->time= (s->avctx->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1329 s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1330 time_div= s->time/s->time_increment_resolution;
1331 time_mod= s->time%s->time_increment_resolution;
1333 if(s->pict_type==B_TYPE){
1334 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1336 s->last_time_base= s->time_base;
1337 s->time_base= time_div;
1338 s->pp_time= s->time - s->last_non_b_time;
1339 s->last_non_b_time= s->time;
1343 static void mpeg4_encode_vol_header(MpegEncContext * s)
1345 int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1348 s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1350 put_bits(&s->pb, 16, 0);
1351 put_bits(&s->pb, 16, 0x100); /* video obj */
1352 put_bits(&s->pb, 16, 0);
1353 put_bits(&s->pb, 16, 0x120); /* video obj layer */
1355 put_bits(&s->pb, 1, 0); /* random access vol */
1356 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
1357 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1358 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1359 put_bits(&s->pb, 3, 1); /* is obj layer priority */
1360 if(s->aspect_ratio_info)
1361 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1363 put_bits(&s->pb, 4, 1); /* aspect ratio info= sqare pixel */
1366 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1367 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1368 put_bits(&s->pb, 1, s->low_delay);
1369 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1371 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
1374 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1375 put_bits(&s->pb, 1, 1); /* marker bit */
1377 put_bits(&s->pb, 16, s->time_increment_resolution);
1378 if (s->time_increment_bits < 1)
1379 s->time_increment_bits = 1;
1380 put_bits(&s->pb, 1, 1); /* marker bit */
1381 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1382 put_bits(&s->pb, 1, 1); /* marker bit */
1383 put_bits(&s->pb, 13, s->width); /* vol width */
1384 put_bits(&s->pb, 1, 1); /* marker bit */
1385 put_bits(&s->pb, 13, s->height); /* vol height */
1386 put_bits(&s->pb, 1, 1); /* marker bit */
1387 put_bits(&s->pb, 1, 0); /* interlace */
1388 put_bits(&s->pb, 1, 1); /* obmc disable */
1389 if (vo_ver_id == 1) {
1390 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
1391 }else{ /* vo_ver_id == 2 */
1392 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
1394 put_bits(&s->pb, 1, 0); /* not 8 bit */
1395 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1396 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1399 put_bits(&s->pb, 1, s->quarter_sample=0);
1400 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1401 s->resync_marker= s->rtp_mode;
1402 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1403 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1404 if(s->data_partitioning){
1405 put_bits(&s->pb, 1, 0); /* no rvlc */
1408 if (vo_ver_id != 1){
1409 put_bits(&s->pb, 1, 0); /* newpred */
1410 put_bits(&s->pb, 1, 0); /* reduced res vop */
1412 put_bits(&s->pb, 1, 0); /* scalability */
1414 ff_mpeg4_stuffing(&s->pb);
1415 put_bits(&s->pb, 16, 0);
1416 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1417 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1418 put_string(&s->pb, buf);
1420 ff_mpeg4_stuffing(&s->pb);
1423 /* write mpeg4 VOP header */
1424 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1427 int time_div, time_mod;
1429 if(s->pict_type==I_TYPE){
1431 if(picture_number==0 || !s->strict_std_compliance)
1432 mpeg4_encode_vol_header(s);
1435 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1437 put_bits(&s->pb, 16, 0); /* vop header */
1438 put_bits(&s->pb, 16, 0x1B6); /* vop header */
1439 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1441 time_div= s->time/s->time_increment_resolution;
1442 time_mod= s->time%s->time_increment_resolution;
1443 time_incr= time_div - s->last_time_base;
1445 put_bits(&s->pb, 1, 1);
1447 put_bits(&s->pb, 1, 0);
1449 put_bits(&s->pb, 1, 1); /* marker */
1450 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1451 put_bits(&s->pb, 1, 1); /* marker */
1452 put_bits(&s->pb, 1, 1); /* vop coded */
1453 if ( s->pict_type == P_TYPE
1454 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1455 s->no_rounding ^= 1;
1456 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1458 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1459 //FIXME sprite stuff
1461 put_bits(&s->pb, 5, s->qscale);
1463 if (s->pict_type != I_TYPE)
1464 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1465 if (s->pict_type == B_TYPE)
1466 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1467 // printf("****frame %d\n", picture_number);
1469 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1470 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1471 s->h_edge_pos= s->width;
1472 s->v_edge_pos= s->height;
1475 static void h263_dc_scale(MpegEncContext * s)
1477 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1478 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1481 inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1483 int a, b, c, wrap, pred, scale;
1487 /* find prediction */
1489 scale = s->y_dc_scale;
1491 scale = s->c_dc_scale;
1493 wrap= s->block_wrap[n];
1494 dc_val = s->dc_val[0] + s->block_index[n];
1500 b = dc_val[ - 1 - wrap];
1501 c = dc_val[ - wrap];
1503 if (abs(a - b) < abs(b - c)) {
1505 *dir_ptr = 1; /* top */
1508 *dir_ptr = 0; /* left */
1510 /* we assume pred is positive */
1513 "xorl %%edx, %%edx \n\t"
1515 : "=d" (pred), "=a"(dummy)
1516 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1519 pred = (pred + (scale >> 1)) / scale;
1522 /* prepare address for prediction update */
1523 *dc_val_ptr = &dc_val[0];
1528 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1532 INT16 *ac_val, *ac_val1;
1534 /* find prediction */
1535 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1539 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
1540 /* left prediction */
1543 if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
1546 block[block_permute_op(i*8)] += ac_val[i];
1549 /* different qscale, we must rescale */
1551 block[block_permute_op(i*8)] += ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
1555 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
1556 /* top prediction */
1557 ac_val -= 16 * s->block_wrap[n];
1559 if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
1562 block[block_permute_op(i)] += ac_val[i + 8];
1565 /* different qscale, we must rescale */
1567 block[block_permute_op(i)] += ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
1574 ac_val1[i] = block[block_permute_op(i * 8)];
1578 ac_val1[8 + i] = block[block_permute_op(i)];
1582 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1588 /* find prediction */
1589 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1592 /* left prediction */
1595 block[block_permute_op(i*8)] -= ac_val[i];
1598 /* top prediction */
1599 ac_val -= 16 * s->block_wrap[n];
1601 block[block_permute_op(i)] -= ac_val[i + 8];
1606 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1609 // if(level<-255 || level>255) printf("dc overflow\n");
1613 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1616 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1620 /* find number of bits */
1630 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1633 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1636 /* encode remaining bits */
1639 level = (-level) ^ ((1 << size) - 1);
1640 put_bits(&s->pb, size, level);
1642 put_bits(&s->pb, 1, 1);
1647 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1648 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1650 int last, i, last_non_zero, sign;
1655 const int last_index = s->block_last_index[n];
1657 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
1658 /* mpeg4 based DC predictor */
1659 mpeg4_encode_dc(dc_pb, intra_dc, n);
1660 if(last_index<1) return;
1663 bits_tab= uni_mpeg4_intra_rl_bits;
1664 len_tab = uni_mpeg4_intra_rl_len;
1666 if(last_index<0) return;
1669 bits_tab= uni_mpeg4_inter_rl_bits;
1670 len_tab = uni_mpeg4_inter_rl_len;
1674 last_non_zero = i - 1;
1676 for (; i < last_index; i++) {
1677 int level = block[ scan_table[i] ];
1679 int run = i - last_non_zero - 1;
1681 if((level&(~127)) == 0){
1682 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
1683 put_bits(ac_pb, len_tab[index], bits_tab[index]);
1685 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);
1690 /*if(i<=last_index)*/{
1691 int level = block[ scan_table[i] ];
1692 int run = i - last_non_zero - 1;
1694 if((level&(~127)) == 0){
1695 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
1696 put_bits(ac_pb, len_tab[index], bits_tab[index]);
1698 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);
1702 for (; i <= last_index; i++) {
1703 const int slevel = block[ scan_table[i] ];
1706 int run = i - last_non_zero - 1;
1707 last = (i == last_index);
1714 code = get_rl_index(rl, last, run, level);
1715 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1716 if (code == rl->n) {
1718 level1 = level - rl->max_level[last][run];
1721 code = get_rl_index(rl, last, run, level1);
1722 if (code == rl->n) {
1724 put_bits(ac_pb, 1, 1);
1725 if (level > MAX_LEVEL)
1727 run1 = run - rl->max_run[last][level] - 1;
1730 code = get_rl_index(rl, last, run1, level);
1731 if (code == rl->n) {
1734 put_bits(ac_pb, 1, 1);
1735 put_bits(ac_pb, 1, last);
1736 put_bits(ac_pb, 6, run);
1737 put_bits(ac_pb, 1, 1);
1738 put_bits(ac_pb, 12, slevel & 0xfff);
1739 put_bits(ac_pb, 1, 1);
1742 put_bits(ac_pb, 1, 0);
1743 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1744 put_bits(ac_pb, 1, sign);
1748 put_bits(ac_pb, 1, 0);
1749 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1750 put_bits(ac_pb, 1, sign);
1753 put_bits(ac_pb, 1, sign);
1763 /***********************************************/
1766 static VLC intra_MCBPC_vlc;
1767 static VLC inter_MCBPC_vlc;
1768 static VLC cbpy_vlc;
1770 static VLC dc_lum, dc_chrom;
1771 static VLC sprite_trajectory;
1772 static VLC mb_type_b_vlc;
1774 void init_rl(RLTable *rl)
1776 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1777 UINT8 index_run[MAX_RUN+1];
1778 int last, run, level, start, end, i;
1780 /* compute max_level[], max_run[] and index_run[] */
1781 for(last=0;last<2;last++) {
1790 memset(max_level, 0, MAX_RUN + 1);
1791 memset(max_run, 0, MAX_LEVEL + 1);
1792 memset(index_run, rl->n, MAX_RUN + 1);
1793 for(i=start;i<end;i++) {
1794 run = rl->table_run[i];
1795 level = rl->table_level[i];
1796 if (index_run[run] == rl->n)
1798 if (level > max_level[run])
1799 max_level[run] = level;
1800 if (run > max_run[level])
1801 max_run[level] = run;
1803 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1804 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1805 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1806 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1807 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1808 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1812 void init_vlc_rl(RLTable *rl)
1816 init_vlc(&rl->vlc, 9, rl->n + 1,
1817 &rl->table_vlc[0][1], 4, 2,
1818 &rl->table_vlc[0][0], 4, 2);
1821 for(q=0; q<32; q++){
1830 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
1831 for(i=0; i<rl->vlc.table_size; i++){
1832 int code= rl->vlc.table[i][0];
1833 int len = rl->vlc.table[i][1];
1836 if(len==0){ // illegal code
1839 }else if(len<0){ //more bits needed
1843 if(code==rl->n){ //esc
1847 run= rl->table_run [code] + 1;
1848 level= rl->table_level[code] * qmul + qadd;
1849 if(code >= rl->last) run+=192;
1852 rl->rl_vlc[q][i].len= len;
1853 rl->rl_vlc[q][i].level= level;
1854 rl->rl_vlc[q][i].run= run;
1861 /* XXX: find a better solution to handle static init */
1862 void h263_decode_init_vlc(MpegEncContext *s)
1864 static int done = 0;
1869 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
1870 intra_MCBPC_bits, 1, 1,
1871 intra_MCBPC_code, 1, 1);
1872 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
1873 inter_MCBPC_bits, 1, 1,
1874 inter_MCBPC_code, 1, 1);
1875 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1876 &cbpy_tab[0][1], 2, 1,
1877 &cbpy_tab[0][0], 2, 1);
1878 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
1880 &mvtab[0][0], 2, 1);
1883 init_rl(&rl_intra_aic);
1884 init_vlc_rl(&rl_inter);
1885 init_vlc_rl(&rl_intra);
1886 init_vlc_rl(&rl_intra_aic);
1887 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
1888 &DCtab_lum[0][1], 2, 1,
1889 &DCtab_lum[0][0], 2, 1);
1890 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
1891 &DCtab_chrom[0][1], 2, 1,
1892 &DCtab_chrom[0][0], 2, 1);
1893 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
1894 &sprite_trajectory_tab[0][1], 4, 2,
1895 &sprite_trajectory_tab[0][0], 4, 2);
1896 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
1897 &mb_type_b_tab[0][1], 2, 1,
1898 &mb_type_b_tab[0][0], 2, 1);
1901 s->progressive_sequence=1; // set to most likely for the case of incomplete headers
1904 int h263_decode_gob_header(MpegEncContext *s)
1906 unsigned int val, gfid;
1908 /* Check for GOB Start Code */
1909 val = show_bits(&s->gb, 16);
1911 /* We have a GBSC probably with GSTUFF */
1912 skip_bits(&s->gb, 16); /* Drop the zeros */
1913 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1915 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1917 s->gob_number = get_bits(&s->gb, 5); /* GN */
1918 gfid = get_bits(&s->gb, 2); /* GFID */
1919 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1921 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1929 static inline void memsetw(short *tab, int val, int n)
1936 void ff_mpeg4_init_partitions(MpegEncContext *s)
1938 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
1939 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
1942 void ff_mpeg4_merge_partitions(MpegEncContext *s)
1944 const int pb2_len = get_bit_count(&s->pb2 );
1945 const int tex_pb_len= get_bit_count(&s->tex_pb);
1946 const int bits= get_bit_count(&s->pb);
1948 if(s->pict_type==I_TYPE){
1949 put_bits(&s->pb, 19, DC_MARKER);
1950 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
1951 s->i_tex_bits+= tex_pb_len;
1953 put_bits(&s->pb, 17, MOTION_MARKER);
1954 s->misc_bits+=17 + pb2_len;;
1955 s->mv_bits+= bits - s->last_bits;
1956 s->p_tex_bits+= tex_pb_len;
1959 flush_put_bits(&s->pb2);
1960 flush_put_bits(&s->tex_pb);
1962 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
1963 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
1964 s->last_bits= get_bit_count(&s->pb);
1967 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
1969 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1971 ff_mpeg4_stuffing(&s->pb);
1972 if(s->pict_type==I_TYPE)
1973 put_bits(&s->pb, 16, 0);
1974 else if(s->pict_type==B_TYPE)
1975 put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0);
1977 put_bits(&s->pb, s->f_code+15, 0);
1978 put_bits(&s->pb, 1, 1);
1980 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
1981 put_bits(&s->pb, 5, s->qscale);
1982 put_bits(&s->pb, 1, 0); /* no HEC */
1986 * decodes the next video packet and sets s->next_qscale
1987 * returns mb_num of the next packet or <0 if something went wrong
1989 static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb)
1992 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1993 int header_extension=0, mb_num;
1994 //printf("%X\n", show_bits(&gb, 24));
1995 //printf("parse_video_packet_header\n");
1996 // if(show_aligned_bits(gb, 1, 16) != 0) return -1;
1998 /* is there enough space left for a video packet + header */
1999 if( get_bits_count(gb) > gb->size*8-20) return -1;
2001 //printf("resync at %d %d\n", s->mb_x, s->mb_y);
2002 // skip_bits(gb, 1);
2003 // align_get_bits(gb);
2004 if(get_bits(gb, 16)!=0){
2005 printf("internal error while decoding video packet header\n");
2008 //printf("%X\n", show_bits(gb, 24));
2010 while(!get_bits1(gb) && bits<30) bits++;
2011 if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){
2012 printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n",
2013 bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y);
2015 }else if(s->pict_type == I_TYPE && bits != 0){
2016 printf("marker too long\n");
2018 }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){
2019 printf("marker does not match f/b_code\n");
2022 //printf("%X\n", show_bits(gb, 24));
2024 if(s->shape != RECT_SHAPE){
2025 header_extension= get_bits1(gb);
2026 //FIXME more stuff here
2029 mb_num= get_bits(gb, mb_num_bits);
2030 if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){
2031 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width);
2035 if(s->shape != BIN_ONLY_SHAPE){
2036 s->next_resync_qscale= get_bits(gb, 5);
2037 if(s->next_resync_qscale==0)
2038 s->next_resync_qscale= s->qscale;
2039 if(s->next_resync_qscale==0){
2040 fprintf(stderr, "qscale==0\n");
2045 if(s->shape == RECT_SHAPE){
2046 header_extension= get_bits1(gb);
2048 if(header_extension){
2052 while (get_bits1(gb) != 0)
2055 check_marker(gb, "before time_increment in video packed header");
2056 time_increment= get_bits(gb, s->time_increment_bits);
2057 check_marker(gb, "before vop_coding_type in video packed header");
2059 skip_bits(gb, 2); /* vop coding type */
2060 //FIXME not rect stuff here
2062 if(s->shape != BIN_ONLY_SHAPE){
2063 skip_bits(gb, 3); /* intra dc vlc threshold */
2065 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
2066 mpeg4_decode_sprite_trajectory(s);
2067 fprintf(stderr, "untested\n");
2070 //FIXME reduced res stuff here
2072 if (s->pict_type != I_TYPE) {
2073 int f_code = get_bits(gb, 3); /* fcode_for */
2075 printf("Error, video packet header damaged (f_code=0)\n");
2078 if (s->pict_type == B_TYPE) {
2079 int b_code = get_bits(gb, 3);
2081 printf("Error, video packet header damaged (b_code=0)\n");
2086 //FIXME new-pred stuff
2088 //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));
2093 void ff_mpeg4_clean_buffers(MpegEncContext *s)
2095 int c_wrap, c_xy, l_wrap, l_xy;
2097 l_wrap= s->block_wrap[0];
2098 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2099 c_wrap= s->block_wrap[4];
2100 c_xy= s->mb_y*c_wrap + s->mb_x;
2103 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2104 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2105 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
2108 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2109 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
2110 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
2113 // we cant clear the MVs as they might be needed by a b frame
2114 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
2115 // memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2116 s->last_mv[0][0][0]=
2117 s->last_mv[0][0][1]=
2118 s->last_mv[1][0][0]=
2119 s->last_mv[1][0][1]= 0;
2122 /* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */
2123 int ff_mpeg4_resync(MpegEncContext *s)
2127 /* search & parse next resync marker */
2129 gb= s->next_resync_gb;
2130 align_get_bits(&gb);
2131 //printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb));
2133 int v= show_bits(&gb, 24);
2134 if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){
2135 s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width;
2136 //printf("mpeg4_resync end\n");
2137 s->gb= s->next_resync_gb; //continue at the next resync marker
2139 }else if(v>>8 == 0){
2141 s->next_resync_pos= get_bits_count(&gb);
2143 next= decode_video_packet_header(s, &gb);
2145 s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width;
2149 align_get_bits(&gb);
2153 s->next_resync_gb=gb;
2158 static inline void init_block_index(MpegEncContext *s)
2160 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2161 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
2162 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
2163 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
2164 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2165 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2168 static inline void update_block_index(MpegEncContext *s)
2170 s->block_index[0]+=2;
2171 s->block_index[1]+=2;
2172 s->block_index[2]+=2;
2173 s->block_index[3]+=2;
2174 s->block_index[4]++;
2175 s->block_index[5]++;
2179 * decodes the first & second partition
2180 * returns error type or 0 if no error
2182 int ff_mpeg4_decode_partitions(MpegEncContext *s)
2184 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2187 /* decode first partition */
2189 s->first_slice_line=1;
2190 s->mb_x= s->resync_mb_x;
2191 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2192 init_block_index(s);
2193 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2194 const int xy= s->mb_x + s->mb_y*s->mb_width;
2199 update_block_index(s);
2200 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2201 s->first_slice_line=0;
2203 if(s->mb_x==0) PRINT_MB_TYPE("\n");
2205 if(s->pict_type==I_TYPE){
2209 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2211 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2212 return DECODING_DESYNC;
2214 s->cbp_table[xy]= cbpc & 3;
2215 s->mb_type[xy]= MB_TYPE_INTRA;
2219 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2222 else if (s->qscale > 31)
2226 s->qscale_table[xy]= s->qscale;
2228 s->mbintra_table[xy]= 1;
2231 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2233 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2234 return DECODING_DESYNC;
2237 if(dc_pred_dir) dir|=1;
2239 s->pred_dir_table[xy]= dir;
2240 }else{ /* P/S_TYPE */
2241 int mx, my, pred_x, pred_y;
2242 INT16 * const mot_val= s->motion_val[s->block_index[0]];
2243 const int stride= s->block_wrap[0]*2;
2245 if(get_bits1(&s->gb)){
2247 s->mb_type[xy]= MB_TYPE_SKIPED;
2248 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2249 const int a= s->sprite_warping_accuracy;
2251 if(s->divx_version==500 && s->divx_build==413){
2252 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2253 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2255 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2256 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2257 s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED;
2264 mot_val[0 ]= mot_val[2 ]=
2265 mot_val[0+stride]= mot_val[2+stride]= mx;
2266 mot_val[1 ]= mot_val[3 ]=
2267 mot_val[1+stride]= mot_val[3+stride]= my;
2269 if(s->mbintra_table[xy])
2270 ff_clean_intra_table_entries(s);
2274 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2276 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2277 return DECODING_DESYNC;
2281 else if (cbpc == 20)
2282 fprintf(stderr, "Stuffing !");
2283 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2285 s->mb_intra = ((cbpc & 4) != 0);
2289 s->mbintra_table[xy]= 1;
2290 s->mb_type[xy]= MB_TYPE_INTRA;
2291 mot_val[0 ]= mot_val[2 ]=
2292 mot_val[0+stride]= mot_val[2+stride]= 0;
2293 mot_val[1 ]= mot_val[3 ]=
2294 mot_val[1+stride]= mot_val[3+stride]= 0;
2296 if(s->mbintra_table[xy])
2297 ff_clean_intra_table_entries(s);
2299 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2300 s->mcsel= get_bits1(&s->gb);
2303 if ((cbpc & 16) == 0) {
2305 /* 16x16 motion prediction */
2306 s->mb_type[xy]= MB_TYPE_INTER;
2308 h263_pred_motion(s, 0, &pred_x, &pred_y);
2310 mx = h263_decode_motion(s, pred_x, s->f_code);
2312 const int a= s->sprite_warping_accuracy;
2313 if(s->divx_version==500 && s->divx_build==413){
2314 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2316 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2320 return DECODING_DESYNC;
2323 my = h263_decode_motion(s, pred_y, s->f_code);
2325 const int a= s->sprite_warping_accuracy;
2326 if(s->divx_version==500 && s->divx_build==413){
2327 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2329 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2333 return DECODING_DESYNC;
2334 mot_val[0 ]= mot_val[2 ] =
2335 mot_val[0+stride]= mot_val[2+stride]= mx;
2336 mot_val[1 ]= mot_val[3 ]=
2337 mot_val[1+stride]= mot_val[3+stride]= my;
2341 s->mb_type[xy]= MB_TYPE_INTER4V;
2343 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2344 mx = h263_decode_motion(s, pred_x, s->f_code);
2346 return DECODING_DESYNC;
2348 my = h263_decode_motion(s, pred_y, s->f_code);
2350 return DECODING_DESYNC;
2361 if (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER ) s->decoding_error= DECODING_DESYNC;
2362 else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC;
2363 if(s->decoding_error== DECODING_DESYNC){
2364 fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y);
2365 return DECODING_DESYNC;
2368 /* decode second partition */
2370 s->mb_x= s->resync_mb_x;
2371 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2372 init_block_index(s);
2373 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2374 const int xy= s->mb_x + s->mb_y*s->mb_width;
2377 update_block_index(s);
2379 if(s->pict_type==I_TYPE){
2380 int ac_pred= get_bits1(&s->gb);
2381 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2383 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2384 return DECODING_AC_LOST;
2387 s->cbp_table[xy]|= cbpy<<2;
2388 s->pred_dir_table[xy]|= ac_pred<<7;
2389 }else{ /* P || S_TYPE */
2390 if(s->mb_type[xy]&MB_TYPE_INTRA){
2392 int ac_pred = get_bits1(&s->gb);
2393 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2396 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2397 return DECODING_ACDC_LOST;
2400 if(s->cbp_table[xy] & 8) {
2401 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2404 else if (s->qscale > 31)
2408 s->qscale_table[xy]= s->qscale;
2412 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2414 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2415 return DECODING_ACDC_LOST;
2418 if(dc_pred_dir) dir|=1;
2420 s->cbp_table[xy]&= 3; //remove dquant
2421 s->cbp_table[xy]|= cbpy<<2;
2422 s->pred_dir_table[xy]= dir | (ac_pred<<7);
2423 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2424 s->qscale_table[xy]= s->qscale;
2425 s->cbp_table[xy]= 0;
2427 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2430 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2431 return DECODING_ACDC_LOST;
2434 if(s->cbp_table[xy] & 8) {
2435 //fprintf(stderr, "dquant\n");
2436 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2439 else if (s->qscale > 31)
2443 s->qscale_table[xy]= s->qscale;
2445 s->cbp_table[xy]&= 3; //remove dquant
2446 s->cbp_table[xy]|= (cbpy^0xf)<<2;
2457 static int mpeg4_decode_partitioned_mb(MpegEncContext *s,
2458 DCTELEM block[6][64])
2461 const int xy= s->mb_x + s->mb_y*s->mb_width;
2463 if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start
2465 int block_index_backup[6];
2466 int qscale= s->qscale;
2468 for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i];
2470 s->decoding_error= ff_mpeg4_decode_partitions(s);
2472 for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i];
2473 s->first_slice_line=1;
2474 s->mb_x= s->resync_mb_x;
2475 s->mb_y= s->resync_mb_y;
2479 if(s->decoding_error==DECODING_DESYNC) return -1;
2482 mb_type= s->mb_type[xy];
2483 if(s->decoding_error)
2486 cbp = s->cbp_table[xy];
2488 if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
2489 s->qscale= s->qscale_table[xy];
2493 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2496 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2497 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2499 s->mb_intra = mb_type&MB_TYPE_INTRA;
2501 if (mb_type&MB_TYPE_SKIPED) {
2504 s->block_last_index[i] = -1;
2505 s->mv_dir = MV_DIR_FORWARD;
2506 s->mv_type = MV_TYPE_16X16;
2507 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2515 }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){
2516 s->ac_pred = s->pred_dir_table[xy]>>7;
2518 /* decode each block */
2519 for (i = 0; i < 6; i++) {
2520 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
2521 if(ret==DECODING_AC_LOST){
2522 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2523 s->decoding_error=DECODING_AC_LOST;
2525 }else if(ret==DECODING_ACDC_LOST){
2526 fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y);
2527 s->decoding_error=DECODING_ACDC_LOST;
2531 }else if(!s->mb_intra){
2532 // s->mcsel= 0; //FIXME do we need to init that
2534 s->mv_dir = MV_DIR_FORWARD;
2535 if (mb_type&MB_TYPE_INTER4V) {
2536 s->mv_type = MV_TYPE_8X8;
2538 s->mv_type = MV_TYPE_16X16;
2540 if(s->decoding_error==0 && cbp){
2541 /* decode each block */
2542 for (i = 0; i < 6; i++) {
2543 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0);
2544 if(ret==DECODING_AC_LOST){
2545 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2546 s->decoding_error=DECODING_AC_LOST;
2552 } else { /* I-Frame */
2555 s->ac_pred = s->pred_dir_table[xy]>>7;
2557 /* decode each block */
2558 for (i = 0; i < 6; i++) {
2559 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
2560 if(ret==DECODING_AC_LOST){
2561 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2562 s->decoding_error=DECODING_AC_LOST;
2564 }else if(ret==DECODING_ACDC_LOST){
2565 fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y);
2574 static inline void decode_interlaced_info(MpegEncContext *s, int cbp, int mb_type){
2576 if(!s->progressive_sequence){
2577 if(cbp || s->mb_intra)
2578 s->interlaced_dct= get_bits1(&s->gb);
2581 if( s->pict_type==P_TYPE //FIXME check that 4MV is forbidden
2582 || (s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && !s->mcsel)
2583 || (s->pict_type==B_TYPE && mb_type!=0) ){
2585 if(get_bits1(&s->gb)){
2586 s->mv_type= MV_TYPE_FIELD;
2588 if( s->pict_type==P_TYPE
2589 || (s->pict_type==B_TYPE && mb_type!=2)){
2590 s->field_select[0][0]= get_bits1(&s->gb);
2591 s->field_select[0][1]= get_bits1(&s->gb);
2593 if(s->pict_type==B_TYPE && mb_type!=3){
2594 s->field_select[1][0]= get_bits1(&s->gb);
2595 s->field_select[1][1]= get_bits1(&s->gb);
2605 int h263_decode_mb(MpegEncContext *s,
2606 DCTELEM block[6][64])
2608 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2610 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2612 if(s->mb_x==0) PRINT_MB_TYPE("\n");
2614 if(s->resync_marker){
2615 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
2616 s->first_slice_line=0;
2620 if(s->data_partitioning && s->pict_type!=B_TYPE)
2621 return mpeg4_decode_partitioned_mb(s, block);
2623 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2624 if (get_bits1(&s->gb)) {
2628 s->block_last_index[i] = -1;
2629 s->mv_dir = MV_DIR_FORWARD;
2630 s->mv_type = MV_TYPE_16X16;
2631 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2632 const int a= s->sprite_warping_accuracy;
2633 // int l = (1 << (s->f_code - 1)) * 32;
2636 if(s->divx_version==500 && s->divx_build==413){
2637 s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2638 s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2640 s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2641 s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2643 /* if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
2644 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
2645 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
2646 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
2658 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2659 //fprintf(stderr, "\tCBPC: %d", cbpc);
2664 else if (cbpc == 20)
2665 fprintf(stderr, "Stuffing !");
2668 s->mb_intra = ((cbpc & 4) != 0);
2669 if (s->mb_intra) goto intra;
2671 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2672 s->mcsel= get_bits1(&s->gb);
2674 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2675 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2677 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2680 else if (s->qscale > 31)
2684 if((!s->progressive_sequence) && (cbp || s->workaround_bugs==2))
2685 s->interlaced_dct= get_bits1(&s->gb);
2687 s->mv_dir = MV_DIR_FORWARD;
2688 if ((cbpc & 16) == 0) {
2690 const int a= s->sprite_warping_accuracy;
2692 /* 16x16 global motion prediction */
2693 s->mv_type = MV_TYPE_16X16;
2694 // int l = (1 << (s->f_code - 1)) * 32;
2695 if(s->divx_version==500 && s->divx_build==413){
2696 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2697 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2699 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2700 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2702 // int l = (1 << (s->f_code - 1)) * 32;
2703 s->mv[0][0][0] = mx;
2704 s->mv[0][0][1] = my;
2705 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
2707 /* 16x8 field motion prediction */
2708 s->mv_type= MV_TYPE_FIELD;
2710 s->field_select[0][0]= get_bits1(&s->gb);
2711 s->field_select[0][1]= get_bits1(&s->gb);
2713 h263_pred_motion(s, 0, &pred_x, &pred_y);
2716 mx = h263_decode_motion(s, pred_x, s->f_code);
2720 my = h263_decode_motion(s, pred_y/2, s->f_code);
2724 s->mv[0][i][0] = mx;
2725 s->mv[0][i][1] = my;
2729 /* 16x16 motion prediction */
2730 s->mv_type = MV_TYPE_16X16;
2731 h263_pred_motion(s, 0, &pred_x, &pred_y);
2733 mx = h263p_decode_umotion(s, pred_x);
2735 mx = h263_decode_motion(s, pred_x, s->f_code);
2741 my = h263p_decode_umotion(s, pred_y);
2743 my = h263_decode_motion(s, pred_y, s->f_code);
2747 s->mv[0][0][0] = mx;
2748 s->mv[0][0][1] = my;
2750 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2751 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2755 s->mv_type = MV_TYPE_8X8;
2757 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
2759 mx = h263p_decode_umotion(s, pred_x);
2761 mx = h263_decode_motion(s, pred_x, s->f_code);
2766 my = h263p_decode_umotion(s, pred_y);
2768 my = h263_decode_motion(s, pred_y, s->f_code);
2771 s->mv[0][i][0] = mx;
2772 s->mv[0][i][1] = my;
2773 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2774 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2779 } else if(s->pict_type==B_TYPE) {
2780 int modb1; // first bit of modb
2781 int modb2; // second bit of modb
2787 s->mb_intra = 0; //B-frames never contain intra blocks
2788 s->mcsel=0; // ... true gmc blocks
2791 s->last_mv[0][0][0]=
2792 s->last_mv[0][0][1]=
2793 s->last_mv[1][0][0]=
2794 s->last_mv[1][0][1]= 0;
2797 /* if we skipped it in the future P Frame than skip it now too */
2798 s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
2803 s->block_last_index[i] = -1;
2805 s->mv_dir = MV_DIR_FORWARD;
2806 s->mv_type = MV_TYPE_16X16;
2815 modb1= get_bits1(&s->gb);
2817 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
2822 modb2= get_bits1(&s->gb);
2823 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
2825 else cbp= get_bits(&s->gb, 6);
2827 if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
2828 if(get_bits1(&s->gb)){
2829 s->qscale +=get_bits1(&s->gb)*4 - 2;
2832 else if (s->qscale > 31)
2839 if(!s->progressive_sequence){
2841 s->interlaced_dct= get_bits1(&s->gb);
2843 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
2846 if(mb_type!=MB_TYPE_B_BACKW){
2847 s->field_select[0][0]= get_bits1(&s->gb);
2848 s->field_select[0][1]= get_bits1(&s->gb);
2850 if(mb_type!=MB_TYPE_B_FORW){
2851 s->field_select[1][0]= get_bits1(&s->gb);
2852 s->field_select[1][1]= get_bits1(&s->gb);
2858 if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
2859 s->mv_type= MV_TYPE_16X16;
2860 if(mb_type!=MB_TYPE_B_BACKW){
2861 s->mv_dir = MV_DIR_FORWARD;
2863 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2864 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2865 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2866 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2869 if(mb_type!=MB_TYPE_B_FORW){
2870 s->mv_dir |= MV_DIR_BACKWARD;
2872 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2873 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2874 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2875 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2877 if(mb_type!=MB_TYPE_B_DIRECT)
2878 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
2879 }else if(mb_type!=MB_TYPE_B_DIRECT){
2880 s->mv_type= MV_TYPE_FIELD;
2882 if(mb_type!=MB_TYPE_B_BACKW){
2883 s->mv_dir = MV_DIR_FORWARD;
2886 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
2887 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
2888 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
2889 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
2893 if(mb_type!=MB_TYPE_B_FORW){
2894 s->mv_dir |= MV_DIR_BACKWARD;
2897 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
2898 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
2899 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
2900 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
2903 if(mb_type!=MB_TYPE_B_DIRECT)
2904 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
2908 if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
2909 int mb_index= s->mb_x + s->mb_y*s->mb_width;
2915 mx = h263_decode_motion(s, 0, 1);
2916 my = h263_decode_motion(s, 0, 1);
2919 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2920 xy= s->block_index[0];
2921 time_pp= s->pp_time;
2922 time_pb= s->pb_time;
2924 //FIXME avoid divides
2925 switch(s->co_located_type_table[mb_index]){
2927 s->mv_type= MV_TYPE_16X16;
2928 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
2929 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
2930 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
2931 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
2932 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
2933 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
2934 PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
2936 case CO_LOCATED_TYPE_4MV:
2937 s->mv_type = MV_TYPE_8X8;
2939 xy= s->block_index[i];
2940 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
2941 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
2942 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
2943 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
2944 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
2945 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
2949 case CO_LOCATED_TYPE_FIELDMV:
2950 s->mv_type = MV_TYPE_FIELD;
2952 if(s->top_field_first){
2953 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
2954 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
2956 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
2957 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
2959 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
2960 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
2961 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
2962 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
2963 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
2964 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
2971 if(mb_type<0 || mb_type>4){
2972 printf("illegal MB_type\n");
2975 } else { /* I-Frame */
2976 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
2983 if (s->h263_pred || s->h263_aic) {
2984 s->ac_pred = get_bits1(&s->gb);
2985 if (s->ac_pred && s->h263_aic)
2986 s->h263_aic_dir = get_bits1(&s->gb);
2988 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
2990 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
2991 if(cbpy<0) return -1;
2992 cbp = (cbpc & 3) | (cbpy << 2);
2994 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2997 else if (s->qscale > 31)
3001 if(!s->progressive_sequence)
3002 s->interlaced_dct= get_bits1(&s->gb);
3004 /* decode each block */
3006 for (i = 0; i < 6; i++) {
3007 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1) < 0)
3011 for (i = 0; i < 6; i++) {
3012 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
3019 /* decode each block */
3021 for (i = 0; i < 6; i++) {
3022 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0) < 0)
3026 for (i = 0; i < 6; i++) {
3027 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
3034 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3036 int code, val, sign, shift, l;
3038 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
3044 sign = get_bits1(&s->gb);
3046 val = (code - 1) << shift;
3048 val |= get_bits(&s->gb, shift);
3054 /* modulo decoding */
3055 if (!s->h263_long_vectors) {
3056 l = (1 << (f_code - 1)) * 32;
3059 } else if (val >= l) {
3063 /* horrible h263 long vector mode */
3064 if (pred < -31 && val < -63)
3066 if (pred > 32 && val > 63)
3073 /* Decodes RVLC of H.263+ UMV */
3074 static int h263p_decode_umotion(MpegEncContext * s, int pred)
3078 if (get_bits1(&s->gb)) /* Motion difference = 0 */
3081 code = 2 + get_bits1(&s->gb);
3083 while (get_bits1(&s->gb))
3086 code += get_bits1(&s->gb);
3091 code = (sign) ? (pred - code) : (pred + code);
3093 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
3099 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
3102 int code, level, i, j, last, run;
3103 RLTable *rl = &rl_inter;
3104 const UINT8 *scan_table;
3106 scan_table = zigzag_direct;
3107 if (s->h263_aic && s->mb_intra) {
3111 if (s->h263_aic_dir)
3112 scan_table = ff_alternate_vertical_scan; /* left */
3114 scan_table = ff_alternate_horizontal_scan; /* top */
3116 } else if (s->mb_intra) {
3118 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
3119 int component, diff;
3120 component = (n <= 3 ? 0 : n - 4 + 1);
3121 level = s->last_dc[component];
3122 if (s->rv10_first_dc_coded[component]) {
3123 diff = rv_decode_dc(s, n);
3127 level = level & 0xff; /* handle wrap round */
3128 s->last_dc[component] = level;
3130 s->rv10_first_dc_coded[component] = 1;
3133 level = get_bits(&s->gb, 8);
3143 if (s->mb_intra && s->h263_aic)
3145 s->block_last_index[n] = i - 1;
3150 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3153 if (code == rl->n) {
3155 last = get_bits1(&s->gb);
3156 run = get_bits(&s->gb, 6);
3157 level = (INT8)get_bits(&s->gb, 8);
3158 if (s->h263_rv10 && level == -128) {
3159 /* XXX: should patch encoder too */
3160 level = get_bits(&s->gb, 12);
3161 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
3164 run = rl->table_run[code];
3165 level = rl->table_level[code];
3166 last = code >= rl->last;
3167 if (get_bits1(&s->gb))
3180 if (s->mb_intra && s->h263_aic) {
3181 h263_pred_acdc(s, block, n);
3184 s->block_last_index[n] = i;
3188 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3190 int level, pred, code;
3194 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3196 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3197 if (code < 0 || code > 9 /* && s->nbit<9 */){
3198 fprintf(stderr, "illegal dc vlc\n");
3204 level = get_bits(&s->gb, code);
3205 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
3206 level = - (level ^ ((1 << code) - 1));
3208 if(get_bits1(&s->gb)==0){ /* marker */
3209 fprintf(stderr, "dc marker bit missing\n");
3215 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3220 *dc_val = level * s->y_dc_scale;
3222 *dc_val = level * s->c_dc_scale;
3229 * returns 0 if everything went ok
3230 * returns DECODING_AC_LOST if an error was detected during AC decoding
3231 * returns DECODING_ACDC_LOST if an error was detected during DC decoding
3233 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3234 int n, int coded, int intra)
3236 int level, i, last, run;
3239 RL_VLC_ELEM * rl_vlc;
3240 const UINT8 * scan_table;
3245 if(s->data_partitioning && s->pict_type!=B_TYPE){
3246 level = s->dc_val[0][ s->block_index[n] ];
3247 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
3248 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
3249 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
3251 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
3253 return DECODING_ACDC_LOST;
3260 rl_vlc = rl_intra.rl_vlc[0];
3261 if(s->alternate_scan)
3262 scan_table = ff_alternate_vertical_scan; /* left */
3263 else if (s->ac_pred) {
3264 if (dc_pred_dir == 0)
3265 scan_table = ff_alternate_vertical_scan; /* left */
3267 scan_table = ff_alternate_horizontal_scan; /* top */
3269 scan_table = zigzag_direct;
3276 s->block_last_index[n] = i;
3281 if(s->alternate_scan)
3282 scan_table = ff_alternate_vertical_scan; /* left */
3284 scan_table = zigzag_direct;
3289 rl_vlc = rl_inter.rl_vlc[0];
3291 qmul = s->qscale << 1;
3292 qadd = (s->qscale - 1) | 1;
3293 rl_vlc = rl_inter.rl_vlc[s->qscale];
3297 OPEN_READER(re, &s->gb);
3299 UPDATE_CACHE(re, &s->gb);
3300 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3303 cache= GET_CACHE(re, &s->gb);
3305 if (cache&0x80000000) {
3306 if (cache&0x40000000) {
3308 SKIP_CACHE(re, &s->gb, 2);
3309 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3310 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3311 SKIP_COUNTER(re, &s->gb, 2+1+6);
3312 UPDATE_CACHE(re, &s->gb);
3314 if(SHOW_UBITS(re, &s->gb, 1)==0){
3315 fprintf(stderr, "1. marker bit missing in 3. esc\n");
3316 return DECODING_AC_LOST;
3317 }; SKIP_CACHE(re, &s->gb, 1);
3319 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3321 if(SHOW_UBITS(re, &s->gb, 1)==0){
3322 fprintf(stderr, "2. marker bit missing in 3. esc\n");
3323 return DECODING_AC_LOST;
3324 }; LAST_SKIP_CACHE(re, &s->gb, 1);
3326 SKIP_COUNTER(re, &s->gb, 1+12+1);
3328 if(level*s->qscale>1024 || level*s->qscale<-1024){
3329 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3330 return DECODING_AC_LOST;
3334 const int abs_level= ABS(level);
3335 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
3336 const int run1= run - rl->max_run[last][abs_level] - 1;
3337 if(abs_level <= rl->max_level[last][run]){
3338 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
3339 return DECODING_AC_LOST;
3341 if(abs_level <= rl->max_level[last][run]*2){
3342 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
3343 return DECODING_AC_LOST;
3345 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
3346 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
3347 return DECODING_AC_LOST;
3352 if (level>0) level= level * qmul + qadd;
3353 else level= level * qmul - qadd;
3359 #if MIN_CACHE_BITS < 20
3360 LAST_SKIP_BITS(re, &s->gb, 2);
3361 UPDATE_CACHE(re, &s->gb);
3363 SKIP_BITS(re, &s->gb, 2);
3365 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3366 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
3367 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3368 LAST_SKIP_BITS(re, &s->gb, 1);
3372 #if MIN_CACHE_BITS < 19
3373 LAST_SKIP_BITS(re, &s->gb, 1);
3374 UPDATE_CACHE(re, &s->gb);
3376 SKIP_BITS(re, &s->gb, 1);
3378 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
3380 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
3381 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3382 LAST_SKIP_BITS(re, &s->gb, 1);
3386 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
3387 LAST_SKIP_BITS(re, &s->gb, 1);
3392 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3393 return DECODING_AC_LOST;
3396 block[scan_table[i]] = level;
3400 block[scan_table[i]] = level;
3402 CLOSE_READER(re, &s->gb);
3406 mpeg4_pred_ac(s, block, n, dc_pred_dir);
3408 i = 63; /* XXX: not optimal */
3411 s->block_last_index[n] = i;
3415 /* most is hardcoded. should extend to handle all h263 streams */
3416 int h263_decode_picture_header(MpegEncContext *s)
3418 int format, width, height;
3420 /* picture start code */
3421 if (get_bits(&s->gb, 22) != 0x20) {
3422 fprintf(stderr, "Bad picture start code\n");
3425 /* temporal reference */
3426 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3428 /* PTYPE starts here */
3429 if (get_bits1(&s->gb) != 1) {
3431 fprintf(stderr, "Bad marker\n");
3434 if (get_bits1(&s->gb) != 0) {
3435 fprintf(stderr, "Bad H263 id\n");
3436 return -1; /* h263 id */
3438 skip_bits1(&s->gb); /* split screen off */
3439 skip_bits1(&s->gb); /* camera off */
3440 skip_bits1(&s->gb); /* freeze picture release off */
3442 /* Reset GOB number */
3445 format = get_bits(&s->gb, 3);
3450 7 extended PTYPE (PLUSPTYPE)
3453 if (format != 7 && format != 6) {
3456 width = h263_format[format][0];
3457 height = h263_format[format][1];
3463 s->pict_type = I_TYPE + get_bits1(&s->gb);
3465 s->unrestricted_mv = get_bits1(&s->gb);
3466 s->h263_long_vectors = s->unrestricted_mv;
3468 if (get_bits1(&s->gb) != 0) {
3469 fprintf(stderr, "H263 SAC not supported\n");
3470 return -1; /* SAC: off */
3472 if (get_bits1(&s->gb) != 0) {
3473 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3476 if (get_bits1(&s->gb) != 0) {
3477 fprintf(stderr, "H263 PB frame not supported\n");
3478 return -1; /* not PB frame */
3480 s->qscale = get_bits(&s->gb, 5);
3481 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
3487 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3489 /* ufep other than 0 and 1 are reserved */
3492 format = get_bits(&s->gb, 3);
3493 dprintf("ufep=1, format: %d\n", format);
3494 skip_bits(&s->gb,1); /* Custom PCF */
3495 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3496 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3497 if (get_bits1(&s->gb) != 0) {
3498 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3500 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3504 skip_bits(&s->gb, 7);
3505 /* these are the 7 bits: (in order of appearence */
3506 /* Deblocking Filter */
3507 /* Slice Structured */
3508 /* Reference Picture Selection */
3509 /* Independent Segment Decoding */
3510 /* Alternative Inter VLC */
3511 /* Modified Quantization */
3512 /* Prevent start code emulation */
3514 skip_bits(&s->gb, 3); /* Reserved */
3515 } else if (ufep != 0) {
3516 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3521 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3522 dprintf("pict_type: %d\n", s->pict_type);
3523 if (s->pict_type != I_TYPE &&
3524 s->pict_type != P_TYPE)
3526 skip_bits(&s->gb, 2);
3527 s->no_rounding = get_bits1(&s->gb);
3528 dprintf("RTYPE: %d\n", s->no_rounding);
3529 skip_bits(&s->gb, 4);
3531 /* Get the picture dimensions */
3534 /* Custom Picture Format (CPFMT) */
3535 s->aspect_ratio_info = get_bits(&s->gb, 4);
3536 dprintf("aspect: %d\n", s->aspect_ratio_info);
3541 3 - 10:11 (525-type 4:3)
3542 4 - 16:11 (CIF 16:9)
3543 5 - 40:33 (525-type 16:9)
3546 width = (get_bits(&s->gb, 9) + 1) * 4;
3548 height = get_bits(&s->gb, 9) * 4;
3549 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3550 if (s->aspect_ratio_info == EXTENDED_PAR) {
3551 /* aspected dimensions */
3552 skip_bits(&s->gb, 8); /* width */
3553 skip_bits(&s->gb, 8); /* height */
3556 width = h263_format[format][0];
3557 height = h263_format[format][1];
3559 if ((width == 0) || (height == 0))
3563 if (s->umvplus_dec) {
3564 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3568 s->qscale = get_bits(&s->gb, 5);
3571 while (get_bits1(&s->gb) != 0) {
3572 skip_bits(&s->gb, 8);
3577 s->y_dc_scale_table=
3578 s->c_dc_scale_table= h263_aic_dc_scale_table;
3580 s->y_dc_scale_table=
3581 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3587 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3590 int a= 2<<s->sprite_warping_accuracy;
3591 int rho= 3-s->sprite_warping_accuracy;
3593 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3594 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3595 int sprite_ref[4][2];
3596 int virtual_ref[2][2];
3598 int alpha=0, beta=0;
3601 //printf("SP %d\n", s->sprite_warping_accuracy);
3602 for(i=0; i<s->num_sprite_warping_points; i++){
3606 length= get_vlc(&s->gb, &sprite_trajectory);
3608 x= get_bits(&s->gb, length);
3609 //printf("lx %d %d\n", length, x);
3610 if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3611 x = - (x ^ ((1 << length) - 1));
3613 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3615 length= get_vlc(&s->gb, &sprite_trajectory);
3617 y=get_bits(&s->gb, length);
3618 //printf("ly %d %d\n", length, y);
3619 if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3620 y = - (y ^ ((1 << length) - 1));
3622 skip_bits1(&s->gb); /* marker bit */
3623 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3624 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
3630 while((1<<alpha)<w) alpha++;
3631 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3635 // Note, the 4th point isnt used for GMC
3636 if(s->divx_version==500 && s->divx_build==413){
3637 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3638 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3639 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3640 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3641 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3642 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3644 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3645 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3646 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3647 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3648 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3649 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3651 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3652 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3654 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3655 // perhaps it should be reordered to be more readable ...
3656 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3657 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3658 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
3659 + 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);
3660 virtual_ref[0][1]= 16*vop_ref[0][1]
3661 + 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);
3662 virtual_ref[1][0]= 16*vop_ref[0][0]
3663 + 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);
3664 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
3665 + 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);
3667 switch(s->num_sprite_warping_points)
3670 s->sprite_offset[0][0]= 0;
3671 s->sprite_offset[0][1]= 0;
3672 s->sprite_offset[1][0]= 0;
3673 s->sprite_offset[1][1]= 0;
3674 s->sprite_delta[0][0][0]= a;
3675 s->sprite_delta[0][0][1]= 0;
3676 s->sprite_delta[0][1][0]= 0;
3677 s->sprite_delta[0][1][1]= a;
3678 s->sprite_delta[1][0][0]= a;
3679 s->sprite_delta[1][0][1]= 0;
3680 s->sprite_delta[1][1][0]= 0;
3681 s->sprite_delta[1][1][1]= a;
3682 s->sprite_shift[0][0]= 0;
3683 s->sprite_shift[0][1]= 0;
3684 s->sprite_shift[1][0]= 0;
3685 s->sprite_shift[1][1]= 0;
3688 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
3689 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
3690 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
3691 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
3692 s->sprite_delta[0][0][0]= a;
3693 s->sprite_delta[0][0][1]= 0;
3694 s->sprite_delta[0][1][0]= 0;
3695 s->sprite_delta[0][1][1]= a;
3696 s->sprite_delta[1][0][0]= a;
3697 s->sprite_delta[1][0][1]= 0;
3698 s->sprite_delta[1][1][0]= 0;
3699 s->sprite_delta[1][1][1]= a;
3700 s->sprite_shift[0][0]= 0;
3701 s->sprite_shift[0][1]= 0;
3702 s->sprite_shift[1][0]= 0;
3703 s->sprite_shift[1][1]= 0;
3707 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
3708 + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
3709 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
3710 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
3711 + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
3712 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
3713 s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
3714 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
3715 +2*w2*r*sprite_ref[0][0] - 16*w2);
3716 s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
3717 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
3718 +2*w2*r*sprite_ref[0][1] - 16*w2);
3719 s->sprite_delta[0][0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3720 s->sprite_delta[0][0][1]= ( r*sprite_ref[0][1] - virtual_ref[0][1]);
3721 s->sprite_delta[0][1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
3722 s->sprite_delta[0][1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
3723 s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3724 s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
3725 s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
3726 s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
3727 s->sprite_shift[0][0]= alpha+rho;
3728 s->sprite_shift[0][1]= alpha+rho;
3729 s->sprite_shift[1][0]= alpha+rho+2;
3730 s->sprite_shift[1][1]= alpha+rho+2;
3735 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
3736 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
3737 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
3738 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
3739 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
3740 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
3741 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
3742 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
3743 /* try to simplify the situation */
3744 if( s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
3745 && s->sprite_delta[0][0][1] == 0
3746 && s->sprite_delta[0][1][0] == 0
3747 && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
3748 && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
3749 && s->sprite_delta[1][0][1] == 0
3750 && s->sprite_delta[1][1][0] == 0
3751 && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
3753 s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
3754 s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
3755 s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
3756 s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
3757 s->sprite_delta[0][0][0]= a;
3758 s->sprite_delta[0][0][1]= 0;
3759 s->sprite_delta[0][1][0]= 0;
3760 s->sprite_delta[0][1][1]= a;
3761 s->sprite_delta[1][0][0]= a;
3762 s->sprite_delta[1][0][1]= 0;
3763 s->sprite_delta[1][1][0]= 0;
3764 s->sprite_delta[1][1][1]= a;
3765 s->sprite_shift[0][0]= 0;
3766 s->sprite_shift[0][1]= 0;
3767 s->sprite_shift[1][0]= 0;
3768 s->sprite_shift[1][1]= 0;
3769 s->real_sprite_warping_points=1;
3772 s->real_sprite_warping_points= s->num_sprite_warping_points;
3774 //printf("%d %d %d %d\n", d[0][0], d[0][1], s->sprite_offset[0][0], s->sprite_offset[0][1]);
3777 /* decode mpeg4 VOP header */
3778 int mpeg4_decode_picture_header(MpegEncContext * s)
3780 int time_incr, startcode, state, v;
3784 /* search next start code */
3785 align_get_bits(&s->gb);
3788 v = get_bits(&s->gb, 8);
3789 if (state == 0x000001) {
3790 state = ((state << 8) | v) & 0xffffff;
3794 state = ((state << 8) | v) & 0xffffff;
3795 if( get_bits_count(&s->gb) > s->gb.size*8-32){
3797 printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
3800 printf("frame skip\n");
3801 return FRAME_SKIPED;
3805 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
3806 if (startcode == 0x120) { // Video Object Layer
3807 int width, height, vo_ver_id;
3810 skip_bits(&s->gb, 1); /* random access */
3811 s->vo_type= get_bits(&s->gb, 8);
3812 if (get_bits1(&s->gb) != 0) { /* is_ol_id */
3813 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
3814 skip_bits(&s->gb, 3); /* vo_priority */
3818 //printf("vo type:%d\n",s->vo_type);
3819 s->aspect_ratio_info= get_bits(&s->gb, 4);
3820 if(s->aspect_ratio_info == EXTENDED_PAR){
3821 skip_bits(&s->gb, 8); //par_width
3822 skip_bits(&s->gb, 8); // par_height
3825 if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
3826 int chroma_format= get_bits(&s->gb, 2);
3827 if(chroma_format!=1){
3828 printf("illegal chroma format\n");
3830 s->low_delay= get_bits1(&s->gb);
3831 if(get_bits1(&s->gb)){ /* vbv parameters */
3832 get_bits(&s->gb, 15); /* first_half_bitrate */
3833 skip_bits1(&s->gb); /* marker */
3834 get_bits(&s->gb, 15); /* latter_half_bitrate */
3835 skip_bits1(&s->gb); /* marker */
3836 get_bits(&s->gb, 15); /* first_half_vbv_buffer_size */
3837 skip_bits1(&s->gb); /* marker */
3838 get_bits(&s->gb, 3); /* latter_half_vbv_buffer_size */
3839 get_bits(&s->gb, 11); /* first_half_vbv_occupancy */
3840 skip_bits1(&s->gb); /* marker */
3841 get_bits(&s->gb, 15); /* latter_half_vbv_occupancy */
3842 skip_bits1(&s->gb); /* marker */
3845 // set low delay flag only once so the smart? low delay detection wont be overriden
3846 if(s->picture_number==0)
3850 s->shape = get_bits(&s->gb, 2); /* vol shape */
3851 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
3852 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
3853 printf("Gray shape not supported\n");
3854 skip_bits(&s->gb, 4); //video_object_layer_shape_extension
3857 skip_bits1(&s->gb); /* marker */
3859 s->time_increment_resolution = get_bits(&s->gb, 16);
3861 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
3862 if (s->time_increment_bits < 1)
3863 s->time_increment_bits = 1;
3864 skip_bits1(&s->gb); /* marker */
3866 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */
3867 skip_bits(&s->gb, s->time_increment_bits);
3870 if (s->shape != BIN_ONLY_SHAPE) {
3871 if (s->shape == RECT_SHAPE) {
3872 skip_bits1(&s->gb); /* marker */
3873 width = get_bits(&s->gb, 13);
3874 skip_bits1(&s->gb); /* marker */
3875 height = get_bits(&s->gb, 13);
3876 skip_bits1(&s->gb); /* marker */
3877 if(width && height){ /* they should be non zero but who knows ... */
3880 // printf("width/height: %d %d\n", width, height);
3884 s->progressive_sequence= get_bits1(&s->gb)^1;
3885 if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
3886 if (vo_ver_id == 1) {
3887 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
3889 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
3891 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
3892 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
3893 if(s->vol_sprite_usage==STATIC_SPRITE){
3894 s->sprite_width = get_bits(&s->gb, 13);
3895 skip_bits1(&s->gb); /* marker */
3896 s->sprite_height= get_bits(&s->gb, 13);
3897 skip_bits1(&s->gb); /* marker */
3898 s->sprite_left = get_bits(&s->gb, 13);
3899 skip_bits1(&s->gb); /* marker */
3900 s->sprite_top = get_bits(&s->gb, 13);
3901 skip_bits1(&s->gb); /* marker */
3903 s->num_sprite_warping_points= get_bits(&s->gb, 6);
3904 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
3905 s->sprite_brightness_change= get_bits1(&s->gb);
3906 if(s->vol_sprite_usage==STATIC_SPRITE)
3907 s->low_latency_sprite= get_bits1(&s->gb);
3909 // FIXME sadct disable bit if verid!=1 && shape not rect
3911 if (get_bits1(&s->gb) == 1) { /* not_8_bit */
3912 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
3913 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
3914 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
3916 s->quant_precision = 5;
3919 // FIXME a bunch of grayscale shape things
3921 if((s->mpeg_quant=get_bits1(&s->gb))){ /* vol_quant_type */
3924 /* load default matrixes */
3925 for(i=0; i<64; i++){
3926 v= ff_mpeg4_default_intra_matrix[i];
3927 s->intra_matrix[i]= v;
3928 s->chroma_intra_matrix[i]= v;
3930 v= ff_mpeg4_default_non_intra_matrix[i];
3931 s->inter_matrix[i]= v;
3932 s->chroma_inter_matrix[i]= v;
3935 /* load custom intra matrix */
3936 if(get_bits1(&s->gb)){
3937 for(i=0; i<64; i++){
3938 v= get_bits(&s->gb, 8);
3941 j= zigzag_direct[i];
3942 s->intra_matrix[j]= v;
3943 s->chroma_intra_matrix[j]= v;
3947 /* load custom non intra matrix */
3948 if(get_bits1(&s->gb)){
3949 for(i=0; i<64; i++){
3950 v= get_bits(&s->gb, 8);
3953 j= zigzag_direct[i];
3954 s->inter_matrix[j]= v;
3955 s->chroma_inter_matrix[j]= v;
3958 /* replicate last value */
3960 j= zigzag_direct[i];
3961 s->inter_matrix[j]= v;
3962 s->chroma_inter_matrix[j]= v;
3966 // FIXME a bunch of grayscale shape things
3970 s->quarter_sample= get_bits1(&s->gb);
3971 else s->quarter_sample=0;
3973 if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
3975 s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
3977 s->data_partitioning= get_bits1(&s->gb);
3978 if(s->data_partitioning){
3979 s->rvlc= get_bits1(&s->gb);
3981 printf("reversible vlc not supported\n");
3985 if(vo_ver_id != 1) {
3986 s->new_pred= get_bits1(&s->gb);
3988 printf("new pred not supported\n");
3989 skip_bits(&s->gb, 2); /* requested upstream message type */
3990 skip_bits1(&s->gb); /* newpred segment type */
3992 s->reduced_res_vop= get_bits1(&s->gb);
3993 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
3997 s->reduced_res_vop= 0;
4000 s->scalability= get_bits1(&s->gb);
4001 if(s->workaround_bugs==1) s->scalability=0;
4002 if (s->scalability) {
4003 int dummy= s->hierachy_type= get_bits1(&s->gb);
4004 int ref_layer_id= get_bits(&s->gb, 4);
4005 int ref_layer_sampling_dir= get_bits1(&s->gb);
4006 int h_sampling_factor_n= get_bits(&s->gb, 5);
4007 int h_sampling_factor_m= get_bits(&s->gb, 5);
4008 int v_sampling_factor_n= get_bits(&s->gb, 5);
4009 int v_sampling_factor_m= get_bits(&s->gb, 5);
4010 s->enhancement_type= get_bits1(&s->gb);
4011 // bin shape stuff FIXME
4012 printf("scalability not supported\n");
4015 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
4017 } else if (startcode == 0x1b2) { //userdata
4023 //printf("user Data %X\n", show_bits(&s->gb, 32));
4024 buf[0]= show_bits(&s->gb, 8);
4025 for(i=1; i<256; i++){
4026 buf[i]= show_bits(&s->gb, 16)&0xFF;
4027 if(buf[i]==0) break;
4028 skip_bits(&s->gb, 8);
4031 e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
4033 e=sscanf(buf, "DivX%db%d", &ver, &build);
4035 s->divx_version= ver;
4036 s->divx_build= build;
4037 if(s->picture_number==0){
4038 printf("This file was encoded with DivX%d Build%d\n", ver, build);
4039 if(ver==500 && build==413){
4040 printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
4044 //printf("User Data: %s\n", buf);
4046 } else if (startcode != 0x1b6) { //VOP
4050 s->pict_type = get_bits(&s->gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
4051 //if(s->pict_type!=I_TYPE) return FRAME_SKIPED;
4052 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
4053 printf("low_delay flag set, but shouldnt, clearing it\n");
4056 // printf("pic: %d, qpel:%d part:%d resync:%d\n", s->pict_type, s->quarter_sample, s->data_partitioning, s->resync_marker);
4058 if(s->time_increment_resolution==0){
4059 s->time_increment_resolution=1;
4060 // fprintf(stderr, "time_increment_resolution is illegal\n");
4063 while (get_bits1(&s->gb) != 0)
4066 check_marker(&s->gb, "before time_increment");
4067 time_increment= get_bits(&s->gb, s->time_increment_bits);
4068 //printf(" type:%d incr:%d increment:%d\n", s->pict_type, time_incr, time_increment);
4069 if(s->pict_type!=B_TYPE){
4070 s->last_time_base= s->time_base;
4071 s->time_base+= time_incr;
4072 s->time= s->time_base*s->time_increment_resolution + time_increment;
4073 if(s->time < s->last_non_b_time && s->workaround_bugs==3){
4074 fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4076 s->time+= s->time_increment_resolution;
4078 s->pp_time= s->time - s->last_non_b_time;
4079 s->last_non_b_time= s->time;
4081 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
4082 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4083 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4084 // printf("messed up order, seeking?, skiping current b frame\n");
4085 return FRAME_SKIPED;
4088 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
4089 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4090 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4091 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4092 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4093 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
4094 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4097 s->avctx->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
4099 if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
4100 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
4101 for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
4102 if(get_bits1(&s->gb)) break;
4104 printf("my guess is %d bits ;)\n",s->time_increment_bits);
4107 if (get_bits1(&s->gb) != 1)
4109 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4110 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4111 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4112 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4113 /* rounding type for motion estimation */
4114 s->no_rounding = get_bits1(&s->gb);
4118 //FIXME reduced res stuff
4120 if (s->shape != RECT_SHAPE) {
4121 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4122 int width, height, hor_spat_ref, ver_spat_ref;
4124 width = get_bits(&s->gb, 13);
4125 skip_bits1(&s->gb); /* marker */
4126 height = get_bits(&s->gb, 13);
4127 skip_bits1(&s->gb); /* marker */
4128 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
4129 skip_bits1(&s->gb); /* marker */
4130 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
4132 skip_bits1(&s->gb); /* change_CR_disable */
4134 if (get_bits1(&s->gb) != 0) {
4135 skip_bits(&s->gb, 8); /* constant_alpha_value */
4138 //FIXME complexity estimation stuff
4140 if (s->shape != BIN_ONLY_SHAPE) {
4142 t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
4143 //printf("threshold %d\n", t);
4144 if(!s->progressive_sequence){
4145 s->top_field_first= get_bits1(&s->gb);
4146 s->alternate_scan= get_bits1(&s->gb);
4148 s->alternate_scan= 0;
4151 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4152 if(s->num_sprite_warping_points){
4153 mpeg4_decode_sprite_trajectory(s);
4155 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4156 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4159 if (s->shape != BIN_ONLY_SHAPE) {
4160 /* note: we do not use quant_precision to avoid problem if no
4161 MPEG4 vol header as it is found on some old opendivx
4163 s->qscale = get_bits(&s->gb, 5);
4165 printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
4166 return -1; // makes no sense to continue, as there is nothing left from the image then
4169 if (s->pict_type != I_TYPE) {
4170 s->f_code = get_bits(&s->gb, 3); /* fcode_for */
4172 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
4173 return -1; // makes no sense to continue, as the MV decoding will break very quickly
4178 if (s->pict_type == B_TYPE) {
4179 s->b_code = get_bits(&s->gb, 3);
4183 printf("qp:%d fc:%d bc:%d type:%s size:%d pro:%d alt:%d qpel:%d part:%d resync:%d\n",
4184 s->qscale, s->f_code, s->b_code,
4185 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4186 s->gb.size,s->progressive_sequence, s->alternate_scan, s->quarter_sample, s->data_partitioning, s->resync_marker);
4188 if(!s->scalability){
4189 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4190 skip_bits1(&s->gb); // vop shape coding type
4193 if(s->enhancement_type){
4194 int load_backward_shape= get_bits1(&s->gb);
4195 if(load_backward_shape){
4196 printf("load backward shape isnt supported\n");
4199 skip_bits(&s->gb, 2); //ref_select_code
4202 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
4203 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
4204 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
4205 printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
4209 s->picture_number++; // better than pic number==0 allways ;)
4211 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
4212 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
4214 if(s->divx_version==0 || s->divx_version < 500){
4215 s->h_edge_pos= s->width;
4216 s->v_edge_pos= s->height;
4221 /* don't understand why they choose a different header ! */
4222 int intel_h263_decode_picture_header(MpegEncContext *s)
4226 /* picture header */
4227 if (get_bits(&s->gb, 22) != 0x20) {
4228 fprintf(stderr, "Bad picture start code\n");
4231 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
4233 if (get_bits1(&s->gb) != 1) {
4234 fprintf(stderr, "Bad marker\n");
4235 return -1; /* marker */
4237 if (get_bits1(&s->gb) != 0) {
4238 fprintf(stderr, "Bad H263 id\n");
4239 return -1; /* h263 id */
4241 skip_bits1(&s->gb); /* split screen off */
4242 skip_bits1(&s->gb); /* camera off */
4243 skip_bits1(&s->gb); /* freeze picture release off */
4245 format = get_bits(&s->gb, 3);
4247 fprintf(stderr, "Intel H263 free format not supported\n");
4252 s->pict_type = I_TYPE + get_bits1(&s->gb);
4254 s->unrestricted_mv = get_bits1(&s->gb);
4255 s->h263_long_vectors = s->unrestricted_mv;
4257 if (get_bits1(&s->gb) != 0) {
4258 fprintf(stderr, "SAC not supported\n");
4259 return -1; /* SAC: off */
4261 if (get_bits1(&s->gb) != 0) {
4262 fprintf(stderr, "Advanced Prediction Mode not supported\n");
4263 return -1; /* advanced prediction mode: off */
4265 if (get_bits1(&s->gb) != 0) {
4266 fprintf(stderr, "PB frame mode no supported\n");
4267 return -1; /* PB frame mode */
4270 /* skip unknown header garbage */
4271 skip_bits(&s->gb, 41);
4273 s->qscale = get_bits(&s->gb, 5);
4274 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4277 while (get_bits1(&s->gb) != 0) {
4278 skip_bits(&s->gb, 8);