2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Gerard Lantau.
5 * Copyright (c) 2001 Juan J. Sierralta P.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program 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
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include "mpegvideo.h"
26 #include "mpeg4data.h"
28 //rounded divison & shift
29 #define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
30 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
31 #define ABS(a) (((a)>=0)?(a):(-(a)))
33 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
35 static void h263_encode_motion(MpegEncContext * s, int val);
36 static void h263p_encode_umotion(MpegEncContext * s, int val);
37 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
38 int n, int dc, UINT8 *scan_table);
39 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
40 static int h263p_decode_umotion(MpegEncContext * s, int pred);
41 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
43 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
45 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
46 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
49 extern UINT32 inverse[256];
51 int h263_get_picture_format(int width, int height)
55 if (width == 128 && height == 96)
57 else if (width == 176 && height == 144)
59 else if (width == 352 && height == 288)
61 else if (width == 704 && height == 576)
63 else if (width == 1408 && height == 1152)
70 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
74 align_put_bits(&s->pb);
76 /* Update the pointer to last GOB */
77 s->ptr_lastgob = pbBufPtr(&s->pb);
80 put_bits(&s->pb, 22, 0x20); /* PSC */
81 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
82 s->frame_rate) & 0xff);
84 put_bits(&s->pb, 1, 1); /* marker */
85 put_bits(&s->pb, 1, 0); /* h263 id */
86 put_bits(&s->pb, 1, 0); /* split screen off */
87 put_bits(&s->pb, 1, 0); /* camera off */
88 put_bits(&s->pb, 1, 0); /* freeze picture release off */
90 format = h263_get_picture_format(s->width, s->height);
93 put_bits(&s->pb, 3, format);
94 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
95 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
96 of H.263v1 UMV implies to check the predicted MV after
97 calculation of the current MB to see if we're on the limits */
98 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
99 put_bits(&s->pb, 1, 0); /* SAC: off */
100 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
101 put_bits(&s->pb, 1, 0); /* not PB frame */
102 put_bits(&s->pb, 5, s->qscale);
103 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
106 /* H.263 Plus PTYPE */
107 put_bits(&s->pb, 3, 7);
108 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
110 put_bits(&s->pb,3,6); /* Custom Source Format */
112 put_bits(&s->pb, 3, format);
114 put_bits(&s->pb,1,0); /* Custom PCF: off */
115 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
116 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
117 put_bits(&s->pb,1,0); /* SAC: off */
118 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
119 put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
120 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
121 put_bits(&s->pb,1,0); /* Slice Structured: off */
122 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
123 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
124 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
125 put_bits(&s->pb,1,0); /* Modified Quantization: off */
126 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
127 put_bits(&s->pb,3,0); /* Reserved */
129 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
131 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
132 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
133 put_bits(&s->pb,1,0); /* Rounding Type */
134 put_bits(&s->pb,2,0); /* Reserved */
135 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
137 /* This should be here if PLUSPTYPE */
138 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
141 /* Custom Picture Format (CPFMT) */
143 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
144 put_bits(&s->pb,9,(s->width >> 2) - 1);
145 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
146 put_bits(&s->pb,9,(s->height >> 2));
149 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
151 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
152 put_bits(&s->pb, 5, s->qscale);
155 put_bits(&s->pb, 1, 0); /* no PEI */
158 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
162 /* Check to see if we need to put a new GBSC */
163 /* for RTP packetization */
165 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
166 if (pdif >= s->rtp_payload_size) {
167 /* Bad luck, packet must be cut before */
168 align_put_bits(&s->pb);
169 flush_put_bits(&s->pb);
170 /* Call the RTP callback to send the last GOB */
171 if (s->rtp_callback) {
172 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
173 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
175 s->ptr_lastgob = pbBufPtr(&s->pb);
176 put_bits(&s->pb, 17, 1); /* GBSC */
177 s->gob_number = mb_line / s->gob_index;
178 put_bits(&s->pb, 5, s->gob_number); /* GN */
179 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
180 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
181 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
183 } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
184 /* Cut the packet before we can't */
185 align_put_bits(&s->pb);
186 flush_put_bits(&s->pb);
187 /* Call the RTP callback to send the last GOB */
188 if (s->rtp_callback) {
189 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
190 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
192 s->ptr_lastgob = pbBufPtr(&s->pb);
193 put_bits(&s->pb, 17, 1); /* GBSC */
194 s->gob_number = mb_line / s->gob_index;
195 put_bits(&s->pb, 5, s->gob_number); /* GN */
196 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
197 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
198 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
205 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
207 int score0=0, score1=0;
211 INT16 *ac_val, *ac_val1;
213 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
216 ac_val-= s->block_wrap[n]*16;
218 const int level= block[n][block_permute_op(i )];
220 score1+= ABS(level - ac_val[i+8]);
221 ac_val1[i ]= block[n][block_permute_op(i<<3)];
227 const int level= block[n][block_permute_op(i<<3)];
229 score1+= ABS(level - ac_val[i]);
231 ac_val1[i+8]= block[n][block_permute_op(i )];
236 return score0 > score1 ? 1 : 0;
239 void mpeg4_encode_mb(MpegEncContext * s,
240 DCTELEM block[6][64],
241 int motion_x, int motion_y)
243 int cbpc, cbpy, i, cbp, pred_x, pred_y;
245 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
249 for (i = 0; i < 6; i++) {
250 if (s->block_last_index[i] >= 0)
253 if ((cbp | motion_x | motion_y) == 0) {
254 /* skip macroblock */
255 put_bits(&s->pb, 1, 1);
258 put_bits(&s->pb, 1, 0); /* mb coded */
261 inter_MCBPC_bits[cbpc],
262 inter_MCBPC_code[cbpc]);
265 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
267 /* motion vectors: 16x16 mode only now */
268 h263_pred_motion(s, 0, &pred_x, &pred_y);
270 h263_encode_motion(s, motion_x - pred_x);
271 h263_encode_motion(s, motion_y - pred_y);
273 /* encode each block */
274 for (i = 0; i < 6; i++) {
275 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
278 int dc_diff[6]; //dc values with the dc prediction subtracted
279 int dir[6]; //prediction direction
280 int zigzag_last_index[6];
281 UINT8 *scan_table[6];
284 const int level= block[i][0];
287 dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
289 *dc_ptr = level * s->y_dc_scale;
291 *dc_ptr = level * s->c_dc_scale;
295 s->ac_pred= decide_ac_pred(s, block, dir);
302 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
303 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
304 else st = ff_alternate_horizontal_scan; /* top */
306 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
307 if(block[i][st[last_index]]) break;
308 zigzag_last_index[i]= s->block_last_index[i];
309 s->block_last_index[i]= last_index;
314 scan_table[i]= zigzag_direct;
319 for (i = 0; i < 6; i++) {
320 if (s->block_last_index[i] >= 1)
325 if (s->pict_type == I_TYPE) {
327 intra_MCBPC_bits[cbpc],
328 intra_MCBPC_code[cbpc]);
330 put_bits(&s->pb, 1, 0); /* mb coded */
332 inter_MCBPC_bits[cbpc + 4],
333 inter_MCBPC_code[cbpc + 4]);
335 put_bits(&s->pb, 1, s->ac_pred);
337 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
339 /* encode each block */
340 for (i = 0; i < 6; i++) {
341 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
344 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
350 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
354 block[i][block_permute_op(j )]= ac_val[j+8];
357 block[i][block_permute_op(j<<3)]= ac_val[j ];
359 s->block_last_index[i]= zigzag_last_index[i];
365 void h263_encode_mb(MpegEncContext * s,
366 DCTELEM block[6][64],
367 int motion_x, int motion_y)
369 int cbpc, cbpy, i, cbp, pred_x, pred_y;
371 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
375 for (i = 0; i < 6; i++) {
376 if (s->block_last_index[i] >= 0)
379 if ((cbp | motion_x | motion_y) == 0) {
380 /* skip macroblock */
381 put_bits(&s->pb, 1, 1);
384 put_bits(&s->pb, 1, 0); /* mb coded */
387 inter_MCBPC_bits[cbpc],
388 inter_MCBPC_code[cbpc]);
391 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
393 /* motion vectors: 16x16 mode only now */
394 h263_pred_motion(s, 0, &pred_x, &pred_y);
397 h263_encode_motion(s, motion_x - pred_x);
398 h263_encode_motion(s, motion_y - pred_y);
401 h263p_encode_umotion(s, motion_x - pred_x);
402 h263p_encode_umotion(s, motion_y - pred_y);
403 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
404 /* To prevent Start Code emulation */
405 put_bits(&s->pb,1,1);
410 for (i = 0; i < 6; i++) {
411 if (s->block_last_index[i] >= 1)
416 if (s->pict_type == I_TYPE) {
418 intra_MCBPC_bits[cbpc],
419 intra_MCBPC_code[cbpc]);
421 put_bits(&s->pb, 1, 0); /* mb coded */
423 inter_MCBPC_bits[cbpc + 4],
424 inter_MCBPC_code[cbpc + 4]);
427 /* XXX: currently, we do not try to use ac prediction */
428 put_bits(&s->pb, 1, 0); /* no ac prediction */
431 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
434 /* encode each block */
436 for (i = 0; i < 6; i++) {
437 // mpeg4_encode_block(s, block[i], i);
440 for (i = 0; i < 6; i++) {
441 h263_encode_block(s, block[i], i);
446 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
448 int x, y, wrap, a, c, pred_dc, scale, i;
449 INT16 *dc_val, *ac_val, *ac_val1;
451 /* find prediction */
453 x = 2 * s->mb_x + 1 + (n & 1);
454 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
455 wrap = s->mb_width * 2 + 2;
456 dc_val = s->dc_val[0];
457 ac_val = s->ac_val[0][0];
458 scale = s->y_dc_scale;
462 wrap = s->mb_width + 2;
463 dc_val = s->dc_val[n - 4 + 1];
464 ac_val = s->ac_val[n - 4 + 1][0];
465 scale = s->c_dc_scale;
468 ac_val += ((y) * wrap + (x)) * 16;
474 a = dc_val[(x - 1) + (y) * wrap];
475 c = dc_val[(x) + (y - 1) * wrap];
479 if (s->h263_aic_dir) {
480 /* left prediction */
484 block[block_permute_op(i*8)] += ac_val[i];
493 block[block_permute_op(i)] += ac_val[i + 8];
499 /* just DC prediction */
500 if (a != 1024 && c != 1024)
501 pred_dc = (a + c) >> 1;
508 /* we assume pred is positive */
509 block[0]=block[0]*scale + pred_dc;
513 else if (!(block[0] & 1))
516 /* Update AC/DC tables */
517 dc_val[(x) + (y) * wrap] = block[0];
521 ac_val1[i] = block[block_permute_op(i * 8)];
524 ac_val1[8 + i] = block[block_permute_op(i)];
528 static inline int mid_pred(int a, int b, int c)
542 return a + b + c - vmin - vmax;
545 INT16 *h263_pred_motion(MpegEncContext * s, int block,
549 INT16 *A, *B, *C, *mot_val;
550 static const int off[4]= {2, 1, 1, -1};
552 wrap = s->block_wrap[0];
553 xy = s->block_index[block];
555 mot_val = s->motion_val[xy];
557 /* special case for first line */
558 if (s->mb_y == 0 || s->first_slice_line || s->first_gob_line) {
559 A = s->motion_val[xy - 1];
563 A = s->motion_val[xy - 1];
564 B = s->motion_val[xy - wrap];
565 C = s->motion_val[xy + off[block] - wrap];
566 *px = mid_pred(A[0], B[0], C[0]);
567 *py = mid_pred(A[1], B[1], C[1]);
572 static void h263_encode_motion(MpegEncContext * s, int val)
574 int range, l, m, bit_size, sign, code, bits;
579 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
581 bit_size = s->f_code - 1;
582 range = 1 << bit_size;
583 /* modulo encoding */
588 } else if (val >= l) {
594 code = (val >> bit_size) + 1;
595 bits = val & (range - 1);
600 code = (val >> bit_size) + 1;
601 bits = val & (range - 1);
605 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
607 put_bits(&s->pb, bit_size, bits);
612 /* Encode MV differences on H.263+ with Unrestricted MV mode */
613 static void h263p_encode_umotion(MpegEncContext * s, int val)
623 put_bits(&s->pb, 1, 1);
625 put_bits(&s->pb, 3, 0);
627 put_bits(&s->pb, 3, 2);
630 sval = ((val < 0) ? (short)(-val):(short)val);
633 while (temp_val != 0) {
634 temp_val = temp_val >> 1;
640 tcode = (sval & (1 << (i-1))) >> (i-1);
641 tcode = (tcode << 1) | 1;
642 code = (code << 2) | tcode;
645 code = ((code << 1) | (val < 0)) << 1;
646 put_bits(&s->pb, (2*n_bits)+1, code);
647 //printf("\nVal = %d\tCode = %d", sval, code);
651 void h263_encode_init_vlc(MpegEncContext *s)
662 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
664 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
666 RLTable *rl = &rl_inter;
671 /* 255 cannot be represented, so we clamp */
676 /* 0 cannot be represented also */
682 put_bits(&s->pb, 8, 0xff);
684 put_bits(&s->pb, 8, level & 0xff);
691 last_index = s->block_last_index[n];
692 last_non_zero = i - 1;
693 for (; i <= last_index; i++) {
694 j = zigzag_direct[i];
697 run = i - last_non_zero - 1;
698 last = (i == last_index);
705 code = get_rl_index(rl, last, run, level);
706 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
708 put_bits(&s->pb, 1, last);
709 put_bits(&s->pb, 6, run);
710 put_bits(&s->pb, 8, slevel & 0xff);
712 put_bits(&s->pb, 1, sign);
719 /***************************************************/
721 static void mpeg4_stuffing(PutBitContext * pbc)
725 length= (-get_bit_count(pbc))&7;
726 put_bits(pbc, length, (1<<length)-1);
729 static void put_string(PutBitContext * pbc, char *s)
732 put_bits(pbc, 8, *s);
738 static void mpeg4_encode_vol_header(MpegEncContext * s)
740 int vo_ver_id=1; //must be 2 if we want GMC or q-pel
742 if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
743 put_bits(&s->pb, 16, 0);
744 put_bits(&s->pb, 16, 0x100); /* video obj */
745 put_bits(&s->pb, 16, 0);
746 put_bits(&s->pb, 16, 0x120); /* video obj layer */
748 put_bits(&s->pb, 1, 0); /* random access vol */
749 put_bits(&s->pb, 8, 1); /* video obj type indication= simple obj */
750 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
751 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
752 put_bits(&s->pb, 3, 1); /* is obj layer priority */
753 put_bits(&s->pb, 4, 1); /* aspect ratio info= sqare pixel */ //FIXME real aspect
754 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
755 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
756 put_bits(&s->pb, 1, 1); /* marker bit */
757 put_bits(&s->pb, 16, s->time_increment_resolution=30000);
758 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
759 if (s->time_increment_bits < 1)
760 s->time_increment_bits = 1;
761 put_bits(&s->pb, 1, 1); /* marker bit */
762 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
763 put_bits(&s->pb, 1, 1); /* marker bit */
764 put_bits(&s->pb, 13, s->width); /* vol width */
765 put_bits(&s->pb, 1, 1); /* marker bit */
766 put_bits(&s->pb, 13, s->height); /* vol height */
767 put_bits(&s->pb, 1, 1); /* marker bit */
768 put_bits(&s->pb, 1, 0); /* interlace */
769 put_bits(&s->pb, 1, 1); /* obmc disable */
770 if (vo_ver_id == 1) {
771 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
772 }else{ /* vo_ver_id == 2 */
773 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
775 put_bits(&s->pb, 1, 0); /* not 8 bit */
776 put_bits(&s->pb, 1, 0); /* quant type= h263 style*/
778 put_bits(&s->pb, 1, s->quarter_sample=0);
779 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
780 put_bits(&s->pb, 1, 1); /* resync marker disable */
781 put_bits(&s->pb, 1, 0); /* data partitioned */
783 put_bits(&s->pb, 1, 0); /* newpred */
784 put_bits(&s->pb, 1, 0); /* reduced res vop */
786 put_bits(&s->pb, 1, 0); /* scalability */
788 mpeg4_stuffing(&s->pb);
789 put_bits(&s->pb, 16, 0);
790 put_bits(&s->pb, 16, 0x1B2); /* user_data */
791 put_string(&s->pb, "ffmpeg"); //FIXME append some version ...
796 /* write mpeg4 VOP header */
797 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
799 if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
801 if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
802 put_bits(&s->pb, 16, 0); /* vop header */
803 put_bits(&s->pb, 16, 0x1B6); /* vop header */
804 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
805 /* XXX: time base + 1 not always correct */
806 put_bits(&s->pb, 1, 1);
807 put_bits(&s->pb, 1, 0);
809 put_bits(&s->pb, 1, 1); /* marker */
810 put_bits(&s->pb, s->time_increment_bits, 1); /* XXX: correct time increment */
811 put_bits(&s->pb, 1, 1); /* marker */
812 put_bits(&s->pb, 1, 1); /* vop coded */
813 if ( s->pict_type == P_TYPE
814 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
816 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
818 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
821 put_bits(&s->pb, 5, s->qscale);
823 if (s->pict_type != I_TYPE)
824 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
825 if (s->pict_type == B_TYPE)
826 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
827 // printf("****frame %d\n", picture_number);
830 void h263_dc_scale(MpegEncContext * s)
833 const static UINT8 y_tab[32]={
834 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
835 0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
837 const static UINT8 c_tab[32]={
838 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
839 0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
841 s->y_dc_scale = y_tab[s->qscale];
842 s->c_dc_scale = c_tab[s->qscale];
849 else if (quant > 4 && quant < 9)
850 s->y_dc_scale = (2 * quant);
851 else if (quant > 8 && quant < 25)
852 s->y_dc_scale = (quant + 8);
854 s->y_dc_scale = (2 * quant - 16);
858 else if (quant > 4 && quant < 25)
859 s->c_dc_scale = ((quant + 13) / 2);
861 s->c_dc_scale = (quant - 6);
865 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
867 int a, b, c, wrap, pred, scale;
871 /* find prediction */
873 scale = s->y_dc_scale;
875 scale = s->c_dc_scale;
877 wrap= s->block_wrap[n];
878 dc_val = s->dc_val[0] + s->block_index[n];
884 b = dc_val[ - 1 - wrap];
887 if (abs(a - b) < abs(b - c)) {
889 *dir_ptr = 1; /* top */
892 *dir_ptr = 0; /* left */
894 /* we assume pred is positive */
897 "xorl %%edx, %%edx \n\t"
899 : "=d" (pred), "=a"(dummy)
900 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
903 pred = (pred + (scale >> 1)) / scale;
906 /* prepare address for prediction update */
907 *dc_val_ptr = &dc_val[0];
912 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
916 INT16 *ac_val, *ac_val1;
918 /* find prediction */
919 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
923 /* left prediction */
926 block[block_permute_op(i*8)] += ac_val[i];
930 ac_val -= 16 * s->block_wrap[n];
932 block[block_permute_op(i)] += ac_val[i + 8];
938 ac_val1[i] = block[block_permute_op(i * 8)];
941 ac_val1[8 + i] = block[block_permute_op(i)];
944 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
950 /* find prediction */
951 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
954 /* left prediction */
957 block[block_permute_op(i*8)] -= ac_val[i];
961 ac_val -= 16 * s->block_wrap[n];
963 block[block_permute_op(i)] -= ac_val[i + 8];
969 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
972 /* find number of bits */
982 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
985 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
988 /* encode remaining bits */
991 level = (-level) ^ ((1 << size) - 1);
992 put_bits(&s->pb, size, level);
994 put_bits(&s->pb, 1, 1);
998 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1000 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1005 /* mpeg4 based DC predictor */
1006 mpeg4_encode_dc(s, intra_dc, n);
1015 last_index = s->block_last_index[n];
1016 last_non_zero = i - 1;
1017 for (; i <= last_index; i++) {
1021 run = i - last_non_zero - 1;
1022 last = (i == last_index);
1029 code = get_rl_index(rl, last, run, level);
1030 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1031 if (code == rl->n) {
1033 level1 = level - rl->max_level[last][run];
1036 code = get_rl_index(rl, last, run, level1);
1037 if (code == rl->n) {
1039 put_bits(&s->pb, 1, 1);
1040 if (level > MAX_LEVEL)
1042 run1 = run - rl->max_run[last][level] - 1;
1045 code = get_rl_index(rl, last, run1, level);
1046 if (code == rl->n) {
1049 put_bits(&s->pb, 1, 1);
1050 put_bits(&s->pb, 1, last);
1051 put_bits(&s->pb, 6, run);
1052 put_bits(&s->pb, 1, 1);
1053 put_bits(&s->pb, 12, slevel & 0xfff);
1054 put_bits(&s->pb, 1, 1);
1057 put_bits(&s->pb, 1, 0);
1058 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1059 put_bits(&s->pb, 1, sign);
1063 put_bits(&s->pb, 1, 0);
1064 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1065 put_bits(&s->pb, 1, sign);
1068 put_bits(&s->pb, 1, sign);
1077 /***********************************************/
1080 static VLC intra_MCBPC_vlc;
1081 static VLC inter_MCBPC_vlc;
1082 static VLC cbpy_vlc;
1084 static VLC dc_lum, dc_chrom;
1085 static VLC sprite_trajectory;
1086 static VLC mb_type_b_vlc;
1088 void init_rl(RLTable *rl)
1090 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1091 UINT8 index_run[MAX_RUN+1];
1092 int last, run, level, start, end, i;
1094 /* compute max_level[], max_run[] and index_run[] */
1095 for(last=0;last<2;last++) {
1104 memset(max_level, 0, MAX_RUN + 1);
1105 memset(max_run, 0, MAX_LEVEL + 1);
1106 memset(index_run, rl->n, MAX_RUN + 1);
1107 for(i=start;i<end;i++) {
1108 run = rl->table_run[i];
1109 level = rl->table_level[i];
1110 if (index_run[run] == rl->n)
1112 if (level > max_level[run])
1113 max_level[run] = level;
1114 if (run > max_run[level])
1115 max_run[level] = run;
1117 rl->max_level[last] = malloc(MAX_RUN + 1);
1118 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1119 rl->max_run[last] = malloc(MAX_LEVEL + 1);
1120 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1121 rl->index_run[last] = malloc(MAX_RUN + 1);
1122 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1126 void init_vlc_rl(RLTable *rl)
1128 init_vlc(&rl->vlc, 9, rl->n + 1,
1129 &rl->table_vlc[0][1], 4, 2,
1130 &rl->table_vlc[0][0], 4, 2);
1135 /* XXX: find a better solution to handle static init */
1136 void h263_decode_init_vlc(MpegEncContext *s)
1138 static int done = 0;
1143 init_vlc(&intra_MCBPC_vlc, 6, 8,
1144 intra_MCBPC_bits, 1, 1,
1145 intra_MCBPC_code, 1, 1);
1146 init_vlc(&inter_MCBPC_vlc, 9, 25,
1147 inter_MCBPC_bits, 1, 1,
1148 inter_MCBPC_code, 1, 1);
1149 init_vlc(&cbpy_vlc, 6, 16,
1150 &cbpy_tab[0][1], 2, 1,
1151 &cbpy_tab[0][0], 2, 1);
1152 init_vlc(&mv_vlc, 9, 33,
1154 &mvtab[0][0], 2, 1);
1157 init_rl(&rl_intra_aic);
1158 init_vlc_rl(&rl_inter);
1159 init_vlc_rl(&rl_intra);
1160 init_vlc_rl(&rl_intra_aic);
1161 init_vlc(&dc_lum, 9, 13,
1162 &DCtab_lum[0][1], 2, 1,
1163 &DCtab_lum[0][0], 2, 1);
1164 init_vlc(&dc_chrom, 9, 13,
1165 &DCtab_chrom[0][1], 2, 1,
1166 &DCtab_chrom[0][0], 2, 1);
1167 init_vlc(&sprite_trajectory, 9, 15,
1168 &sprite_trajectory_tab[0][1], 4, 2,
1169 &sprite_trajectory_tab[0][0], 4, 2);
1170 init_vlc(&mb_type_b_vlc, 4, 4,
1171 &mb_type_b_tab[0][1], 2, 1,
1172 &mb_type_b_tab[0][0], 2, 1);
1176 int h263_decode_gob_header(MpegEncContext *s)
1178 unsigned int val, gfid;
1180 /* Check for GOB Start Code */
1181 val = show_bits(&s->gb, 16);
1183 /* We have a GBSC probably with GSTUFF */
1184 skip_bits(&s->gb, 16); /* Drop the zeros */
1185 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1187 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1189 s->gob_number = get_bits(&s->gb, 5); /* GN */
1190 gfid = get_bits(&s->gb, 2); /* GFID */
1191 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1193 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1201 int h263_decode_mb(MpegEncContext *s,
1202 DCTELEM block[6][64])
1204 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1206 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1208 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1209 if (get_bits1(&s->gb)) {
1213 s->block_last_index[i] = -1;
1214 s->mv_dir = MV_DIR_FORWARD;
1215 s->mv_type = MV_TYPE_16X16;
1216 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1217 const int a= s->sprite_warping_accuracy;
1218 // int l = (1 << (s->f_code - 1)) * 32;
1221 s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1222 s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1223 /* if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1224 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1225 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1226 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1237 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1238 //fprintf(stderr, "\tCBPC: %d", cbpc);
1243 else if (cbpc == 20)
1244 fprintf(stderr, "Stuffing !");
1247 s->mb_intra = ((cbpc & 4) != 0);
1248 if (s->mb_intra) goto intra;
1250 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1251 s->mcsel= get_bits1(&s->gb);
1253 cbpy = get_vlc(&s->gb, &cbpy_vlc);
1254 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1256 s->qscale += quant_tab[get_bits(&s->gb, 2)];
1259 else if (s->qscale > 31)
1262 s->mv_dir = MV_DIR_FORWARD;
1263 if ((cbpc & 16) == 0) {
1264 /* 16x16 motion prediction */
1265 s->mv_type = MV_TYPE_16X16;
1266 h263_pred_motion(s, 0, &pred_x, &pred_y);
1268 mx = h263p_decode_umotion(s, pred_x);
1270 mx = h263_decode_motion(s, pred_x, s->f_code);
1272 const int a= s->sprite_warping_accuracy;
1273 // int l = (1 << (s->f_code - 1)) * 32;
1274 mx= RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1275 // if (mx < -l) mx= -l;
1276 // else if (mx >= l) mx= l-1;
1282 my = h263p_decode_umotion(s, pred_y);
1284 my = h263_decode_motion(s, pred_y, s->f_code);
1286 const int a= s->sprite_warping_accuracy;
1287 // int l = (1 << (s->f_code - 1)) * 32;
1288 my= RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1289 // if (my < -l) my= -l;
1290 // else if (my >= l) my= l-1;
1294 s->mv[0][0][0] = mx;
1295 s->mv[0][0][1] = my;
1296 /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1297 fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1298 fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1299 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1300 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1303 s->mv_type = MV_TYPE_8X8;
1305 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1307 mx = h263p_decode_umotion(s, pred_x);
1309 mx = h263_decode_motion(s, pred_x, s->f_code);
1314 my = h263p_decode_umotion(s, pred_y);
1316 my = h263_decode_motion(s, pred_y, s->f_code);
1319 s->mv[0][i][0] = mx;
1320 s->mv[0][i][1] = my;
1321 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1322 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1327 } else if(s->pict_type==B_TYPE) {
1328 int modb1; // first bit of modb
1329 int modb2; // second bit of modb
1335 s->mb_intra = 0; //B-frames never contain intra blocks
1336 s->mcsel=0; // ... true gmc blocks
1339 s->last_mv[0][0][0]=
1340 s->last_mv[0][0][1]=
1341 s->last_mv[1][0][0]=
1342 s->last_mv[1][0][1]= 0;
1345 /* if we skipped it in the future P Frame than skip it now too */
1346 s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
1351 s->block_last_index[i] = -1;
1353 s->mv_dir = MV_DIR_FORWARD;
1354 s->mv_type = MV_TYPE_16X16;
1359 s->last_mv[0][0][0]=
1360 s->last_mv[0][0][1]=
1361 s->last_mv[1][0][0]=
1362 s->last_mv[1][0][1]= 0;
1367 modb1= get_bits1(&s->gb);
1369 modb2= get_bits1(&s->gb);
1370 mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1371 if(modb2==0) cbp= get_bits(&s->gb, 6);
1373 if (mb_type && cbp) {
1374 if(get_bits1(&s->gb)){
1375 s->qscale +=get_bits1(&s->gb)*4 - 2;
1378 else if (s->qscale > 31)
1383 mb_type=4; //like 0 but no vectors coded
1386 s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
1387 mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1391 mx = h263_decode_motion(s, 0, 1);
1392 my = h263_decode_motion(s, 0, 1);
1394 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1395 xy= s->block_index[0];
1396 time_pp= s->last_non_b_time[0] - s->last_non_b_time[1];
1397 time_pb= s->time - s->last_non_b_time[1];
1398 //if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);
1400 //FIXME avoid divides
1401 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
1402 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
1403 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
1404 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
1405 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
1406 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
1410 s->mv[1][0][1] = 1000;*/
1413 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1414 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1415 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1416 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1417 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1419 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1420 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1421 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1422 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1425 s->mv_dir = MV_DIR_BACKWARD;
1426 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1427 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1428 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1429 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1432 s->mv_dir = MV_DIR_FORWARD;
1433 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1434 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1435 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1436 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1440 } else { /* I-Frame */
1441 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1448 if (s->h263_pred || s->h263_aic) {
1449 s->ac_pred = get_bits1(&s->gb);
1450 if (s->ac_pred && s->h263_aic)
1451 s->h263_aic_dir = get_bits1(&s->gb);
1454 s->y_dc_scale = 2 * s->qscale;
1455 s->c_dc_scale = 2 * s->qscale;
1457 cbpy = get_vlc(&s->gb, &cbpy_vlc);
1458 cbp = (cbpc & 3) | (cbpy << 2);
1460 s->qscale += quant_tab[get_bits(&s->gb, 2)];
1463 else if (s->qscale > 31)
1468 /* decode each block */
1470 for (i = 0; i < 6; i++) {
1471 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1475 for (i = 0; i < 6; i++) {
1476 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1483 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1485 int code, val, sign, shift, l, m;
1487 code = get_vlc(&s->gb, &mv_vlc);
1493 sign = get_bits1(&s->gb);
1495 val = (code - 1) << shift;
1497 val |= get_bits(&s->gb, shift);
1503 /* modulo decoding */
1504 if (!s->h263_long_vectors) {
1505 l = (1 << (f_code - 1)) * 32;
1509 } else if (val >= l) {
1513 /* horrible h263 long vector mode */
1514 if (pred < -31 && val < -63)
1516 if (pred > 32 && val > 63)
1523 /* Decodes RVLC of H.263+ UMV */
1524 static int h263p_decode_umotion(MpegEncContext * s, int pred)
1528 if (get_bits1(&s->gb)) /* Motion difference = 0 */
1531 code = 2 + get_bits1(&s->gb);
1533 while (get_bits1(&s->gb))
1536 code += get_bits1(&s->gb);
1541 code = (sign) ? (pred - code) : (pred + code);
1543 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
1549 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1552 int code, level, i, j, last, run;
1553 RLTable *rl = &rl_inter;
1554 const UINT8 *scan_table;
1556 scan_table = zigzag_direct;
1557 if (s->h263_aic && s->mb_intra) {
1561 if (s->h263_aic_dir)
1562 scan_table = ff_alternate_vertical_scan; /* left */
1564 scan_table = ff_alternate_horizontal_scan; /* top */
1566 } else if (s->mb_intra) {
1568 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1569 int component, diff;
1570 component = (n <= 3 ? 0 : n - 4 + 1);
1571 level = s->last_dc[component];
1572 if (s->rv10_first_dc_coded[component]) {
1573 diff = rv_decode_dc(s, n);
1577 level = level & 0xff; /* handle wrap round */
1578 s->last_dc[component] = level;
1580 s->rv10_first_dc_coded[component] = 1;
1583 level = get_bits(&s->gb, 8);
1593 if (s->mb_intra && s->h263_aic)
1595 s->block_last_index[n] = i - 1;
1600 code = get_vlc(&s->gb, &rl->vlc);
1603 if (code == rl->n) {
1605 last = get_bits1(&s->gb);
1606 run = get_bits(&s->gb, 6);
1607 level = (INT8)get_bits(&s->gb, 8);
1608 if (s->h263_rv10 && level == -128) {
1609 /* XXX: should patch encoder too */
1610 level = get_bits(&s->gb, 12);
1611 level = (level << 20) >> 20;
1614 run = rl->table_run[code];
1615 level = rl->table_level[code];
1616 last = code >= rl->last;
1617 if (get_bits1(&s->gb))
1630 if (s->mb_intra && s->h263_aic) {
1631 h263_pred_acdc(s, block, n);
1634 s->block_last_index[n] = i;
1638 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1640 int level, pred, code;
1644 code = get_vlc(&s->gb, &dc_lum);
1646 code = get_vlc(&s->gb, &dc_chrom);
1652 level = get_bits(&s->gb, code);
1653 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1654 level = - (level ^ ((1 << code) - 1));
1656 skip_bits1(&s->gb); /* marker */
1659 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1664 *dc_val = level * s->y_dc_scale;
1666 *dc_val = level * s->c_dc_scale;
1671 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1674 int code, level, i, j, last, run;
1677 const UINT8 *scan_table;
1681 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1690 if (dc_pred_dir == 0)
1691 scan_table = ff_alternate_vertical_scan; /* left */
1693 scan_table = ff_alternate_horizontal_scan; /* top */
1695 scan_table = zigzag_direct;
1700 s->block_last_index[n] = i - 1;
1704 scan_table = zigzag_direct;
1708 code = get_vlc(&s->gb, &rl->vlc);
1711 if (code == rl->n) {
1713 if (get_bits1(&s->gb) != 0) {
1714 if (get_bits1(&s->gb) != 0) {
1716 last = get_bits1(&s->gb);
1717 run = get_bits(&s->gb, 6);
1718 get_bits1(&s->gb); /* marker */
1719 level = get_bits(&s->gb, 12);
1720 level = (level << 20) >> 20; /* sign extend */
1721 skip_bits1(&s->gb); /* marker */
1724 code = get_vlc(&s->gb, &rl->vlc);
1725 if (code < 0 || code >= rl->n)
1727 run = rl->table_run[code];
1728 level = rl->table_level[code];
1729 last = code >= rl->last;
1730 run += rl->max_run[last][level] + 1;
1731 if (get_bits1(&s->gb))
1736 code = get_vlc(&s->gb, &rl->vlc);
1737 if (code < 0 || code >= rl->n)
1739 run = rl->table_run[code];
1740 level = rl->table_level[code];
1741 last = code >= rl->last;
1742 level += rl->max_level[last][run];
1743 if (get_bits1(&s->gb))
1747 run = rl->table_run[code];
1748 level = rl->table_level[code];
1749 last = code >= rl->last;
1750 if (get_bits1(&s->gb))
1764 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1766 i = 64; /* XXX: not optimal */
1769 s->block_last_index[n] = i - 1;
1773 /* most is hardcoded. should extend to handle all h263 streams */
1774 int h263_decode_picture_header(MpegEncContext *s)
1776 int format, width, height;
1778 /* picture header */
1779 if (get_bits(&s->gb, 22) != 0x20)
1781 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
1783 if (get_bits1(&s->gb) != 1)
1784 return -1; /* marker */
1785 if (get_bits1(&s->gb) != 0)
1786 return -1; /* h263 id */
1787 skip_bits1(&s->gb); /* split screen off */
1788 skip_bits1(&s->gb); /* camera off */
1789 skip_bits1(&s->gb); /* freeze picture release off */
1791 /* Reset GOB number */
1794 format = get_bits(&s->gb, 3);
1796 if (format != 7 && format != 6) {
1799 width = h263_format[format][0];
1800 height = h263_format[format][1];
1806 s->pict_type = I_TYPE + get_bits1(&s->gb);
1808 s->unrestricted_mv = get_bits1(&s->gb);
1809 s->h263_long_vectors = s->unrestricted_mv;
1811 if (get_bits1(&s->gb) != 0)
1812 return -1; /* SAC: off */
1813 if (get_bits1(&s->gb) != 0) {
1814 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1817 if (get_bits1(&s->gb) != 0)
1818 return -1; /* not PB frame */
1820 s->qscale = get_bits(&s->gb, 5);
1821 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1827 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1831 format = get_bits(&s->gb, 3);
1832 skip_bits(&s->gb,1); /* Custom PCF */
1833 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1834 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1835 if (get_bits1(&s->gb) != 0) {
1836 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1838 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
1841 skip_bits(&s->gb, 7);
1842 skip_bits(&s->gb, 3); /* Reserved */
1843 } else if (ufep != 0)
1847 s->pict_type = get_bits(&s->gb, 3) + 1;
1848 if (s->pict_type != I_TYPE &&
1849 s->pict_type != P_TYPE)
1851 skip_bits(&s->gb, 2);
1852 s->no_rounding = get_bits1(&s->gb);
1853 //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
1854 skip_bits(&s->gb, 4);
1856 /* Get the picture dimensions */
1859 /* Custom Picture Format (CPFMT) */
1860 skip_bits(&s->gb, 4); /* aspect ratio */
1861 width = (get_bits(&s->gb, 9) + 1) * 4;
1863 height = get_bits(&s->gb, 9) * 4;
1865 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1869 width = h263_format[format][0];
1870 height = h263_format[format][1];
1872 if ((width == 0) || (height == 0))
1876 if (s->umvplus_dec) {
1877 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1881 s->qscale = get_bits(&s->gb, 5);
1884 while (get_bits1(&s->gb) != 0) {
1885 skip_bits(&s->gb, 8);
1891 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
1894 int a= 2<<s->sprite_warping_accuracy;
1895 int rho= 3-s->sprite_warping_accuracy;
1897 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
1898 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
1899 int sprite_ref[4][2];
1900 int virtual_ref[2][2];
1902 int alpha=0, beta=0;
1905 //printf("SP %d\n", s->sprite_warping_accuracy);
1906 for(i=0; i<s->num_sprite_warping_points; i++){
1910 length= get_vlc(&s->gb, &sprite_trajectory);
1912 x= get_bits(&s->gb, length);
1913 //printf("lx %d %d\n", length, x);
1914 if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
1915 x = - (x ^ ((1 << length) - 1));
1917 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
1919 length= get_vlc(&s->gb, &sprite_trajectory);
1921 y=get_bits(&s->gb, length);
1922 //printf("ly %d %d\n", length, y);
1923 if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
1924 y = - (y ^ ((1 << length) - 1));
1926 skip_bits1(&s->gb); /* marker bit */
1927 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
1928 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
1934 while((1<<alpha)<w) alpha++;
1935 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
1939 // Note, the 4th point isnt used for GMC
1940 if(s->divx_version==500 && s->divx_build==413){
1941 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
1942 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
1943 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
1944 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
1945 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
1946 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
1948 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
1949 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
1950 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
1951 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
1952 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
1953 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
1955 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
1956 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
1958 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
1959 // perhaps it should be reordered to be more readable ...
1960 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
1961 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
1962 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
1963 + RDIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
1964 virtual_ref[0][1]= 16*vop_ref[0][1]
1965 + RDIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
1966 virtual_ref[1][0]= 16*vop_ref[0][0]
1967 + RDIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
1968 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
1969 + RDIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
1971 switch(s->num_sprite_warping_points)
1974 s->sprite_offset[0][0]= 0;
1975 s->sprite_offset[0][1]= 0;
1976 s->sprite_offset[1][0]= 0;
1977 s->sprite_offset[1][1]= 0;
1978 s->sprite_delta[0][0][0]= a;
1979 s->sprite_delta[0][0][1]= 0;
1980 s->sprite_delta[0][1][0]= 0;
1981 s->sprite_delta[0][1][1]= a;
1982 s->sprite_delta[1][0][0]= a;
1983 s->sprite_delta[1][0][1]= 0;
1984 s->sprite_delta[1][1][0]= 0;
1985 s->sprite_delta[1][1][1]= a;
1986 s->sprite_shift[0][0]= 0;
1987 s->sprite_shift[0][1]= 0;
1988 s->sprite_shift[1][0]= 0;
1989 s->sprite_shift[1][1]= 0;
1992 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
1993 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
1994 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
1995 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
1996 s->sprite_delta[0][0][0]= a;
1997 s->sprite_delta[0][0][1]= 0;
1998 s->sprite_delta[0][1][0]= 0;
1999 s->sprite_delta[0][1][1]= a;
2000 s->sprite_delta[1][0][0]= a;
2001 s->sprite_delta[1][0][1]= 0;
2002 s->sprite_delta[1][1][0]= 0;
2003 s->sprite_delta[1][1][1]= a;
2004 s->sprite_shift[0][0]= 0;
2005 s->sprite_shift[0][1]= 0;
2006 s->sprite_shift[1][0]= 0;
2007 s->sprite_shift[1][1]= 0;
2011 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2012 + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2013 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2014 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2015 + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2016 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2017 s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2018 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2019 +2*w2*r*sprite_ref[0][0] - 16*w2);
2020 s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
2021 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2022 +2*w2*r*sprite_ref[0][1] - 16*w2);
2023 s->sprite_delta[0][0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2024 s->sprite_delta[0][0][1]= ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2025 s->sprite_delta[0][1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2026 s->sprite_delta[0][1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2027 s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2028 s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2029 s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2030 s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2031 s->sprite_shift[0][0]= alpha+rho;
2032 s->sprite_shift[0][1]= alpha+rho;
2033 s->sprite_shift[1][0]= alpha+rho+2;
2034 s->sprite_shift[1][1]= alpha+rho+2;
2039 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2040 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2041 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2042 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2043 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2044 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2045 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2046 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2047 /* try to simplify the situation */
2048 if( s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2049 && s->sprite_delta[0][0][1] == 0
2050 && s->sprite_delta[0][1][0] == 0
2051 && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2052 && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2053 && s->sprite_delta[1][0][1] == 0
2054 && s->sprite_delta[1][1][0] == 0
2055 && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2057 s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2058 s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2059 s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2060 s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2061 s->sprite_delta[0][0][0]= a;
2062 s->sprite_delta[0][0][1]= 0;
2063 s->sprite_delta[0][1][0]= 0;
2064 s->sprite_delta[0][1][1]= a;
2065 s->sprite_delta[1][0][0]= a;
2066 s->sprite_delta[1][0][1]= 0;
2067 s->sprite_delta[1][1][0]= 0;
2068 s->sprite_delta[1][1][1]= a;
2069 s->sprite_shift[0][0]= 0;
2070 s->sprite_shift[0][1]= 0;
2071 s->sprite_shift[1][0]= 0;
2072 s->sprite_shift[1][1]= 0;
2073 s->real_sprite_warping_points=1;
2076 s->real_sprite_warping_points= s->num_sprite_warping_points;
2080 /* decode mpeg4 VOP header */
2081 int mpeg4_decode_picture_header(MpegEncContext * s)
2083 int time_incr, startcode, state, v;
2086 /* search next start code */
2087 align_get_bits(&s->gb);
2090 v = get_bits(&s->gb, 8);
2091 if (state == 0x000001) {
2092 state = ((state << 8) | v) & 0xffffff;
2096 state = ((state << 8) | v) & 0xffffff;
2097 /* XXX: really detect end of frame */
2099 printf("illegal zero code found\n");
2103 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2104 if (startcode == 0x120) { // Video Object Layer
2105 int width, height, vo_ver_id;
2108 skip_bits(&s->gb, 1); /* random access */
2109 skip_bits(&s->gb, 8); /* vo_type */
2110 if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2111 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2112 skip_bits(&s->gb, 3); /* vo_priority */
2117 s->aspect_ratio_info= get_bits(&s->gb, 4);
2118 if(s->aspect_ratio_info == EXTENDET_PAR){
2119 skip_bits(&s->gb, 8); //par_width
2120 skip_bits(&s->gb, 8); // par_height
2122 if(get_bits1(&s->gb)){ /* vol control parameter */
2123 printf("vol control parameter not supported\n");
2126 s->shape = get_bits(&s->gb, 2); /* vol shape */
2127 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2128 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2129 printf("Gray shape not supported\n");
2130 skip_bits(&s->gb, 4); //video_object_layer_shape_extension
2133 skip_bits1(&s->gb); /* marker */
2135 s->time_increment_resolution = get_bits(&s->gb, 16);
2136 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2137 if (s->time_increment_bits < 1)
2138 s->time_increment_bits = 1;
2139 skip_bits1(&s->gb); /* marker */
2141 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */
2142 skip_bits(&s->gb, s->time_increment_bits);
2145 if (s->shape != BIN_ONLY_SHAPE) {
2146 if (s->shape == RECT_SHAPE) {
2147 skip_bits1(&s->gb); /* marker */
2148 width = get_bits(&s->gb, 13);
2149 skip_bits1(&s->gb); /* marker */
2150 height = get_bits(&s->gb, 13);
2151 skip_bits1(&s->gb); /* marker */
2154 if(get_bits1(&s->gb)) printf("interlaced not supported\n"); /* interlaced */
2155 if(!get_bits1(&s->gb)) printf("OBMC not supported\n"); /* OBMC Disable */
2156 if (vo_ver_id == 1) {
2157 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2159 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2161 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2162 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2163 if(s->vol_sprite_usage==STATIC_SPRITE){
2164 s->sprite_width = get_bits(&s->gb, 13);
2165 skip_bits1(&s->gb); /* marker */
2166 s->sprite_height= get_bits(&s->gb, 13);
2167 skip_bits1(&s->gb); /* marker */
2168 s->sprite_left = get_bits(&s->gb, 13);
2169 skip_bits1(&s->gb); /* marker */
2170 s->sprite_top = get_bits(&s->gb, 13);
2171 skip_bits1(&s->gb); /* marker */
2173 s->num_sprite_warping_points= get_bits(&s->gb, 6);
2174 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2175 s->sprite_brightness_change= get_bits1(&s->gb);
2176 if(s->vol_sprite_usage==STATIC_SPRITE)
2177 s->low_latency_sprite= get_bits1(&s->gb);
2179 // FIXME sadct disable bit if verid!=1 && shape not rect
2181 if (get_bits1(&s->gb) == 1) { /* not_8_bit */
2182 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2183 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2185 s->quant_precision = 5;
2188 // FIXME a bunch of grayscale shape things
2189 if(get_bits1(&s->gb)) printf("Quant-Type not supported\n"); /* vol_quant_type */ //FIXME
2191 s->quarter_sample= get_bits1(&s->gb);
2192 else s->quarter_sample=0;
2194 if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
2196 if(get_bits1(&s->gb)) printf("resync disable\n");
2198 skip_bits1(&s->gb); /* resync_marker_disabled */
2200 s->data_partioning= get_bits1(&s->gb);
2201 if(s->data_partioning){
2202 printf("data partitioning not supported\n");
2203 skip_bits1(&s->gb); // reversible vlc
2206 if(vo_ver_id != 1) {
2207 s->new_pred= get_bits1(&s->gb);
2209 printf("new pred not supported\n");
2210 skip_bits(&s->gb, 2); /* requested upstream message type */
2211 skip_bits1(&s->gb); /* newpred segment type */
2213 s->reduced_res_vop= get_bits1(&s->gb);
2214 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2218 s->reduced_res_vop= 0;
2221 s->scalability= get_bits1(&s->gb);
2222 if (s->scalability) {
2223 printf("bad scalability!!!\n");
2227 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2229 } else if (startcode == 0x1b2) { //userdata
2235 //printf("user Data %X\n", show_bits(&s->gb, 32));
2236 buf[0]= show_bits(&s->gb, 8);
2237 for(i=1; i<256; i++){
2238 buf[i]= show_bits(&s->gb, 16)&0xFF;
2239 if(buf[i]==0) break;
2240 skip_bits(&s->gb, 8);
2243 e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2245 s->divx_version= ver;
2246 s->divx_build= build;
2247 if(s->picture_number==0){
2248 printf("This file was encoded with DivX%d Build%d\n", ver, build);
2249 if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
2250 printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2252 printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2253 "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2257 //printf("User Data: %s\n", buf);
2259 } else if (startcode != 0x1b6) { //VOP
2263 s->pict_type = get_bits(&s->gb, 2) + 1; /* pict type: I = 0 , P = 1 */
2264 //printf("pic: %d\n", s->pict_type);
2266 while (get_bits1(&s->gb) != 0)
2269 check_marker(&s->gb, "before time_increment");
2270 s->time_increment= get_bits(&s->gb, s->time_increment_bits);
2271 if(s->pict_type!=B_TYPE){
2272 s->time_base+= time_incr;
2273 s->last_non_b_time[1]= s->last_non_b_time[0];
2274 s->last_non_b_time[0]= s->time_base*s->time_increment_resolution + s->time_increment;
2276 s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
2277 s->time+= s->time_increment;
2280 if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2281 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2282 for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2283 if(get_bits1(&s->gb)) break;
2285 printf("my guess is %d bits ;)\n",s->time_increment_bits);
2288 if (get_bits1(&s->gb) != 1)
2290 //printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2291 //s->time, s->last_non_b_time[0], s->last_non_b_time[1]);
2292 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2293 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2294 /* rounding type for motion estimation */
2295 s->no_rounding = get_bits1(&s->gb);
2299 //FIXME reduced res stuff
2301 if (s->shape != RECT_SHAPE) {
2302 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2303 int width, height, hor_spat_ref, ver_spat_ref;
2305 width = get_bits(&s->gb, 13);
2306 skip_bits1(&s->gb); /* marker */
2307 height = get_bits(&s->gb, 13);
2308 skip_bits1(&s->gb); /* marker */
2309 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2310 skip_bits1(&s->gb); /* marker */
2311 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
2313 skip_bits1(&s->gb); /* change_CR_disable */
2315 if (get_bits1(&s->gb) != 0) {
2316 skip_bits(&s->gb, 8); /* constant_alpha_value */
2319 //FIXME complexity estimation stuff
2321 if (s->shape != BIN_ONLY_SHAPE) {
2322 skip_bits(&s->gb, 3); /* intra dc VLC threshold */
2323 //FIXME interlaced specific bits
2326 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
2327 if(s->num_sprite_warping_points){
2328 mpeg4_decode_sprite_trajectory(s);
2330 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
2331 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
2334 if (s->shape != BIN_ONLY_SHAPE) {
2335 /* note: we do not use quant_precision to avoid problem if no
2336 MPEG4 vol header as it is found on some old opendivx
2338 s->qscale = get_bits(&s->gb, 5);
2340 printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
2341 return -1; // makes no sense to continue, as there is nothing left from the image then
2344 if (s->pict_type != I_TYPE) {
2345 s->f_code = get_bits(&s->gb, 3); /* fcode_for */
2347 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
2348 return -1; // makes no sense to continue, as the MV decoding will break very quickly
2351 if (s->pict_type == B_TYPE) {
2352 s->b_code = get_bits(&s->gb, 3);
2353 //printf("b-code %d\n", s->b_code);
2355 //printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
2356 if(!s->scalability){
2357 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
2358 skip_bits1(&s->gb); // vop shape coding type
2362 s->picture_number++; // better than pic number==0 allways ;)
2366 /* don't understand why they choose a different header ! */
2367 int intel_h263_decode_picture_header(MpegEncContext *s)
2371 /* picture header */
2372 if (get_bits(&s->gb, 22) != 0x20)
2374 skip_bits(&s->gb, 8); /* picture timestamp */
2376 if (get_bits1(&s->gb) != 1)
2377 return -1; /* marker */
2378 if (get_bits1(&s->gb) != 0)
2379 return -1; /* h263 id */
2380 skip_bits1(&s->gb); /* split screen off */
2381 skip_bits1(&s->gb); /* camera off */
2382 skip_bits1(&s->gb); /* freeze picture release off */
2384 format = get_bits(&s->gb, 3);
2390 s->pict_type = I_TYPE + get_bits1(&s->gb);
2392 s->unrestricted_mv = get_bits1(&s->gb);
2393 s->h263_long_vectors = s->unrestricted_mv;
2395 if (get_bits1(&s->gb) != 0)
2396 return -1; /* SAC: off */
2397 if (get_bits1(&s->gb) != 0)
2398 return -1; /* advanced prediction mode: off */
2399 if (get_bits1(&s->gb) != 0)
2400 return -1; /* not PB frame */
2402 /* skip unknown header garbage */
2403 skip_bits(&s->gb, 41);
2405 s->qscale = get_bits(&s->gb, 5);
2406 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
2409 while (get_bits1(&s->gb) != 0) {
2410 skip_bits(&s->gb, 8);