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 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
30 static void h263_encode_motion(MpegEncContext * s, int val);
31 static void h263p_encode_umotion(MpegEncContext * s, int val);
32 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
34 static int h263_decode_motion(MpegEncContext * s, int pred);
35 static int h263p_decode_umotion(MpegEncContext * s, int pred);
36 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
38 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
41 int h263_get_picture_format(int width, int height)
45 if (width == 128 && height == 96)
47 else if (width == 176 && height == 144)
49 else if (width == 352 && height == 288)
51 else if (width == 704 && height == 576)
53 else if (width == 1408 && height == 1152)
60 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
64 align_put_bits(&s->pb);
66 /* Update the pointer to last GOB */
67 s->ptr_lastgob = pbBufPtr(&s->pb);
70 put_bits(&s->pb, 22, 0x20); /* PSC */
71 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
72 s->frame_rate) & 0xff);
74 put_bits(&s->pb, 1, 1); /* marker */
75 put_bits(&s->pb, 1, 0); /* h263 id */
76 put_bits(&s->pb, 1, 0); /* split screen off */
77 put_bits(&s->pb, 1, 0); /* camera off */
78 put_bits(&s->pb, 1, 0); /* freeze picture release off */
80 format = h263_get_picture_format(s->width, s->height);
83 put_bits(&s->pb, 3, format);
84 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
85 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
86 of H.263v1 UMV implies to check the predicted MV after
87 calculation of the current MB to see if we're on the limits */
88 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
89 put_bits(&s->pb, 1, 0); /* SAC: off */
90 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
91 put_bits(&s->pb, 1, 0); /* not PB frame */
92 put_bits(&s->pb, 5, s->qscale);
93 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
96 /* H.263 Plus PTYPE */
97 put_bits(&s->pb, 3, 7);
98 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
100 put_bits(&s->pb,3,6); /* Custom Source Format */
102 put_bits(&s->pb, 3, format);
104 put_bits(&s->pb,1,0); /* Custom PCF: off */
105 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
106 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
107 put_bits(&s->pb,1,0); /* SAC: off */
108 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
109 put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
110 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
111 put_bits(&s->pb,1,0); /* Slice Structured: off */
112 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
113 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
114 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
115 put_bits(&s->pb,1,0); /* Modified Quantization: off */
116 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
117 put_bits(&s->pb,3,0); /* Reserved */
119 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
121 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
122 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
123 put_bits(&s->pb,1,0); /* Rounding Type */
124 put_bits(&s->pb,2,0); /* Reserved */
125 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
127 /* This should be here if PLUSPTYPE */
128 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
131 /* Custom Picture Format (CPFMT) */
133 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
134 put_bits(&s->pb,9,(s->width >> 2) - 1);
135 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
136 put_bits(&s->pb,9,(s->height >> 2));
139 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
141 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
142 put_bits(&s->pb, 5, s->qscale);
145 put_bits(&s->pb, 1, 0); /* no PEI */
148 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
152 /* Check to see if we need to put a new GBSC */
153 /* for RTP packetization */
155 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
156 if (pdif >= s->rtp_payload_size) {
157 /* Bad luck, packet must be cut before */
158 align_put_bits(&s->pb);
159 flush_put_bits(&s->pb);
160 /* Call the RTP callback to send the last GOB */
161 if (s->rtp_callback) {
162 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
163 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
165 s->ptr_lastgob = pbBufPtr(&s->pb);
166 put_bits(&s->pb, 17, 1); /* GBSC */
167 s->gob_number = mb_line / s->gob_index;
168 put_bits(&s->pb, 5, s->gob_number); /* GN */
169 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
170 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
171 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
173 } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
174 /* Cut the packet before we can't */
175 align_put_bits(&s->pb);
176 flush_put_bits(&s->pb);
177 /* Call the RTP callback to send the last GOB */
178 if (s->rtp_callback) {
179 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
180 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
182 s->ptr_lastgob = pbBufPtr(&s->pb);
183 put_bits(&s->pb, 17, 1); /* GBSC */
184 s->gob_number = mb_line / s->gob_index;
185 put_bits(&s->pb, 5, s->gob_number); /* GN */
186 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
187 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
188 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
195 void h263_encode_mb(MpegEncContext * s,
196 DCTELEM block[6][64],
197 int motion_x, int motion_y)
199 int cbpc, cbpy, i, cbp, pred_x, pred_y;
201 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
205 for (i = 0; i < 6; i++) {
206 if (s->block_last_index[i] >= 0)
209 if ((cbp | motion_x | motion_y) == 0) {
210 /* skip macroblock */
211 put_bits(&s->pb, 1, 1);
214 put_bits(&s->pb, 1, 0); /* mb coded */
217 inter_MCBPC_bits[cbpc],
218 inter_MCBPC_code[cbpc]);
221 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
223 /* motion vectors: 16x16 mode only now */
224 h263_pred_motion(s, 0, &pred_x, &pred_y);
227 h263_encode_motion(s, motion_x - pred_x);
228 h263_encode_motion(s, motion_y - pred_y);
231 h263p_encode_umotion(s, motion_x - pred_x);
232 h263p_encode_umotion(s, motion_y - pred_y);
233 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
234 /* To prevent Start Code emulation */
235 put_bits(&s->pb,1,1);
240 for (i = 0; i < 6; i++) {
241 if (s->block_last_index[i] >= 1)
246 if (s->pict_type == I_TYPE) {
248 intra_MCBPC_bits[cbpc],
249 intra_MCBPC_code[cbpc]);
251 put_bits(&s->pb, 1, 0); /* mb coded */
253 inter_MCBPC_bits[cbpc + 4],
254 inter_MCBPC_code[cbpc + 4]);
257 /* XXX: currently, we do not try to use ac prediction */
258 put_bits(&s->pb, 1, 0); /* no ac prediction */
261 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
264 /* encode each block */
266 for (i = 0; i < 6; i++) {
267 mpeg4_encode_block(s, block[i], i);
270 for (i = 0; i < 6; i++) {
271 h263_encode_block(s, block[i], i);
277 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
279 int x, y, wrap, a, c, pred_dc, scale, i;
280 INT16 *dc_val, *ac_val, *ac_val1;
282 /* find prediction */
284 x = 2 * s->mb_x + 1 + (n & 1);
285 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
286 wrap = s->mb_width * 2 + 2;
287 dc_val = s->dc_val[0];
288 ac_val = s->ac_val[0][0];
289 scale = s->y_dc_scale;
293 wrap = s->mb_width + 2;
294 dc_val = s->dc_val[n - 4 + 1];
295 ac_val = s->ac_val[n - 4 + 1][0];
296 scale = s->c_dc_scale;
299 ac_val += ((y) * wrap + (x)) * 16;
305 a = dc_val[(x - 1) + (y) * wrap];
306 c = dc_val[(x) + (y - 1) * wrap];
310 if (s->h263_aic_dir) {
311 /* left prediction */
315 block[block_permute_op(i*8)] += ac_val[i];
324 block[block_permute_op(i)] += ac_val[i + 8];
330 /* just DC prediction */
331 if (a != 1024 && c != 1024)
332 pred_dc = (a + c) >> 1;
339 /* we assume pred is positive */
340 block[0]=block[0]*scale + pred_dc;
344 else if (!(block[0] & 1))
347 /* Update AC/DC tables */
348 dc_val[(x) + (y) * wrap] = block[0];
352 ac_val1[i] = block[block_permute_op(i * 8)];
355 ac_val1[8 + i] = block[block_permute_op(i)];
359 static inline int mid_pred(int a, int b, int c)
373 return a + b + c - vmin - vmax;
376 INT16 *h263_pred_motion(MpegEncContext * s, int block,
380 INT16 *A, *B, *C, *mot_val;
382 wrap = 2 * s->mb_width + 2;
383 y = xy = 2 * s->mb_y + 1 + ((block >> 1) & 1); // y
384 xy *= wrap; // y * wrap
385 xy += 2 * s->mb_x + 1 + (block & 1); // x + y * wrap
387 mot_val = s->motion_val[xy];
389 /* special case for first line */
390 if (y == 1 || s->first_slice_line || s->first_gob_line) {
391 A = s->motion_val[xy - 1];
398 A = s->motion_val[xy - 1];
399 B = s->motion_val[xy - wrap];
400 C = s->motion_val[xy + 2 - wrap];
404 A = s->motion_val[xy - 1];
405 B = s->motion_val[xy - wrap];
406 C = s->motion_val[xy + 1 - wrap];
409 A = s->motion_val[xy - 1];
410 B = s->motion_val[xy - 1 - wrap];
411 C = s->motion_val[xy - wrap];
414 *px = mid_pred(A[0], B[0], C[0]);
415 *py = mid_pred(A[1], B[1], C[1]);
421 static void h263_encode_motion(MpegEncContext * s, int val)
423 int range, l, m, bit_size, sign, code, bits;
428 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
430 bit_size = s->f_code - 1;
431 range = 1 << bit_size;
432 /* modulo encoding */
437 } else if (val >= l) {
443 code = (val >> bit_size) + 1;
444 bits = val & (range - 1);
449 code = (val >> bit_size) + 1;
450 bits = val & (range - 1);
454 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
456 put_bits(&s->pb, bit_size, bits);
461 /* Encode MV differences on H.263+ with Unrestricted MV mode */
462 static void h263p_encode_umotion(MpegEncContext * s, int val)
472 put_bits(&s->pb, 1, 1);
474 put_bits(&s->pb, 3, 0);
476 put_bits(&s->pb, 3, 2);
479 sval = ((val < 0) ? (short)(-val):(short)val);
482 while (temp_val != 0) {
483 temp_val = temp_val >> 1;
489 tcode = (sval & (1 << (i-1))) >> (i-1);
490 tcode = (tcode << 1) | 1;
491 code = (code << 2) | tcode;
494 code = ((code << 1) | (val < 0)) << 1;
495 put_bits(&s->pb, (2*n_bits)+1, code);
496 //printf("\nVal = %d\tCode = %d", sval, code);
500 void h263_encode_init_vlc(MpegEncContext *s)
511 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
513 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
515 RLTable *rl = &rl_inter;
520 /* 255 cannot be represented, so we clamp */
525 /* 0 cannot be represented also */
531 put_bits(&s->pb, 8, 0xff);
533 put_bits(&s->pb, 8, level & 0xff);
540 last_index = s->block_last_index[n];
541 last_non_zero = i - 1;
542 for (; i <= last_index; i++) {
543 j = zigzag_direct[i];
546 run = i - last_non_zero - 1;
547 last = (i == last_index);
554 code = get_rl_index(rl, last, run, level);
555 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
557 put_bits(&s->pb, 1, last);
558 put_bits(&s->pb, 6, run);
559 put_bits(&s->pb, 8, slevel & 0xff);
561 put_bits(&s->pb, 1, sign);
568 /***************************************************/
570 /* write mpeg4 VOP header */
571 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
573 align_put_bits(&s->pb);
575 put_bits(&s->pb, 16, 0); /* vop header */
576 put_bits(&s->pb, 16, 0x1B6); /* vop header */
577 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
578 /* XXX: time base + 1 not always correct */
579 put_bits(&s->pb, 1, 1);
580 put_bits(&s->pb, 1, 0);
582 put_bits(&s->pb, 1, 1); /* marker */
583 put_bits(&s->pb, 4, 1); /* XXX: correct time increment */
584 put_bits(&s->pb, 1, 1); /* marker */
585 put_bits(&s->pb, 1, 1); /* vop coded */
586 if (s->pict_type == P_TYPE) {
588 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
590 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
592 put_bits(&s->pb, 5, s->qscale);
594 if (s->pict_type != I_TYPE)
595 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
596 // printf("****frame %d\n", picture_number);
599 void h263_dc_scale(MpegEncContext * s)
607 else if (quant > 4 && quant < 9)
608 s->y_dc_scale = (2 * quant);
609 else if (quant > 8 && quant < 25)
610 s->y_dc_scale = (quant + 8);
612 s->y_dc_scale = (2 * quant - 16);
616 else if (quant > 4 && quant < 25)
617 s->c_dc_scale = ((quant + 13) / 2);
619 s->c_dc_scale = (quant - 6);
622 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
624 int a, b, c, xy, wrap, pred, scale;
627 /* find prediction */
629 wrap = s->mb_width * 2 + 2;
630 xy = 2 * s->mb_y + 1 + ((n & 2) >> 1);
632 xy += 2 * s->mb_x + 1 + (n & 1);
633 dc_val = s->dc_val[0];
634 scale = s->y_dc_scale;
636 wrap = s->mb_width + 2;
640 dc_val = s->dc_val[n - 4 + 1];
641 scale = s->c_dc_scale;
648 b = dc_val[xy - 1 - wrap];
649 c = dc_val[xy - wrap];
651 if (abs(a - b) < abs(b - c)) {
653 *dir_ptr = 1; /* top */
656 *dir_ptr = 0; /* left */
658 /* we assume pred is positive */
659 pred = (pred + (scale >> 1)) / scale;
661 /* prepare address for prediction update */
662 *dc_val_ptr = &dc_val[xy];
667 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
671 INT16 *ac_val, *ac_val1;
673 /* find prediction */
675 x = 2 * s->mb_x + 1 + (n & 1);
676 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
677 wrap = s->mb_width * 2 + 2;
678 ac_val = s->ac_val[0][0];
682 wrap = s->mb_width + 2;
683 ac_val = s->ac_val[n - 4 + 1][0];
685 ac_val += ((y) * wrap + (x)) * 16;
689 /* left prediction */
692 block[block_permute_op(i*8)] += ac_val[i];
698 block[block_permute_op(i)] += ac_val[i + 8];
704 ac_val1[i] = block[block_permute_op(i * 8)];
707 ac_val1[8 + i] = block[block_permute_op(i)];
710 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
715 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
717 *dc_val = level * s->y_dc_scale;
719 *dc_val = level * s->c_dc_scale;
722 /* do the prediction */
724 /* find number of bits */
734 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
737 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
740 /* encode remaining bits */
743 level = (-level) ^ ((1 << size) - 1);
744 put_bits(&s->pb, size, level);
746 put_bits(&s->pb, 1, 1);
750 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
752 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
753 int code, dc_pred_dir;
757 /* mpeg4 based DC predictor */
758 mpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
767 last_index = s->block_last_index[n];
768 last_non_zero = i - 1;
769 for (; i <= last_index; i++) {
770 j = zigzag_direct[i];
773 run = i - last_non_zero - 1;
774 last = (i == last_index);
781 code = get_rl_index(rl, last, run, level);
782 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
785 level1 = level - rl->max_level[last][run];
788 code = get_rl_index(rl, last, run, level1);
791 put_bits(&s->pb, 1, 1);
792 if (level > MAX_LEVEL)
794 run1 = run - rl->max_run[last][level] - 1;
797 code = get_rl_index(rl, last, run1, level);
801 put_bits(&s->pb, 1, 1);
802 put_bits(&s->pb, 1, last);
803 put_bits(&s->pb, 6, run);
804 put_bits(&s->pb, 1, 1);
805 put_bits(&s->pb, 12, slevel & 0xfff);
806 put_bits(&s->pb, 1, 1);
809 put_bits(&s->pb, 1, 0);
810 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
811 put_bits(&s->pb, 1, sign);
815 put_bits(&s->pb, 1, 0);
816 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
817 put_bits(&s->pb, 1, sign);
820 put_bits(&s->pb, 1, sign);
829 /***********************************************/
832 static VLC intra_MCBPC_vlc;
833 static VLC inter_MCBPC_vlc;
836 static VLC dc_lum, dc_chrom;
838 void init_rl(RLTable *rl)
840 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
841 UINT8 index_run[MAX_RUN+1];
842 int last, run, level, start, end, i;
844 /* compute max_level[], max_run[] and index_run[] */
845 for(last=0;last<2;last++) {
854 memset(max_level, 0, MAX_RUN + 1);
855 memset(max_run, 0, MAX_LEVEL + 1);
856 memset(index_run, rl->n, MAX_RUN + 1);
857 for(i=start;i<end;i++) {
858 run = rl->table_run[i];
859 level = rl->table_level[i];
860 if (index_run[run] == rl->n)
862 if (level > max_level[run])
863 max_level[run] = level;
864 if (run > max_run[level])
865 max_run[level] = run;
867 rl->max_level[last] = malloc(MAX_RUN + 1);
868 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
869 rl->max_run[last] = malloc(MAX_LEVEL + 1);
870 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
871 rl->index_run[last] = malloc(MAX_RUN + 1);
872 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
876 void init_vlc_rl(RLTable *rl)
878 init_vlc(&rl->vlc, 9, rl->n + 1,
879 &rl->table_vlc[0][1], 4, 2,
880 &rl->table_vlc[0][0], 4, 2);
885 /* XXX: find a better solution to handle static init */
886 void h263_decode_init_vlc(MpegEncContext *s)
893 init_vlc(&intra_MCBPC_vlc, 6, 8,
894 intra_MCBPC_bits, 1, 1,
895 intra_MCBPC_code, 1, 1);
896 init_vlc(&inter_MCBPC_vlc, 9, 25,
897 inter_MCBPC_bits, 1, 1,
898 inter_MCBPC_code, 1, 1);
899 init_vlc(&cbpy_vlc, 6, 16,
900 &cbpy_tab[0][1], 2, 1,
901 &cbpy_tab[0][0], 2, 1);
902 init_vlc(&mv_vlc, 9, 33,
907 init_rl(&rl_intra_aic);
908 init_vlc_rl(&rl_inter);
909 init_vlc_rl(&rl_intra);
910 init_vlc_rl(&rl_intra_aic);
911 init_vlc(&dc_lum, 9, 13,
912 &DCtab_lum[0][1], 2, 1,
913 &DCtab_lum[0][0], 2, 1);
914 init_vlc(&dc_chrom, 9, 13,
915 &DCtab_chrom[0][1], 2, 1,
916 &DCtab_chrom[0][0], 2, 1);
920 int h263_decode_gob_header(MpegEncContext *s)
922 unsigned int val, gfid;
924 /* Check for GOB Start Code */
925 val = show_bits(&s->gb, 16);
927 /* We have a GBSC probably with GSTUFF */
928 skip_bits(&s->gb, 16); /* Drop the zeros */
929 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
931 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
933 s->gob_number = get_bits(&s->gb, 5); /* GN */
934 gfid = get_bits(&s->gb, 2); /* GFID */
935 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
937 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
945 int h263_decode_mb(MpegEncContext *s,
946 DCTELEM block[6][64])
948 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
950 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
952 if (s->pict_type == P_TYPE) {
953 if (get_bits1(&s->gb)) {
957 s->block_last_index[i] = -1;
958 s->mv_dir = MV_DIR_FORWARD;
959 s->mv_type = MV_TYPE_16X16;
965 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
966 //fprintf(stderr, "\tCBPC: %d", cbpc);
972 fprintf(stderr, "Stuffing !");
975 s->mb_intra = ((cbpc & 4) != 0);
977 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
985 cbpy = get_vlc(&s->gb, &cbpy_vlc);
986 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
988 s->qscale += quant_tab[get_bits(&s->gb, 2)];
991 else if (s->qscale > 31)
994 s->mv_dir = MV_DIR_FORWARD;
995 if ((cbpc & 16) == 0) {
996 /* 16x16 motion prediction */
997 s->mv_type = MV_TYPE_16X16;
998 h263_pred_motion(s, 0, &pred_x, &pred_y);
1000 mx = h263p_decode_umotion(s, pred_x);
1002 mx = h263_decode_motion(s, pred_x);
1007 my = h263p_decode_umotion(s, pred_y);
1009 my = h263_decode_motion(s, pred_y);
1012 s->mv[0][0][0] = mx;
1013 s->mv[0][0][1] = my;
1014 /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1015 fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1016 fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1017 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1018 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1021 s->mv_type = MV_TYPE_8X8;
1023 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1025 mx = h263p_decode_umotion(s, pred_x);
1027 mx = h263_decode_motion(s, pred_x);
1032 my = h263p_decode_umotion(s, pred_y);
1034 my = h263_decode_motion(s, pred_y);
1037 s->mv[0][i][0] = mx;
1038 s->mv[0][i][1] = my;
1039 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1040 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1047 if (s->h263_pred || s->h263_aic) {
1048 s->ac_pred = get_bits1(&s->gb);
1049 if (s->ac_pred && s->h263_aic)
1050 s->h263_aic_dir = get_bits1(&s->gb);
1053 s->y_dc_scale = 2 * s->qscale;
1054 s->c_dc_scale = 2 * s->qscale;
1056 cbpy = get_vlc(&s->gb, &cbpy_vlc);
1057 cbp = (cbpc & 3) | (cbpy << 2);
1059 s->qscale += quant_tab[get_bits(&s->gb, 2)];
1062 else if (s->qscale > 31)
1067 /* decode each block */
1069 for (i = 0; i < 6; i++) {
1070 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1074 for (i = 0; i < 6; i++) {
1075 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1082 static int h263_decode_motion(MpegEncContext * s, int pred)
1084 int code, val, sign, shift, l, m;
1086 code = get_vlc(&s->gb, &mv_vlc);
1092 sign = get_bits1(&s->gb);
1093 shift = s->f_code - 1;
1094 val = (code - 1) << shift;
1096 val |= get_bits(&s->gb, shift);
1102 /* modulo decoding */
1103 if (!s->h263_long_vectors) {
1104 l = (1 << (s->f_code - 1)) * 32;
1108 } else if (val >= l) {
1112 /* horrible h263 long vector mode */
1113 if (pred < -31 && val < -63)
1115 if (pred > 32 && val > 63)
1122 /* Decodes RVLC of H.263+ UMV */
1123 static int h263p_decode_umotion(MpegEncContext * s, int pred)
1127 if (get_bits1(&s->gb)) /* Motion difference = 0 */
1130 code = 2 + get_bits1(&s->gb);
1132 while (get_bits1(&s->gb))
1135 code += get_bits1(&s->gb);
1140 code = (sign) ? (pred - code) : (pred + code);
1142 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
1148 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1151 int code, level, i, j, last, run;
1152 RLTable *rl = &rl_inter;
1153 const UINT8 *scan_table;
1155 scan_table = zigzag_direct;
1156 if (s->h263_aic && s->mb_intra) {
1160 if (s->h263_aic_dir)
1161 scan_table = ff_alternate_vertical_scan; /* left */
1163 scan_table = ff_alternate_horizontal_scan; /* top */
1165 } else if (s->mb_intra) {
1167 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1168 int component, diff;
1169 component = (n <= 3 ? 0 : n - 4 + 1);
1170 level = s->last_dc[component];
1171 if (s->rv10_first_dc_coded[component]) {
1172 diff = rv_decode_dc(s, n);
1176 level = level & 0xff; /* handle wrap round */
1177 s->last_dc[component] = level;
1179 s->rv10_first_dc_coded[component] = 1;
1182 level = get_bits(&s->gb, 8);
1192 if (s->mb_intra && s->h263_aic)
1194 s->block_last_index[n] = i - 1;
1199 code = get_vlc(&s->gb, &rl->vlc);
1202 if (code == rl->n) {
1204 last = get_bits1(&s->gb);
1205 run = get_bits(&s->gb, 6);
1206 level = (INT8)get_bits(&s->gb, 8);
1207 if (s->h263_rv10 && level == -128) {
1208 /* XXX: should patch encoder too */
1209 level = get_bits(&s->gb, 12);
1210 level = (level << 20) >> 20;
1213 run = rl->table_run[code];
1214 level = rl->table_level[code];
1215 last = code >= rl->last;
1216 if (get_bits1(&s->gb))
1229 if (s->mb_intra && s->h263_aic) {
1230 h263_pred_acdc(s, block, n);
1233 s->block_last_index[n] = i;
1237 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1239 int level, pred, code;
1243 code = get_vlc(&s->gb, &dc_lum);
1245 code = get_vlc(&s->gb, &dc_chrom);
1251 level = get_bits(&s->gb, code);
1252 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1253 level = - (level ^ ((1 << code) - 1));
1255 skip_bits1(&s->gb); /* marker */
1258 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1263 *dc_val = level * s->y_dc_scale;
1265 *dc_val = level * s->c_dc_scale;
1270 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1273 int code, level, i, j, last, run;
1276 const UINT8 *scan_table;
1280 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1289 if (dc_pred_dir == 0)
1290 scan_table = ff_alternate_vertical_scan; /* left */
1292 scan_table = ff_alternate_horizontal_scan; /* top */
1294 scan_table = zigzag_direct;
1299 s->block_last_index[n] = i - 1;
1303 scan_table = zigzag_direct;
1307 code = get_vlc(&s->gb, &rl->vlc);
1310 if (code == rl->n) {
1312 if (get_bits1(&s->gb) != 0) {
1313 if (get_bits1(&s->gb) != 0) {
1315 last = get_bits1(&s->gb);
1316 run = get_bits(&s->gb, 6);
1317 get_bits1(&s->gb); /* marker */
1318 level = get_bits(&s->gb, 12);
1319 level = (level << 20) >> 20; /* sign extend */
1320 skip_bits1(&s->gb); /* marker */
1323 code = get_vlc(&s->gb, &rl->vlc);
1324 if (code < 0 || code >= rl->n)
1326 run = rl->table_run[code];
1327 level = rl->table_level[code];
1328 last = code >= rl->last;
1329 run += rl->max_run[last][level] + 1;
1330 if (get_bits1(&s->gb))
1335 code = get_vlc(&s->gb, &rl->vlc);
1336 if (code < 0 || code >= rl->n)
1338 run = rl->table_run[code];
1339 level = rl->table_level[code];
1340 last = code >= rl->last;
1341 level += rl->max_level[last][run];
1342 if (get_bits1(&s->gb))
1346 run = rl->table_run[code];
1347 level = rl->table_level[code];
1348 last = code >= rl->last;
1349 if (get_bits1(&s->gb))
1363 mpeg4_pred_ac(s, block, n, dc_pred_dir);
1365 i = 64; /* XXX: not optimal */
1368 s->block_last_index[n] = i - 1;
1372 /* most is hardcoded. should extend to handle all h263 streams */
1373 int h263_decode_picture_header(MpegEncContext *s)
1375 int format, width, height;
1377 /* picture header */
1378 if (get_bits(&s->gb, 22) != 0x20)
1380 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
1382 if (get_bits1(&s->gb) != 1)
1383 return -1; /* marker */
1384 if (get_bits1(&s->gb) != 0)
1385 return -1; /* h263 id */
1386 skip_bits1(&s->gb); /* split screen off */
1387 skip_bits1(&s->gb); /* camera off */
1388 skip_bits1(&s->gb); /* freeze picture release off */
1390 /* Reset GOB number */
1393 format = get_bits(&s->gb, 3);
1395 if (format != 7 && format != 6) {
1398 width = h263_format[format][0];
1399 height = h263_format[format][1];
1405 s->pict_type = I_TYPE + get_bits1(&s->gb);
1407 s->unrestricted_mv = get_bits1(&s->gb);
1408 s->h263_long_vectors = s->unrestricted_mv;
1410 if (get_bits1(&s->gb) != 0)
1411 return -1; /* SAC: off */
1412 if (get_bits1(&s->gb) != 0) {
1413 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1416 if (get_bits1(&s->gb) != 0)
1417 return -1; /* not PB frame */
1419 s->qscale = get_bits(&s->gb, 5);
1420 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1426 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1430 format = get_bits(&s->gb, 3);
1431 skip_bits(&s->gb,1); /* Custom PCF */
1432 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1433 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1434 if (get_bits1(&s->gb) != 0) {
1435 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1437 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
1440 skip_bits(&s->gb, 7);
1441 skip_bits(&s->gb, 3); /* Reserved */
1442 } else if (ufep != 0)
1446 s->pict_type = get_bits(&s->gb, 3) + 1;
1447 if (s->pict_type != I_TYPE &&
1448 s->pict_type != P_TYPE)
1450 skip_bits(&s->gb, 7);
1452 /* Get the picture dimensions */
1455 /* Custom Picture Format (CPFMT) */
1456 skip_bits(&s->gb, 4); /* aspect ratio */
1457 width = (get_bits(&s->gb, 9) + 1) * 4;
1459 height = get_bits(&s->gb, 9) * 4;
1461 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1465 width = h263_format[format][0];
1466 height = h263_format[format][1];
1468 if ((width == 0) || (height == 0))
1472 if (s->umvplus_dec) {
1473 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1477 s->qscale = get_bits(&s->gb, 5);
1480 while (get_bits1(&s->gb) != 0) {
1481 skip_bits(&s->gb, 8);
1487 /* decode mpeg4 VOP header */
1488 int mpeg4_decode_picture_header(MpegEncContext * s)
1490 int time_incr, startcode, state, v;
1493 /* search next start code */
1494 align_get_bits(&s->gb);
1497 v = get_bits(&s->gb, 8);
1498 if (state == 0x000001) {
1499 state = ((state << 8) | v) & 0xffffff;
1503 state = ((state << 8) | v) & 0xffffff;
1504 /* XXX: really detect end of frame */
1509 if (startcode == 0x120) {
1510 int time_increment_resolution, width, height, vo_ver_id;
1513 skip_bits(&s->gb, 1); /* random access */
1514 skip_bits(&s->gb, 8); /* vo_type */
1515 if (get_bits1(&s->gb) != 0) { /* is_ol_id */
1516 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
1517 skip_bits(&s->gb, 3); /* vo_priority */
1522 skip_bits(&s->gb, 4); /* aspect_ratio_info */
1523 skip_bits1(&s->gb); /* vol control parameter */
1524 s->shape = get_bits(&s->gb, 2); /* vol shape */
1525 skip_bits1(&s->gb); /* marker */
1527 time_increment_resolution = get_bits(&s->gb, 16);
1528 s->time_increment_bits = av_log2(time_increment_resolution - 1) + 1;
1529 if (s->time_increment_bits < 1)
1530 s->time_increment_bits = 1;
1531 skip_bits1(&s->gb); /* marker */
1533 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */
1534 skip_bits(&s->gb, s->time_increment_bits);
1537 if (s->shape != 2) {
1538 if (s->shape == 0) {
1539 skip_bits1(&s->gb); /* marker */
1540 width = get_bits(&s->gb, 13);
1541 skip_bits1(&s->gb); /* marker */
1542 height = get_bits(&s->gb, 13);
1543 skip_bits1(&s->gb); /* marker */
1546 skip_bits1(&s->gb); /* interlaced */
1547 skip_bits1(&s->gb); /* OBMC */
1548 if (vo_ver_id == 1) {
1549 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
1551 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
1553 if (get_bits1(&s->gb) == 1) { /* not_8_bit */
1554 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
1555 skip_bits(&s->gb, 4); /* bits_per_pixel */
1557 s->quant_precision = 5;
1560 skip_bits1(&s->gb); /* vol_quant_type */
1561 skip_bits1(&s->gb); /* vol_quarter_pixel */
1562 skip_bits1(&s->gb); /* complexity_estimation_disabled */
1563 skip_bits1(&s->gb); /* resync_marker_disabled */
1564 skip_bits1(&s->gb); /* data_partioning_enabled */
1565 if (get_bits1(&s->gb) != 0) { /* scalability */
1566 printf("bad scalability!!!\n");
1571 } else if (startcode != 0x1b6) {
1575 s->pict_type = get_bits(&s->gb, 2) + 1; /* pict type: I = 0 , P = 1 */
1576 if (s->pict_type != I_TYPE &&
1577 s->pict_type != P_TYPE)
1580 /* XXX: parse time base */
1582 while (get_bits1(&s->gb) != 0)
1585 skip_bits1(&s->gb); /* marker */
1586 skip_bits(&s->gb, s->time_increment_bits);
1587 skip_bits1(&s->gb); /* marker */
1589 if (get_bits1(&s->gb) != 1)
1592 if (s->shape != 2 && s->pict_type == P_TYPE) {
1593 /* rounding type for motion estimation */
1594 s->no_rounding = get_bits1(&s->gb);
1599 if (s->shape != 0) {
1600 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
1601 int width, height, hor_spat_ref, ver_spat_ref;
1603 width = get_bits(&s->gb, 13);
1604 skip_bits1(&s->gb); /* marker */
1605 height = get_bits(&s->gb, 13);
1606 skip_bits1(&s->gb); /* marker */
1607 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
1608 skip_bits1(&s->gb); /* marker */
1609 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
1611 skip_bits1(&s->gb); /* change_CR_disable */
1613 if (get_bits1(&s->gb) != 0) {
1614 skip_bits(&s->gb, 8); /* constant_alpha_value */
1618 if (s->shape != 2) {
1619 skip_bits(&s->gb, 3); /* intra dc VLC threshold */
1621 /* note: we do not use quant_precision to avoid problem if no
1622 MPEG4 vol header as it is found on some old opendivx
1624 s->qscale = get_bits(&s->gb, 5);
1626 if (s->pict_type != I_TYPE) {
1627 s->f_code = get_bits(&s->gb, 3); /* fcode_for */
1629 if (s->shape && (s->pict_type != I_TYPE)) {
1630 skip_bits1(&s->gb); // vop shape coding type
1636 /* don't understand why they choose a different header ! */
1637 int intel_h263_decode_picture_header(MpegEncContext *s)
1641 /* picture header */
1642 if (get_bits(&s->gb, 22) != 0x20)
1644 skip_bits(&s->gb, 8); /* picture timestamp */
1646 if (get_bits1(&s->gb) != 1)
1647 return -1; /* marker */
1648 if (get_bits1(&s->gb) != 0)
1649 return -1; /* h263 id */
1650 skip_bits1(&s->gb); /* split screen off */
1651 skip_bits1(&s->gb); /* camera off */
1652 skip_bits1(&s->gb); /* freeze picture release off */
1654 format = get_bits(&s->gb, 3);
1660 s->pict_type = I_TYPE + get_bits1(&s->gb);
1662 s->unrestricted_mv = get_bits1(&s->gb);
1663 s->h263_long_vectors = s->unrestricted_mv;
1665 if (get_bits1(&s->gb) != 0)
1666 return -1; /* SAC: off */
1667 if (get_bits1(&s->gb) != 0)
1668 return -1; /* advanced prediction mode: off */
1669 if (get_bits1(&s->gb) != 0)
1670 return -1; /* not PB frame */
1672 /* skip unknown header garbage */
1673 skip_bits(&s->gb, 41);
1675 s->qscale = get_bits(&s->gb, 5);
1676 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1679 while (get_bits1(&s->gb) != 0) {
1680 skip_bits(&s->gb, 8);