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))
32 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
34 static void h263_encode_motion(MpegEncContext * s, int val);
35 static void h263p_encode_umotion(MpegEncContext * s, int val);
36 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
38 static int h263_decode_motion(MpegEncContext * s, int pred);
39 static int h263p_decode_umotion(MpegEncContext * s, int pred);
40 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
42 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
45 int h263_get_picture_format(int width, int height)
49 if (width == 128 && height == 96)
51 else if (width == 176 && height == 144)
53 else if (width == 352 && height == 288)
55 else if (width == 704 && height == 576)
57 else if (width == 1408 && height == 1152)
64 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
68 align_put_bits(&s->pb);
70 /* Update the pointer to last GOB */
71 s->ptr_lastgob = pbBufPtr(&s->pb);
74 put_bits(&s->pb, 22, 0x20); /* PSC */
75 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
76 s->frame_rate) & 0xff);
78 put_bits(&s->pb, 1, 1); /* marker */
79 put_bits(&s->pb, 1, 0); /* h263 id */
80 put_bits(&s->pb, 1, 0); /* split screen off */
81 put_bits(&s->pb, 1, 0); /* camera off */
82 put_bits(&s->pb, 1, 0); /* freeze picture release off */
84 format = h263_get_picture_format(s->width, s->height);
87 put_bits(&s->pb, 3, format);
88 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
89 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
90 of H.263v1 UMV implies to check the predicted MV after
91 calculation of the current MB to see if we're on the limits */
92 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
93 put_bits(&s->pb, 1, 0); /* SAC: off */
94 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
95 put_bits(&s->pb, 1, 0); /* not PB frame */
96 put_bits(&s->pb, 5, s->qscale);
97 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
100 /* H.263 Plus PTYPE */
101 put_bits(&s->pb, 3, 7);
102 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
104 put_bits(&s->pb,3,6); /* Custom Source Format */
106 put_bits(&s->pb, 3, format);
108 put_bits(&s->pb,1,0); /* Custom PCF: off */
109 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
110 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
111 put_bits(&s->pb,1,0); /* SAC: off */
112 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
113 put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
114 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
115 put_bits(&s->pb,1,0); /* Slice Structured: off */
116 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
117 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
118 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
119 put_bits(&s->pb,1,0); /* Modified Quantization: off */
120 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
121 put_bits(&s->pb,3,0); /* Reserved */
123 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
125 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
126 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
127 put_bits(&s->pb,1,0); /* Rounding Type */
128 put_bits(&s->pb,2,0); /* Reserved */
129 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
131 /* This should be here if PLUSPTYPE */
132 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
135 /* Custom Picture Format (CPFMT) */
137 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
138 put_bits(&s->pb,9,(s->width >> 2) - 1);
139 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
140 put_bits(&s->pb,9,(s->height >> 2));
143 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
145 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
146 put_bits(&s->pb, 5, s->qscale);
149 put_bits(&s->pb, 1, 0); /* no PEI */
152 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
156 /* Check to see if we need to put a new GBSC */
157 /* for RTP packetization */
159 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
160 if (pdif >= s->rtp_payload_size) {
161 /* Bad luck, packet must be cut before */
162 align_put_bits(&s->pb);
163 flush_put_bits(&s->pb);
164 /* Call the RTP callback to send the last GOB */
165 if (s->rtp_callback) {
166 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
167 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
169 s->ptr_lastgob = pbBufPtr(&s->pb);
170 put_bits(&s->pb, 17, 1); /* GBSC */
171 s->gob_number = mb_line / s->gob_index;
172 put_bits(&s->pb, 5, s->gob_number); /* GN */
173 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
174 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
175 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
177 } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
178 /* Cut the packet before we can't */
179 align_put_bits(&s->pb);
180 flush_put_bits(&s->pb);
181 /* Call the RTP callback to send the last GOB */
182 if (s->rtp_callback) {
183 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
184 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
186 s->ptr_lastgob = pbBufPtr(&s->pb);
187 put_bits(&s->pb, 17, 1); /* GBSC */
188 s->gob_number = mb_line / s->gob_index;
189 put_bits(&s->pb, 5, s->gob_number); /* GN */
190 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
191 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
192 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
199 void h263_encode_mb(MpegEncContext * s,
200 DCTELEM block[6][64],
201 int motion_x, int motion_y)
203 int cbpc, cbpy, i, cbp, pred_x, pred_y;
205 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
209 for (i = 0; i < 6; i++) {
210 if (s->block_last_index[i] >= 0)
213 if ((cbp | motion_x | motion_y) == 0) {
214 /* skip macroblock */
215 put_bits(&s->pb, 1, 1);
218 put_bits(&s->pb, 1, 0); /* mb coded */
221 inter_MCBPC_bits[cbpc],
222 inter_MCBPC_code[cbpc]);
225 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
227 /* motion vectors: 16x16 mode only now */
228 h263_pred_motion(s, 0, &pred_x, &pred_y);
231 h263_encode_motion(s, motion_x - pred_x);
232 h263_encode_motion(s, motion_y - pred_y);
235 h263p_encode_umotion(s, motion_x - pred_x);
236 h263p_encode_umotion(s, motion_y - pred_y);
237 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
238 /* To prevent Start Code emulation */
239 put_bits(&s->pb,1,1);
244 for (i = 0; i < 6; i++) {
245 if (s->block_last_index[i] >= 1)
250 if (s->pict_type == I_TYPE) {
252 intra_MCBPC_bits[cbpc],
253 intra_MCBPC_code[cbpc]);
255 put_bits(&s->pb, 1, 0); /* mb coded */
257 inter_MCBPC_bits[cbpc + 4],
258 inter_MCBPC_code[cbpc + 4]);
261 /* XXX: currently, we do not try to use ac prediction */
262 put_bits(&s->pb, 1, 0); /* no ac prediction */
265 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
268 /* encode each block */
270 for (i = 0; i < 6; i++) {
271 mpeg4_encode_block(s, block[i], i);
274 for (i = 0; i < 6; i++) {
275 h263_encode_block(s, block[i], i);
281 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
283 int x, y, wrap, a, c, pred_dc, scale, i;
284 INT16 *dc_val, *ac_val, *ac_val1;
286 /* find prediction */
288 x = 2 * s->mb_x + 1 + (n & 1);
289 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
290 wrap = s->mb_width * 2 + 2;
291 dc_val = s->dc_val[0];
292 ac_val = s->ac_val[0][0];
293 scale = s->y_dc_scale;
297 wrap = s->mb_width + 2;
298 dc_val = s->dc_val[n - 4 + 1];
299 ac_val = s->ac_val[n - 4 + 1][0];
300 scale = s->c_dc_scale;
303 ac_val += ((y) * wrap + (x)) * 16;
309 a = dc_val[(x - 1) + (y) * wrap];
310 c = dc_val[(x) + (y - 1) * wrap];
314 if (s->h263_aic_dir) {
315 /* left prediction */
319 block[block_permute_op(i*8)] += ac_val[i];
328 block[block_permute_op(i)] += ac_val[i + 8];
334 /* just DC prediction */
335 if (a != 1024 && c != 1024)
336 pred_dc = (a + c) >> 1;
343 /* we assume pred is positive */
344 block[0]=block[0]*scale + pred_dc;
348 else if (!(block[0] & 1))
351 /* Update AC/DC tables */
352 dc_val[(x) + (y) * wrap] = block[0];
356 ac_val1[i] = block[block_permute_op(i * 8)];
359 ac_val1[8 + i] = block[block_permute_op(i)];
363 static inline int mid_pred(int a, int b, int c)
377 return a + b + c - vmin - vmax;
380 INT16 *h263_pred_motion(MpegEncContext * s, int block,
384 INT16 *A, *B, *C, *mot_val;
386 wrap = 2 * s->mb_width + 2;
387 y = xy = 2 * s->mb_y + 1 + ((block >> 1) & 1); // y
388 xy *= wrap; // y * wrap
389 xy += 2 * s->mb_x + 1 + (block & 1); // x + y * wrap
391 mot_val = s->motion_val[xy];
393 /* special case for first line */
394 if (y == 1 || s->first_slice_line || s->first_gob_line) {
395 A = s->motion_val[xy - 1];
402 A = s->motion_val[xy - 1];
403 B = s->motion_val[xy - wrap];
404 C = s->motion_val[xy + 2 - wrap];
408 A = s->motion_val[xy - 1];
409 B = s->motion_val[xy - wrap];
410 C = s->motion_val[xy + 1 - wrap];
413 A = s->motion_val[xy - 1];
414 B = s->motion_val[xy - 1 - wrap];
415 C = s->motion_val[xy - wrap];
418 *px = mid_pred(A[0], B[0], C[0]);
419 *py = mid_pred(A[1], B[1], C[1]);
425 static void h263_encode_motion(MpegEncContext * s, int val)
427 int range, l, m, bit_size, sign, code, bits;
432 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
434 bit_size = s->f_code - 1;
435 range = 1 << bit_size;
436 /* modulo encoding */
441 } else if (val >= l) {
447 code = (val >> bit_size) + 1;
448 bits = val & (range - 1);
453 code = (val >> bit_size) + 1;
454 bits = val & (range - 1);
458 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
460 put_bits(&s->pb, bit_size, bits);
465 /* Encode MV differences on H.263+ with Unrestricted MV mode */
466 static void h263p_encode_umotion(MpegEncContext * s, int val)
476 put_bits(&s->pb, 1, 1);
478 put_bits(&s->pb, 3, 0);
480 put_bits(&s->pb, 3, 2);
483 sval = ((val < 0) ? (short)(-val):(short)val);
486 while (temp_val != 0) {
487 temp_val = temp_val >> 1;
493 tcode = (sval & (1 << (i-1))) >> (i-1);
494 tcode = (tcode << 1) | 1;
495 code = (code << 2) | tcode;
498 code = ((code << 1) | (val < 0)) << 1;
499 put_bits(&s->pb, (2*n_bits)+1, code);
500 //printf("\nVal = %d\tCode = %d", sval, code);
504 void h263_encode_init_vlc(MpegEncContext *s)
515 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
517 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
519 RLTable *rl = &rl_inter;
524 /* 255 cannot be represented, so we clamp */
529 /* 0 cannot be represented also */
535 put_bits(&s->pb, 8, 0xff);
537 put_bits(&s->pb, 8, level & 0xff);
544 last_index = s->block_last_index[n];
545 last_non_zero = i - 1;
546 for (; i <= last_index; i++) {
547 j = zigzag_direct[i];
550 run = i - last_non_zero - 1;
551 last = (i == last_index);
558 code = get_rl_index(rl, last, run, level);
559 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
561 put_bits(&s->pb, 1, last);
562 put_bits(&s->pb, 6, run);
563 put_bits(&s->pb, 8, slevel & 0xff);
565 put_bits(&s->pb, 1, sign);
572 /***************************************************/
574 /* write mpeg4 VOP header */
575 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
577 align_put_bits(&s->pb);
579 put_bits(&s->pb, 16, 0); /* vop header */
580 put_bits(&s->pb, 16, 0x1B6); /* vop header */
581 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
582 /* XXX: time base + 1 not always correct */
583 put_bits(&s->pb, 1, 1);
584 put_bits(&s->pb, 1, 0);
586 put_bits(&s->pb, 1, 1); /* marker */
587 put_bits(&s->pb, 4, 1); /* XXX: correct time increment */
588 put_bits(&s->pb, 1, 1); /* marker */
589 put_bits(&s->pb, 1, 1); /* vop coded */
590 if (s->pict_type == P_TYPE) {
592 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
594 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
596 put_bits(&s->pb, 5, s->qscale);
598 if (s->pict_type != I_TYPE)
599 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
600 // printf("****frame %d\n", picture_number);
603 void h263_dc_scale(MpegEncContext * s)
611 else if (quant > 4 && quant < 9)
612 s->y_dc_scale = (2 * quant);
613 else if (quant > 8 && quant < 25)
614 s->y_dc_scale = (quant + 8);
616 s->y_dc_scale = (2 * quant - 16);
620 else if (quant > 4 && quant < 25)
621 s->c_dc_scale = ((quant + 13) / 2);
623 s->c_dc_scale = (quant - 6);
626 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
628 int a, b, c, xy, wrap, pred, scale;
631 /* find prediction */
633 wrap = s->mb_width * 2 + 2;
634 xy = 2 * s->mb_y + 1 + ((n & 2) >> 1);
636 xy += 2 * s->mb_x + 1 + (n & 1);
637 dc_val = s->dc_val[0];
638 scale = s->y_dc_scale;
640 wrap = s->mb_width + 2;
644 dc_val = s->dc_val[n - 4 + 1];
645 scale = s->c_dc_scale;
652 b = dc_val[xy - 1 - wrap];
653 c = dc_val[xy - wrap];
655 if (abs(a - b) < abs(b - c)) {
657 *dir_ptr = 1; /* top */
660 *dir_ptr = 0; /* left */
662 /* we assume pred is positive */
663 pred = (pred + (scale >> 1)) / scale;
665 /* prepare address for prediction update */
666 *dc_val_ptr = &dc_val[xy];
671 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
675 INT16 *ac_val, *ac_val1;
677 /* find prediction */
679 x = 2 * s->mb_x + 1 + (n & 1);
680 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
681 wrap = s->mb_width * 2 + 2;
682 ac_val = s->ac_val[0][0];
686 wrap = s->mb_width + 2;
687 ac_val = s->ac_val[n - 4 + 1][0];
689 ac_val += ((y) * wrap + (x)) * 16;
693 /* left prediction */
696 block[block_permute_op(i*8)] += ac_val[i];
702 block[block_permute_op(i)] += ac_val[i + 8];
708 ac_val1[i] = block[block_permute_op(i * 8)];
711 ac_val1[8 + i] = block[block_permute_op(i)];
714 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
719 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
721 *dc_val = level * s->y_dc_scale;
723 *dc_val = level * s->c_dc_scale;
726 /* do the prediction */
728 /* find number of bits */
738 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
741 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
744 /* encode remaining bits */
747 level = (-level) ^ ((1 << size) - 1);
748 put_bits(&s->pb, size, level);
750 put_bits(&s->pb, 1, 1);
754 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
756 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
757 int code, dc_pred_dir;
761 /* mpeg4 based DC predictor */
762 mpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
771 last_index = s->block_last_index[n];
772 last_non_zero = i - 1;
773 for (; i <= last_index; i++) {
774 j = zigzag_direct[i];
777 run = i - last_non_zero - 1;
778 last = (i == last_index);
785 code = get_rl_index(rl, last, run, level);
786 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
789 level1 = level - rl->max_level[last][run];
792 code = get_rl_index(rl, last, run, level1);
795 put_bits(&s->pb, 1, 1);
796 if (level > MAX_LEVEL)
798 run1 = run - rl->max_run[last][level] - 1;
801 code = get_rl_index(rl, last, run1, level);
805 put_bits(&s->pb, 1, 1);
806 put_bits(&s->pb, 1, last);
807 put_bits(&s->pb, 6, run);
808 put_bits(&s->pb, 1, 1);
809 put_bits(&s->pb, 12, slevel & 0xfff);
810 put_bits(&s->pb, 1, 1);
813 put_bits(&s->pb, 1, 0);
814 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
815 put_bits(&s->pb, 1, sign);
819 put_bits(&s->pb, 1, 0);
820 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
821 put_bits(&s->pb, 1, sign);
824 put_bits(&s->pb, 1, sign);
833 /***********************************************/
836 static VLC intra_MCBPC_vlc;
837 static VLC inter_MCBPC_vlc;
840 static VLC dc_lum, dc_chrom;
841 static VLC sprite_trajectory;
843 void init_rl(RLTable *rl)
845 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
846 UINT8 index_run[MAX_RUN+1];
847 int last, run, level, start, end, i;
849 /* compute max_level[], max_run[] and index_run[] */
850 for(last=0;last<2;last++) {
859 memset(max_level, 0, MAX_RUN + 1);
860 memset(max_run, 0, MAX_LEVEL + 1);
861 memset(index_run, rl->n, MAX_RUN + 1);
862 for(i=start;i<end;i++) {
863 run = rl->table_run[i];
864 level = rl->table_level[i];
865 if (index_run[run] == rl->n)
867 if (level > max_level[run])
868 max_level[run] = level;
869 if (run > max_run[level])
870 max_run[level] = run;
872 rl->max_level[last] = malloc(MAX_RUN + 1);
873 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
874 rl->max_run[last] = malloc(MAX_LEVEL + 1);
875 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
876 rl->index_run[last] = malloc(MAX_RUN + 1);
877 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
881 void init_vlc_rl(RLTable *rl)
883 init_vlc(&rl->vlc, 9, rl->n + 1,
884 &rl->table_vlc[0][1], 4, 2,
885 &rl->table_vlc[0][0], 4, 2);
890 /* XXX: find a better solution to handle static init */
891 void h263_decode_init_vlc(MpegEncContext *s)
898 init_vlc(&intra_MCBPC_vlc, 6, 8,
899 intra_MCBPC_bits, 1, 1,
900 intra_MCBPC_code, 1, 1);
901 init_vlc(&inter_MCBPC_vlc, 9, 25,
902 inter_MCBPC_bits, 1, 1,
903 inter_MCBPC_code, 1, 1);
904 init_vlc(&cbpy_vlc, 6, 16,
905 &cbpy_tab[0][1], 2, 1,
906 &cbpy_tab[0][0], 2, 1);
907 init_vlc(&mv_vlc, 9, 33,
912 init_rl(&rl_intra_aic);
913 init_vlc_rl(&rl_inter);
914 init_vlc_rl(&rl_intra);
915 init_vlc_rl(&rl_intra_aic);
916 init_vlc(&dc_lum, 9, 13,
917 &DCtab_lum[0][1], 2, 1,
918 &DCtab_lum[0][0], 2, 1);
919 init_vlc(&dc_chrom, 9, 13,
920 &DCtab_chrom[0][1], 2, 1,
921 &DCtab_chrom[0][0], 2, 1);
922 init_vlc(&sprite_trajectory, 9, 15,
923 &sprite_trajectory_tab[0][1], 4, 2,
924 &sprite_trajectory_tab[0][0], 4, 2);
928 int h263_decode_gob_header(MpegEncContext *s)
930 unsigned int val, gfid;
932 /* Check for GOB Start Code */
933 val = show_bits(&s->gb, 16);
935 /* We have a GBSC probably with GSTUFF */
936 skip_bits(&s->gb, 16); /* Drop the zeros */
937 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
939 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
941 s->gob_number = get_bits(&s->gb, 5); /* GN */
942 gfid = get_bits(&s->gb, 2); /* GFID */
943 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
945 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
953 int h263_decode_mb(MpegEncContext *s,
954 DCTELEM block[6][64])
956 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
958 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
960 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
961 if (get_bits1(&s->gb)) {
965 s->block_last_index[i] = -1;
966 s->mv_dir = MV_DIR_FORWARD;
967 s->mv_type = MV_TYPE_16X16;
968 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
969 const int a= s->sprite_warping_accuracy;
970 // int l = (1 << (s->f_code - 1)) * 32;
973 s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
974 s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
975 /* if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
976 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
977 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
978 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
989 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
990 //fprintf(stderr, "\tCBPC: %d", cbpc);
996 fprintf(stderr, "Stuffing !");
999 s->mb_intra = ((cbpc & 4) != 0);
1001 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1009 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1010 s->mcsel= get_bits1(&s->gb);
1012 cbpy = get_vlc(&s->gb, &cbpy_vlc);
1013 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1015 s->qscale += quant_tab[get_bits(&s->gb, 2)];
1018 else if (s->qscale > 31)
1021 s->mv_dir = MV_DIR_FORWARD;
1022 if ((cbpc & 16) == 0) {
1023 /* 16x16 motion prediction */
1024 s->mv_type = MV_TYPE_16X16;
1025 h263_pred_motion(s, 0, &pred_x, &pred_y);
1027 mx = h263p_decode_umotion(s, pred_x);
1029 mx = h263_decode_motion(s, pred_x);
1031 const int a= s->sprite_warping_accuracy;
1032 // int l = (1 << (s->f_code - 1)) * 32;
1033 mx= RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1034 // if (mx < -l) mx= -l;
1035 // else if (mx >= l) mx= l-1;
1041 my = h263p_decode_umotion(s, pred_y);
1043 my = h263_decode_motion(s, pred_y);
1045 const int a= s->sprite_warping_accuracy;
1046 // int l = (1 << (s->f_code - 1)) * 32;
1047 my= RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1048 // if (my < -l) my= -l;
1049 // else if (my >= l) my= l-1;
1053 s->mv[0][0][0] = mx;
1054 s->mv[0][0][1] = my;
1055 /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1056 fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1057 fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1058 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1059 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1062 s->mv_type = MV_TYPE_8X8;
1064 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1066 mx = h263p_decode_umotion(s, pred_x);
1068 mx = h263_decode_motion(s, pred_x);
1073 my = h263p_decode_umotion(s, pred_y);
1075 my = h263_decode_motion(s, pred_y);
1078 s->mv[0][i][0] = mx;
1079 s->mv[0][i][1] = my;
1080 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1081 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1088 if (s->h263_pred || s->h263_aic) {
1089 s->ac_pred = get_bits1(&s->gb);
1090 if (s->ac_pred && s->h263_aic)
1091 s->h263_aic_dir = get_bits1(&s->gb);
1094 s->y_dc_scale = 2 * s->qscale;
1095 s->c_dc_scale = 2 * s->qscale;
1097 cbpy = get_vlc(&s->gb, &cbpy_vlc);
1098 cbp = (cbpc & 3) | (cbpy << 2);
1100 s->qscale += quant_tab[get_bits(&s->gb, 2)];
1103 else if (s->qscale > 31)
1108 /* decode each block */
1110 for (i = 0; i < 6; i++) {
1111 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1115 for (i = 0; i < 6; i++) {
1116 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1123 static int h263_decode_motion(MpegEncContext * s, int pred)
1125 int code, val, sign, shift, l, m;
1127 code = get_vlc(&s->gb, &mv_vlc);
1133 sign = get_bits1(&s->gb);
1134 shift = s->f_code - 1;
1135 val = (code - 1) << shift;
1137 val |= get_bits(&s->gb, shift);
1143 /* modulo decoding */
1144 if (!s->h263_long_vectors) {
1145 l = (1 << (s->f_code - 1)) * 32;
1149 } else if (val >= l) {
1153 /* horrible h263 long vector mode */
1154 if (pred < -31 && val < -63)
1156 if (pred > 32 && val > 63)
1163 /* Decodes RVLC of H.263+ UMV */
1164 static int h263p_decode_umotion(MpegEncContext * s, int pred)
1168 if (get_bits1(&s->gb)) /* Motion difference = 0 */
1171 code = 2 + get_bits1(&s->gb);
1173 while (get_bits1(&s->gb))
1176 code += get_bits1(&s->gb);
1181 code = (sign) ? (pred - code) : (pred + code);
1183 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
1189 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1192 int code, level, i, j, last, run;
1193 RLTable *rl = &rl_inter;
1194 const UINT8 *scan_table;
1196 scan_table = zigzag_direct;
1197 if (s->h263_aic && s->mb_intra) {
1201 if (s->h263_aic_dir)
1202 scan_table = ff_alternate_vertical_scan; /* left */
1204 scan_table = ff_alternate_horizontal_scan; /* top */
1206 } else if (s->mb_intra) {
1208 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1209 int component, diff;
1210 component = (n <= 3 ? 0 : n - 4 + 1);
1211 level = s->last_dc[component];
1212 if (s->rv10_first_dc_coded[component]) {
1213 diff = rv_decode_dc(s, n);
1217 level = level & 0xff; /* handle wrap round */
1218 s->last_dc[component] = level;
1220 s->rv10_first_dc_coded[component] = 1;
1223 level = get_bits(&s->gb, 8);
1233 if (s->mb_intra && s->h263_aic)
1235 s->block_last_index[n] = i - 1;
1240 code = get_vlc(&s->gb, &rl->vlc);
1243 if (code == rl->n) {
1245 last = get_bits1(&s->gb);
1246 run = get_bits(&s->gb, 6);
1247 level = (INT8)get_bits(&s->gb, 8);
1248 if (s->h263_rv10 && level == -128) {
1249 /* XXX: should patch encoder too */
1250 level = get_bits(&s->gb, 12);
1251 level = (level << 20) >> 20;
1254 run = rl->table_run[code];
1255 level = rl->table_level[code];
1256 last = code >= rl->last;
1257 if (get_bits1(&s->gb))
1270 if (s->mb_intra && s->h263_aic) {
1271 h263_pred_acdc(s, block, n);
1274 s->block_last_index[n] = i;
1278 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1280 int level, pred, code;
1284 code = get_vlc(&s->gb, &dc_lum);
1286 code = get_vlc(&s->gb, &dc_chrom);
1292 level = get_bits(&s->gb, code);
1293 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1294 level = - (level ^ ((1 << code) - 1));
1296 skip_bits1(&s->gb); /* marker */
1299 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1304 *dc_val = level * s->y_dc_scale;
1306 *dc_val = level * s->c_dc_scale;
1311 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1314 int code, level, i, j, last, run;
1317 const UINT8 *scan_table;
1321 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1330 if (dc_pred_dir == 0)
1331 scan_table = ff_alternate_vertical_scan; /* left */
1333 scan_table = ff_alternate_horizontal_scan; /* top */
1335 scan_table = zigzag_direct;
1340 s->block_last_index[n] = i - 1;
1344 scan_table = zigzag_direct;
1348 code = get_vlc(&s->gb, &rl->vlc);
1351 if (code == rl->n) {
1353 if (get_bits1(&s->gb) != 0) {
1354 if (get_bits1(&s->gb) != 0) {
1356 last = get_bits1(&s->gb);
1357 run = get_bits(&s->gb, 6);
1358 get_bits1(&s->gb); /* marker */
1359 level = get_bits(&s->gb, 12);
1360 level = (level << 20) >> 20; /* sign extend */
1361 skip_bits1(&s->gb); /* marker */
1364 code = get_vlc(&s->gb, &rl->vlc);
1365 if (code < 0 || code >= rl->n)
1367 run = rl->table_run[code];
1368 level = rl->table_level[code];
1369 last = code >= rl->last;
1370 run += rl->max_run[last][level] + 1;
1371 if (get_bits1(&s->gb))
1376 code = get_vlc(&s->gb, &rl->vlc);
1377 if (code < 0 || code >= rl->n)
1379 run = rl->table_run[code];
1380 level = rl->table_level[code];
1381 last = code >= rl->last;
1382 level += rl->max_level[last][run];
1383 if (get_bits1(&s->gb))
1387 run = rl->table_run[code];
1388 level = rl->table_level[code];
1389 last = code >= rl->last;
1390 if (get_bits1(&s->gb))
1404 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1406 i = 64; /* XXX: not optimal */
1409 s->block_last_index[n] = i - 1;
1413 /* most is hardcoded. should extend to handle all h263 streams */
1414 int h263_decode_picture_header(MpegEncContext *s)
1416 int format, width, height;
1418 /* picture header */
1419 if (get_bits(&s->gb, 22) != 0x20)
1421 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
1423 if (get_bits1(&s->gb) != 1)
1424 return -1; /* marker */
1425 if (get_bits1(&s->gb) != 0)
1426 return -1; /* h263 id */
1427 skip_bits1(&s->gb); /* split screen off */
1428 skip_bits1(&s->gb); /* camera off */
1429 skip_bits1(&s->gb); /* freeze picture release off */
1431 /* Reset GOB number */
1434 format = get_bits(&s->gb, 3);
1436 if (format != 7 && format != 6) {
1439 width = h263_format[format][0];
1440 height = h263_format[format][1];
1446 s->pict_type = I_TYPE + get_bits1(&s->gb);
1448 s->unrestricted_mv = get_bits1(&s->gb);
1449 s->h263_long_vectors = s->unrestricted_mv;
1451 if (get_bits1(&s->gb) != 0)
1452 return -1; /* SAC: off */
1453 if (get_bits1(&s->gb) != 0) {
1454 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1457 if (get_bits1(&s->gb) != 0)
1458 return -1; /* not PB frame */
1460 s->qscale = get_bits(&s->gb, 5);
1461 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1467 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1471 format = get_bits(&s->gb, 3);
1472 skip_bits(&s->gb,1); /* Custom PCF */
1473 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1474 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1475 if (get_bits1(&s->gb) != 0) {
1476 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1478 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
1481 skip_bits(&s->gb, 7);
1482 skip_bits(&s->gb, 3); /* Reserved */
1483 } else if (ufep != 0)
1487 s->pict_type = get_bits(&s->gb, 3) + 1;
1488 if (s->pict_type != I_TYPE &&
1489 s->pict_type != P_TYPE)
1491 skip_bits(&s->gb, 2);
1492 s->no_rounding = get_bits1(&s->gb);
1493 //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
1494 skip_bits(&s->gb, 4);
1496 /* Get the picture dimensions */
1499 /* Custom Picture Format (CPFMT) */
1500 skip_bits(&s->gb, 4); /* aspect ratio */
1501 width = (get_bits(&s->gb, 9) + 1) * 4;
1503 height = get_bits(&s->gb, 9) * 4;
1505 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1509 width = h263_format[format][0];
1510 height = h263_format[format][1];
1512 if ((width == 0) || (height == 0))
1516 if (s->umvplus_dec) {
1517 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1521 s->qscale = get_bits(&s->gb, 5);
1524 while (get_bits1(&s->gb) != 0) {
1525 skip_bits(&s->gb, 8);
1531 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
1534 int a= 2<<s->sprite_warping_accuracy;
1535 int rho= 3-s->sprite_warping_accuracy;
1537 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
1538 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
1539 int sprite_ref[4][2];
1540 int virtual_ref[2][2];
1542 int alpha=0, beta=0;
1545 //printf("SP %d\n", s->sprite_warping_accuracy);
1546 for(i=0; i<s->num_sprite_warping_points; i++){
1550 length= get_vlc(&s->gb, &sprite_trajectory);
1552 x= get_bits(&s->gb, length);
1553 //printf("lx %d %d\n", length, x);
1554 if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
1555 x = - (x ^ ((1 << length) - 1));
1557 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
1559 length= get_vlc(&s->gb, &sprite_trajectory);
1561 y=get_bits(&s->gb, length);
1562 //printf("ly %d %d\n", length, y);
1563 if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
1564 y = - (y ^ ((1 << length) - 1));
1566 skip_bits1(&s->gb); /* marker bit */
1567 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
1568 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
1574 while((1<<alpha)<w) alpha++;
1575 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
1579 // Note, the 4th point isnt used for GMC
1581 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
1582 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
1583 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
1584 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
1585 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
1586 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
1588 //FIXME DIVX5 vs. mpeg4 ?
1589 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
1590 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
1591 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
1592 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
1593 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
1594 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
1595 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
1596 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
1598 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
1599 // perhaps it should be reordered to be more readable ...
1600 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
1601 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
1602 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
1603 + 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);
1604 virtual_ref[0][1]= 16*vop_ref[0][1]
1605 + 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);
1606 virtual_ref[1][0]= 16*vop_ref[0][0]
1607 + 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);
1608 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
1609 + 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);
1611 switch(s->num_sprite_warping_points)
1614 s->sprite_offset[0][0]= 0;
1615 s->sprite_offset[0][1]= 0;
1616 s->sprite_offset[1][0]= 0;
1617 s->sprite_offset[1][1]= 0;
1618 s->sprite_delta[0][0][0]= a;
1619 s->sprite_delta[0][0][1]= 0;
1620 s->sprite_delta[0][1][0]= 0;
1621 s->sprite_delta[0][1][1]= a;
1622 s->sprite_delta[1][0][0]= a;
1623 s->sprite_delta[1][0][1]= 0;
1624 s->sprite_delta[1][1][0]= 0;
1625 s->sprite_delta[1][1][1]= a;
1626 s->sprite_shift[0][0]= 0;
1627 s->sprite_shift[0][1]= 0;
1628 s->sprite_shift[1][0]= 0;
1629 s->sprite_shift[1][1]= 0;
1632 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
1633 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
1634 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
1635 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
1636 s->sprite_delta[0][0][0]= a;
1637 s->sprite_delta[0][0][1]= 0;
1638 s->sprite_delta[0][1][0]= 0;
1639 s->sprite_delta[0][1][1]= a;
1640 s->sprite_delta[1][0][0]= a;
1641 s->sprite_delta[1][0][1]= 0;
1642 s->sprite_delta[1][1][0]= 0;
1643 s->sprite_delta[1][1][1]= a;
1644 s->sprite_shift[0][0]= 0;
1645 s->sprite_shift[0][1]= 0;
1646 s->sprite_shift[1][0]= 0;
1647 s->sprite_shift[1][1]= 0;
1651 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
1652 + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
1653 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
1654 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
1655 + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
1656 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
1657 s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
1658 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
1659 +2*w2*r*sprite_ref[0][0] - 16*w2);
1660 s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
1661 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
1662 +2*w2*r*sprite_ref[0][1] - 16*w2);
1663 s->sprite_delta[0][0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
1664 s->sprite_delta[0][0][1]= ( r*sprite_ref[0][1] - virtual_ref[0][1]);
1665 s->sprite_delta[0][1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
1666 s->sprite_delta[0][1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
1667 s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
1668 s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
1669 s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
1670 s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
1671 s->sprite_shift[0][0]= alpha+rho;
1672 s->sprite_shift[0][1]= alpha+rho;
1673 s->sprite_shift[1][0]= alpha+rho+2;
1674 s->sprite_shift[1][1]= alpha+rho+2;
1679 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
1680 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
1681 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
1682 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
1683 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
1684 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
1685 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
1686 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
1687 /* try to simplify the situation */
1688 if( s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
1689 && s->sprite_delta[0][0][1] == 0
1690 && s->sprite_delta[0][1][0] == 0
1691 && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
1692 && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
1693 && s->sprite_delta[1][0][1] == 0
1694 && s->sprite_delta[1][1][0] == 0
1695 && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
1697 s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
1698 s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
1699 s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
1700 s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
1701 s->sprite_delta[0][0][0]= a;
1702 s->sprite_delta[0][0][1]= 0;
1703 s->sprite_delta[0][1][0]= 0;
1704 s->sprite_delta[0][1][1]= a;
1705 s->sprite_delta[1][0][0]= a;
1706 s->sprite_delta[1][0][1]= 0;
1707 s->sprite_delta[1][1][0]= 0;
1708 s->sprite_delta[1][1][1]= a;
1709 s->sprite_shift[0][0]= 0;
1710 s->sprite_shift[0][1]= 0;
1711 s->sprite_shift[1][0]= 0;
1712 s->sprite_shift[1][1]= 0;
1713 s->real_sprite_warping_points=1;
1716 s->real_sprite_warping_points= s->num_sprite_warping_points;
1718 //FIXME convert stuff if accurace != 3
1721 /* decode mpeg4 VOP header */
1722 int mpeg4_decode_picture_header(MpegEncContext * s)
1724 int time_incr, startcode, state, v;
1727 /* search next start code */
1728 align_get_bits(&s->gb);
1731 v = get_bits(&s->gb, 8);
1732 if (state == 0x000001) {
1733 state = ((state << 8) | v) & 0xffffff;
1737 state = ((state << 8) | v) & 0xffffff;
1738 /* XXX: really detect end of frame */
1742 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
1743 if (startcode == 0x120) { // Video Object Layer
1744 int time_increment_resolution, width, height, vo_ver_id;
1747 skip_bits(&s->gb, 1); /* random access */
1748 skip_bits(&s->gb, 8); /* vo_type */
1749 if (get_bits1(&s->gb) != 0) { /* is_ol_id */
1750 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
1751 skip_bits(&s->gb, 3); /* vo_priority */
1756 s->aspect_ratio_info= get_bits(&s->gb, 4);
1757 if(s->aspect_ratio_info == EXTENDET_PAR){
1758 skip_bits(&s->gb, 8); //par_width
1759 skip_bits(&s->gb, 8); // par_height
1761 if(get_bits1(&s->gb)){ /* vol control parameter */
1762 printf("vol control parameter not supported\n");
1765 s->shape = get_bits(&s->gb, 2); /* vol shape */
1766 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
1767 printf("Gray shape not supported\n");
1768 skip_bits(&s->gb, 4); //video_object_layer_shape_extension
1771 skip_bits1(&s->gb); /* marker */
1773 time_increment_resolution = get_bits(&s->gb, 16);
1774 s->time_increment_bits = av_log2(time_increment_resolution - 1) + 1;
1775 if (s->time_increment_bits < 1)
1776 s->time_increment_bits = 1;
1777 skip_bits1(&s->gb); /* marker */
1779 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */
1780 skip_bits(&s->gb, s->time_increment_bits);
1783 if (s->shape != BIN_ONLY_SHAPE) {
1784 if (s->shape == RECT_SHAPE) {
1785 skip_bits1(&s->gb); /* marker */
1786 width = get_bits(&s->gb, 13);
1787 skip_bits1(&s->gb); /* marker */
1788 height = get_bits(&s->gb, 13);
1789 skip_bits1(&s->gb); /* marker */
1792 skip_bits1(&s->gb); /* interlaced */
1793 if(!get_bits1(&s->gb)) printf("OBMC not supported\n"); /* OBMC Disable */
1794 if (vo_ver_id == 1) {
1795 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
1797 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
1799 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
1800 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
1801 if(s->vol_sprite_usage==STATIC_SPRITE){
1802 s->sprite_width = get_bits(&s->gb, 13);
1803 skip_bits1(&s->gb); /* marker */
1804 s->sprite_height= get_bits(&s->gb, 13);
1805 skip_bits1(&s->gb); /* marker */
1806 s->sprite_left = get_bits(&s->gb, 13);
1807 skip_bits1(&s->gb); /* marker */
1808 s->sprite_top = get_bits(&s->gb, 13);
1809 skip_bits1(&s->gb); /* marker */
1811 s->num_sprite_warping_points= get_bits(&s->gb, 6);
1812 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
1813 s->sprite_brightness_change= get_bits1(&s->gb);
1814 if(s->vol_sprite_usage==STATIC_SPRITE)
1815 s->low_latency_sprite= get_bits1(&s->gb);
1817 // FIXME sadct disable bit if verid!=1 && shape not rect
1819 if (get_bits1(&s->gb) == 1) { /* not_8_bit */
1820 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
1821 skip_bits(&s->gb, 4); /* bits_per_pixel */
1823 s->quant_precision = 5;
1826 // FIXME a bunch of grayscale shape things
1827 if(get_bits1(&s->gb)) printf("Quant-Type not supported\n"); /* vol_quant_type */ //FIXME
1829 s->quarter_sample= get_bits1(&s->gb);
1830 else s->quarter_sample=0;
1832 if(get_bits1(&s->gb)) printf("Complexity est disabled\n");
1833 if(get_bits1(&s->gb)) printf("resync disable\n");
1835 skip_bits1(&s->gb); /* complexity_estimation_disabled */
1836 skip_bits1(&s->gb); /* resync_marker_disabled */
1838 s->data_partioning= get_bits1(&s->gb);
1839 if(s->data_partioning){
1840 printf("data partitioning not supported\n");
1841 skip_bits1(&s->gb); // reversible vlc
1844 if(vo_ver_id != 1) {
1845 s->new_pred= get_bits1(&s->gb);
1847 printf("new pred not supported\n");
1848 skip_bits(&s->gb, 2); /* requested upstream message type */
1849 skip_bits1(&s->gb); /* newpred segment type */
1851 s->reduced_res_vop= get_bits1(&s->gb);
1852 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
1856 s->reduced_res_vop= 0;
1859 s->scalability= get_bits1(&s->gb);
1860 if (s->scalability) {
1861 printf("bad scalability!!!\n");
1865 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
1867 } else if (startcode == 0x1b2) { //userdata
1873 //printf("user Data %X\n", show_bits(&s->gb, 32));
1874 buf[0]= show_bits(&s->gb, 8);
1875 for(i=1; i<256; i++){
1876 buf[i]= show_bits(&s->gb, 16)&0xFF;
1877 if(buf[i]==0) break;
1878 skip_bits(&s->gb, 8);
1881 e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
1883 s->divx_version= ver;
1884 s->divx_build= build;
1885 if(s->picture_number==0){
1886 printf("This file was encoded with DivX%d Build%d\n", ver, build);
1887 if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
1888 printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
1890 printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
1891 "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
1895 //printf("User Data: %s\n", buf);
1897 } else if (startcode != 0x1b6) { //VOP
1901 s->pict_type = get_bits(&s->gb, 2) + 1; /* pict type: I = 0 , P = 1 */
1902 if(s->pict_type == B_TYPE)
1908 /* XXX: parse time base */
1910 while (get_bits1(&s->gb) != 0)
1913 skip_bits1(&s->gb); /* marker */
1914 skip_bits(&s->gb, s->time_increment_bits);
1915 skip_bits1(&s->gb); /* marker */
1917 if (get_bits1(&s->gb) != 1)
1920 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
1921 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
1922 /* rounding type for motion estimation */
1923 s->no_rounding = get_bits1(&s->gb);
1927 //FIXME reduced res stuff
1929 if (s->shape != RECT_SHAPE) {
1930 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
1931 int width, height, hor_spat_ref, ver_spat_ref;
1933 width = get_bits(&s->gb, 13);
1934 skip_bits1(&s->gb); /* marker */
1935 height = get_bits(&s->gb, 13);
1936 skip_bits1(&s->gb); /* marker */
1937 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
1938 skip_bits1(&s->gb); /* marker */
1939 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
1941 skip_bits1(&s->gb); /* change_CR_disable */
1943 if (get_bits1(&s->gb) != 0) {
1944 skip_bits(&s->gb, 8); /* constant_alpha_value */
1947 //FIXME complexity estimation stuff
1949 if (s->shape != BIN_ONLY_SHAPE) {
1950 skip_bits(&s->gb, 3); /* intra dc VLC threshold */
1951 //FIXME interlaced specific bits
1954 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
1955 if(s->num_sprite_warping_points){
1956 mpeg4_decode_sprite_trajectory(s);
1958 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
1959 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
1962 if (s->shape != BIN_ONLY_SHAPE) {
1963 /* note: we do not use quant_precision to avoid problem if no
1964 MPEG4 vol header as it is found on some old opendivx
1966 s->qscale = get_bits(&s->gb, 5);
1968 if (s->pict_type != I_TYPE) {
1969 s->f_code = get_bits(&s->gb, 3); /* fcode_for */
1971 if (s->pict_type == B_TYPE) {
1972 s->b_code = get_bits(&s->gb, 3);
1974 //printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
1975 if(!s->scalability){
1976 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
1977 skip_bits1(&s->gb); // vop shape coding type
1981 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
1982 s->picture_number++; // better than pic number==0 allways ;)
1986 /* don't understand why they choose a different header ! */
1987 int intel_h263_decode_picture_header(MpegEncContext *s)
1991 /* picture header */
1992 if (get_bits(&s->gb, 22) != 0x20)
1994 skip_bits(&s->gb, 8); /* picture timestamp */
1996 if (get_bits1(&s->gb) != 1)
1997 return -1; /* marker */
1998 if (get_bits1(&s->gb) != 0)
1999 return -1; /* h263 id */
2000 skip_bits1(&s->gb); /* split screen off */
2001 skip_bits1(&s->gb); /* camera off */
2002 skip_bits1(&s->gb); /* freeze picture release off */
2004 format = get_bits(&s->gb, 3);
2010 s->pict_type = I_TYPE + get_bits1(&s->gb);
2012 s->unrestricted_mv = get_bits1(&s->gb);
2013 s->h263_long_vectors = s->unrestricted_mv;
2015 if (get_bits1(&s->gb) != 0)
2016 return -1; /* SAC: off */
2017 if (get_bits1(&s->gb) != 0)
2018 return -1; /* advanced prediction mode: off */
2019 if (get_bits1(&s->gb) != 0)
2020 return -1; /* not PB frame */
2022 /* skip unknown header garbage */
2023 skip_bits(&s->gb, 41);
2025 s->qscale = get_bits(&s->gb, 5);
2026 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
2029 while (get_bits1(&s->gb) != 0) {
2030 skip_bits(&s->gb, 8);