Mercurial > libavcodec.hg
annotate h263.c @ 254:b4fed8b24e3a libavcodec
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
author | michaelni |
---|---|
date | Thu, 07 Mar 2002 13:27:15 +0000 |
parents | 4448dd55d415 |
children | db20b987c32d |
rev | line source |
---|---|
0 | 1 /* |
2 * H263/MPEG4 backend for ffmpeg encoder and decoder | |
3 * Copyright (c) 2000,2001 Gerard Lantau. | |
78 | 4 * H263+ support. |
0 | 5 * Copyright (c) 2001 Juan J. Sierralta P. |
6 * | |
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. | |
11 * | |
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. | |
16 * | |
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. | |
20 */ | |
21 #include "common.h" | |
22 #include "dsputil.h" | |
23 #include "avcodec.h" | |
24 #include "mpegvideo.h" | |
25 #include "h263data.h" | |
26 #include "mpeg4data.h" | |
27 | |
28 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, | |
29 int n); | |
30 static void h263_encode_motion(MpegEncContext * s, int val); | |
78 | 31 static void h263p_encode_umotion(MpegEncContext * s, int val); |
0 | 32 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
33 int n); | |
34 static int h263_decode_motion(MpegEncContext * s, int pred); | |
78 | 35 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 36 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
37 int n, int coded); | |
38 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
39 int n, int coded); | |
40 | |
41 int h263_get_picture_format(int width, int height) | |
42 { | |
43 int format; | |
44 | |
45 if (width == 128 && height == 96) | |
46 format = 1; | |
47 else if (width == 176 && height == 144) | |
48 format = 2; | |
49 else if (width == 352 && height == 288) | |
50 format = 3; | |
51 else if (width == 704 && height == 576) | |
52 format = 4; | |
53 else if (width == 1408 && height == 1152) | |
54 format = 5; | |
55 else | |
56 format = 7; | |
57 return format; | |
58 } | |
59 | |
60 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
61 { | |
78 | 62 int format; |
0 | 63 |
64 align_put_bits(&s->pb); | |
231 | 65 |
66 /* Update the pointer to last GOB */ | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
67 s->ptr_lastgob = pbBufPtr(&s->pb); |
231 | 68 s->gob_number = 0; |
69 | |
70 put_bits(&s->pb, 22, 0x20); /* PSC */ | |
241 | 71 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / |
0 | 72 s->frame_rate) & 0xff); |
73 | |
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 */ | |
78 | 79 |
80 format = h263_get_picture_format(s->width, s->height); | |
0 | 81 if (!s->h263_plus) { |
82 /* H.263v1 */ | |
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 */ | |
94 } else { | |
95 /* H.263v2 */ | |
96 /* H.263 Plus PTYPE */ | |
97 put_bits(&s->pb, 3, 7); | |
98 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */ | |
78 | 99 if (format == 7) |
100 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
101 else | |
102 put_bits(&s->pb, 3, format); | |
103 | |
0 | 104 put_bits(&s->pb,1,0); /* Custom PCF: off */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
105 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv; |
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
106 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 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 */ | |
118 | |
119 put_bits(&s->pb, 3, s->pict_type == P_TYPE); | |
120 | |
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 */ | |
126 | |
127 /* This should be here if PLUSPTYPE */ | |
128 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
129 | |
78 | 130 if (format == 7) { |
131 /* Custom Picture Format (CPFMT) */ | |
0 | 132 |
78 | 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)); | |
137 } | |
138 | |
0 | 139 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
140 if (s->umvplus) |
0 | 141 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
142 put_bits(&s->pb, 5, s->qscale); | |
143 } | |
144 | |
145 put_bits(&s->pb, 1, 0); /* no PEI */ | |
146 } | |
147 | |
162 | 148 int h263_encode_gob_header(MpegEncContext * s, int mb_line) |
149 { | |
150 int pdif=0; | |
151 | |
152 /* Check to see if we need to put a new GBSC */ | |
153 /* for RTP packetization */ | |
154 if (s->rtp_mode) { | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
155 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
162 | 156 if (pdif >= s->rtp_payload_size) { |
157 /* Bad luck, packet must be cut before */ | |
158 align_put_bits(&s->pb); | |
231 | 159 flush_put_bits(&s->pb); |
160 /* Call the RTP callback to send the last GOB */ | |
161 if (s->rtp_callback) { | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
162 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 163 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number); |
164 } | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
165 s->ptr_lastgob = pbBufPtr(&s->pb); |
162 | 166 put_bits(&s->pb, 17, 1); /* GBSC */ |
231 | 167 s->gob_number = mb_line / s->gob_index; |
162 | 168 put_bits(&s->pb, 5, s->gob_number); /* GN */ |
231 | 169 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ |
162 | 170 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
231 | 171 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif); |
162 | 172 return 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); | |
231 | 176 flush_put_bits(&s->pb); |
177 /* Call the RTP callback to send the last GOB */ | |
178 if (s->rtp_callback) { | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
179 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 180 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number); |
181 } | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
182 s->ptr_lastgob = pbBufPtr(&s->pb); |
162 | 183 put_bits(&s->pb, 17, 1); /* GBSC */ |
231 | 184 s->gob_number = mb_line / s->gob_index; |
162 | 185 put_bits(&s->pb, 5, s->gob_number); /* GN */ |
231 | 186 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ |
162 | 187 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
231 | 188 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif); |
162 | 189 return pdif; |
190 } | |
191 } | |
192 return 0; | |
193 } | |
194 | |
0 | 195 void h263_encode_mb(MpegEncContext * s, |
196 DCTELEM block[6][64], | |
197 int motion_x, int motion_y) | |
198 { | |
199 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
162 | 200 |
0 | 201 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
78 | 202 if (!s->mb_intra) { |
203 /* compute cbp */ | |
204 cbp = 0; | |
205 for (i = 0; i < 6; i++) { | |
206 if (s->block_last_index[i] >= 0) | |
207 cbp |= 1 << (5 - i); | |
208 } | |
209 if ((cbp | motion_x | motion_y) == 0) { | |
210 /* skip macroblock */ | |
211 put_bits(&s->pb, 1, 1); | |
212 return; | |
213 } | |
214 put_bits(&s->pb, 1, 0); /* mb coded */ | |
215 cbpc = cbp & 3; | |
216 put_bits(&s->pb, | |
217 inter_MCBPC_bits[cbpc], | |
218 inter_MCBPC_code[cbpc]); | |
219 cbpy = cbp >> 2; | |
220 cbpy ^= 0xf; | |
221 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
0 | 222 |
78 | 223 /* motion vectors: 16x16 mode only now */ |
224 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
225 | |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
226 if (!s->umvplus) { |
78 | 227 h263_encode_motion(s, motion_x - pred_x); |
228 h263_encode_motion(s, motion_y - pred_y); | |
229 } | |
230 else { | |
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); | |
236 } | |
237 } else { | |
0 | 238 /* compute cbp */ |
239 cbp = 0; | |
240 for (i = 0; i < 6; i++) { | |
241 if (s->block_last_index[i] >= 1) | |
242 cbp |= 1 << (5 - i); | |
243 } | |
244 | |
245 cbpc = cbp & 3; | |
246 if (s->pict_type == I_TYPE) { | |
247 put_bits(&s->pb, | |
248 intra_MCBPC_bits[cbpc], | |
249 intra_MCBPC_code[cbpc]); | |
250 } else { | |
251 put_bits(&s->pb, 1, 0); /* mb coded */ | |
252 put_bits(&s->pb, | |
253 inter_MCBPC_bits[cbpc + 4], | |
254 inter_MCBPC_code[cbpc + 4]); | |
255 } | |
256 if (s->h263_pred) { | |
257 /* XXX: currently, we do not try to use ac prediction */ | |
258 put_bits(&s->pb, 1, 0); /* no ac prediction */ | |
259 } | |
260 cbpy = cbp >> 2; | |
261 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
262 } | |
263 | |
264 /* encode each block */ | |
265 if (s->h263_pred) { | |
266 for (i = 0; i < 6; i++) { | |
267 mpeg4_encode_block(s, block[i], i); | |
268 } | |
269 } else { | |
270 for (i = 0; i < 6; i++) { | |
271 h263_encode_block(s, block[i], i); | |
272 } | |
273 } | |
274 } | |
275 | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
276 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
277 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n) |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
278 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
279 int x, y, wrap, a, c, pred_dc, scale, i; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
280 INT16 *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
281 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
282 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
283 if (n < 4) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
284 x = 2 * s->mb_x + 1 + (n & 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
285 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
286 wrap = s->mb_width * 2 + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
287 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
288 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
289 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
290 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
291 x = s->mb_x + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
292 y = s->mb_y + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
293 wrap = s->mb_width + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
294 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
295 ac_val = s->ac_val[n - 4 + 1][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
296 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
297 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
298 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
299 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
300 ac_val1 = ac_val; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
301 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
302 /* B C |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
303 * A X |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
304 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
305 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
306 c = dc_val[(x) + (y - 1) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
307 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
308 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
309 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
310 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
311 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
312 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
313 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
314 for(i=1;i<8;i++) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
315 block[block_permute_op(i*8)] += ac_val[i]; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
316 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
317 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
318 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
319 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
320 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
321 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
322 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
323 for(i=1;i<8;i++) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
324 block[block_permute_op(i)] += ac_val[i + 8]; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
325 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
326 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
327 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
328 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
329 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
330 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
331 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
332 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
333 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
334 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
335 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
336 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
337 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
338 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
339 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
340 block[0]=block[0]*scale + pred_dc; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
341 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
342 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
343 block[0] = 0; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
344 else if (!(block[0] & 1)) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
345 block[0]++; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
346 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
347 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
348 dc_val[(x) + (y) * wrap] = block[0]; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
349 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
350 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
351 for(i=1;i<8;i++) |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
352 ac_val1[i] = block[block_permute_op(i * 8)]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
353 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
354 for(i=1;i<8;i++) |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
355 ac_val1[8 + i] = block[block_permute_op(i)]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
356 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
357 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
358 |
0 | 359 static inline int mid_pred(int a, int b, int c) |
360 { | |
361 int vmin, vmax; | |
245 | 362 vmax = vmin = a; |
0 | 363 if (b < vmin) |
364 vmin = b; | |
245 | 365 else |
366 vmax = b; | |
367 | |
0 | 368 if (c < vmin) |
369 vmin = c; | |
245 | 370 else if (c > vmax) |
0 | 371 vmax = c; |
372 | |
373 return a + b + c - vmin - vmax; | |
374 } | |
375 | |
376 INT16 *h263_pred_motion(MpegEncContext * s, int block, | |
377 int *px, int *py) | |
378 { | |
245 | 379 int xy, y, wrap; |
0 | 380 INT16 *A, *B, *C, *mot_val; |
381 | |
382 wrap = 2 * s->mb_width + 2; | |
245 | 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 | |
0 | 386 |
245 | 387 mot_val = s->motion_val[xy]; |
0 | 388 |
389 /* special case for first line */ | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
390 if (y == 1 || s->first_slice_line || s->first_gob_line) { |
245 | 391 A = s->motion_val[xy - 1]; |
0 | 392 *px = A[0]; |
393 *py = A[1]; | |
394 } else { | |
395 switch(block) { | |
396 default: | |
397 case 0: | |
245 | 398 A = s->motion_val[xy - 1]; |
399 B = s->motion_val[xy - wrap]; | |
400 C = s->motion_val[xy + 2 - wrap]; | |
0 | 401 break; |
402 case 1: | |
403 case 2: | |
245 | 404 A = s->motion_val[xy - 1]; |
405 B = s->motion_val[xy - wrap]; | |
406 C = s->motion_val[xy + 1 - wrap]; | |
0 | 407 break; |
408 case 3: | |
245 | 409 A = s->motion_val[xy - 1]; |
410 B = s->motion_val[xy - 1 - wrap]; | |
411 C = s->motion_val[xy - wrap]; | |
0 | 412 break; |
413 } | |
414 *px = mid_pred(A[0], B[0], C[0]); | |
415 *py = mid_pred(A[1], B[1], C[1]); | |
416 } | |
417 return mot_val; | |
418 } | |
419 | |
420 | |
421 static void h263_encode_motion(MpegEncContext * s, int val) | |
422 { | |
423 int range, l, m, bit_size, sign, code, bits; | |
424 | |
425 if (val == 0) { | |
426 /* zero vector */ | |
427 code = 0; | |
428 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
429 } else { | |
430 bit_size = s->f_code - 1; | |
431 range = 1 << bit_size; | |
432 /* modulo encoding */ | |
433 l = range * 32; | |
434 m = 2 * l; | |
435 if (val < -l) { | |
436 val += m; | |
437 } else if (val >= l) { | |
438 val -= m; | |
439 } | |
440 | |
441 if (val >= 0) { | |
442 val--; | |
443 code = (val >> bit_size) + 1; | |
444 bits = val & (range - 1); | |
445 sign = 0; | |
446 } else { | |
447 val = -val; | |
448 val--; | |
449 code = (val >> bit_size) + 1; | |
450 bits = val & (range - 1); | |
451 sign = 1; | |
452 } | |
453 | |
454 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); | |
455 if (bit_size > 0) { | |
456 put_bits(&s->pb, bit_size, bits); | |
457 } | |
458 } | |
459 } | |
460 | |
78 | 461 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
462 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
463 { | |
464 short sval = 0; | |
465 short i = 0; | |
466 short n_bits = 0; | |
467 short temp_val; | |
468 int code = 0; | |
469 int tcode; | |
470 | |
471 if ( val == 0) | |
472 put_bits(&s->pb, 1, 1); | |
473 else if (val == 1) | |
474 put_bits(&s->pb, 3, 0); | |
475 else if (val == -1) | |
476 put_bits(&s->pb, 3, 2); | |
477 else { | |
478 | |
479 sval = ((val < 0) ? (short)(-val):(short)val); | |
480 temp_val = sval; | |
481 | |
482 while (temp_val != 0) { | |
483 temp_val = temp_val >> 1; | |
484 n_bits++; | |
485 } | |
486 | |
487 i = n_bits - 1; | |
488 while (i > 0) { | |
489 tcode = (sval & (1 << (i-1))) >> (i-1); | |
490 tcode = (tcode << 1) | 1; | |
491 code = (code << 2) | tcode; | |
492 i--; | |
493 } | |
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); | |
497 } | |
498 } | |
499 | |
0 | 500 void h263_encode_init_vlc(MpegEncContext *s) |
501 { | |
502 static int done = 0; | |
503 | |
504 if (!done) { | |
505 done = 1; | |
506 init_rl(&rl_inter); | |
507 init_rl(&rl_intra); | |
508 } | |
509 } | |
510 | |
511 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) | |
512 { | |
513 int level, run, last, i, j, last_index, last_non_zero, sign, slevel; | |
514 int code; | |
515 RLTable *rl = &rl_inter; | |
516 | |
517 if (s->mb_intra) { | |
231 | 518 /* DC coef */ |
519 level = block[0]; | |
0 | 520 /* 255 cannot be represented, so we clamp */ |
521 if (level > 254) { | |
522 level = 254; | |
523 block[0] = 254; | |
524 } | |
231 | 525 /* 0 cannot be represented also */ |
526 else if (!level) { | |
527 level = 1; | |
528 block[0] = 1; | |
529 } | |
530 if (level == 128) | |
531 put_bits(&s->pb, 8, 0xff); | |
532 else | |
533 put_bits(&s->pb, 8, level & 0xff); | |
534 i = 1; | |
0 | 535 } else { |
231 | 536 i = 0; |
0 | 537 } |
538 | |
539 /* AC coefs */ | |
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]; | |
544 level = block[j]; | |
545 if (level) { | |
546 run = i - last_non_zero - 1; | |
547 last = (i == last_index); | |
548 sign = 0; | |
549 slevel = level; | |
550 if (level < 0) { | |
551 sign = 1; | |
552 level = -level; | |
553 } | |
554 code = get_rl_index(rl, last, run, level); | |
555 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
556 if (code == rl->n) { | |
557 put_bits(&s->pb, 1, last); | |
558 put_bits(&s->pb, 6, run); | |
559 put_bits(&s->pb, 8, slevel & 0xff); | |
560 } else { | |
561 put_bits(&s->pb, 1, sign); | |
562 } | |
563 last_non_zero = i; | |
564 } | |
565 } | |
566 } | |
567 | |
568 /***************************************************/ | |
569 | |
570 /* write mpeg4 VOP header */ | |
571 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
572 { | |
573 align_put_bits(&s->pb); | |
574 | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
575 put_bits(&s->pb, 16, 0); /* vop header */ |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
576 put_bits(&s->pb, 16, 0x1B6); /* vop header */ |
0 | 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); | |
581 | |
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) { | |
587 s->no_rounding = 0; | |
588 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ | |
589 } | |
590 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
591 | |
592 put_bits(&s->pb, 5, s->qscale); | |
593 | |
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); | |
597 } | |
598 | |
599 void h263_dc_scale(MpegEncContext * s) | |
600 { | |
601 int quant; | |
602 | |
603 quant = s->qscale; | |
604 /* luminance */ | |
605 if (quant < 5) | |
606 s->y_dc_scale = 8; | |
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); | |
611 else | |
612 s->y_dc_scale = (2 * quant - 16); | |
613 /* chrominance */ | |
614 if (quant < 5) | |
615 s->c_dc_scale = 8; | |
616 else if (quant > 4 && quant < 25) | |
617 s->c_dc_scale = ((quant + 13) / 2); | |
618 else | |
619 s->c_dc_scale = (quant - 6); | |
620 } | |
621 | |
622 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) | |
623 { | |
245 | 624 int a, b, c, xy, wrap, pred, scale; |
0 | 625 UINT16 *dc_val; |
626 | |
627 /* find prediction */ | |
628 if (n < 4) { | |
629 wrap = s->mb_width * 2 + 2; | |
245 | 630 xy = 2 * s->mb_y + 1 + ((n & 2) >> 1); |
631 xy *= wrap; | |
632 xy += 2 * s->mb_x + 1 + (n & 1); | |
0 | 633 dc_val = s->dc_val[0]; |
634 scale = s->y_dc_scale; | |
635 } else { | |
636 wrap = s->mb_width + 2; | |
245 | 637 xy = s->mb_y + 1; |
638 xy *= wrap; | |
639 xy += s->mb_x + 1; | |
0 | 640 dc_val = s->dc_val[n - 4 + 1]; |
641 scale = s->c_dc_scale; | |
642 } | |
643 | |
644 /* B C | |
645 * A X | |
646 */ | |
245 | 647 a = dc_val[xy - 1]; |
648 b = dc_val[xy - 1 - wrap]; | |
649 c = dc_val[xy - wrap]; | |
0 | 650 |
651 if (abs(a - b) < abs(b - c)) { | |
652 pred = c; | |
653 *dir_ptr = 1; /* top */ | |
654 } else { | |
655 pred = a; | |
656 *dir_ptr = 0; /* left */ | |
657 } | |
658 /* we assume pred is positive */ | |
659 pred = (pred + (scale >> 1)) / scale; | |
660 | |
661 /* prepare address for prediction update */ | |
245 | 662 *dc_val_ptr = &dc_val[xy]; |
0 | 663 |
664 return pred; | |
665 } | |
666 | |
174
ac5075a55488
new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents:
162
diff
changeset
|
667 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n, |
0 | 668 int dir) |
669 { | |
670 int x, y, wrap, i; | |
671 INT16 *ac_val, *ac_val1; | |
672 | |
673 /* find prediction */ | |
674 if (n < 4) { | |
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]; | |
679 } else { | |
680 x = s->mb_x + 1; | |
681 y = s->mb_y + 1; | |
682 wrap = s->mb_width + 2; | |
683 ac_val = s->ac_val[n - 4 + 1][0]; | |
684 } | |
685 ac_val += ((y) * wrap + (x)) * 16; | |
686 ac_val1 = ac_val; | |
687 if (s->ac_pred) { | |
688 if (dir == 0) { | |
689 /* left prediction */ | |
690 ac_val -= 16; | |
691 for(i=1;i<8;i++) { | |
174
ac5075a55488
new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents:
162
diff
changeset
|
692 block[block_permute_op(i*8)] += ac_val[i]; |
0 | 693 } |
694 } else { | |
695 /* top prediction */ | |
696 ac_val -= 16 * wrap; | |
697 for(i=1;i<8;i++) { | |
174
ac5075a55488
new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents:
162
diff
changeset
|
698 block[block_permute_op(i)] += ac_val[i + 8]; |
0 | 699 } |
700 } | |
701 } | |
702 /* left copy */ | |
703 for(i=1;i<8;i++) | |
174
ac5075a55488
new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents:
162
diff
changeset
|
704 ac_val1[i] = block[block_permute_op(i * 8)]; |
0 | 705 /* top copy */ |
706 for(i=1;i<8;i++) | |
174
ac5075a55488
new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents:
162
diff
changeset
|
707 ac_val1[8 + i] = block[block_permute_op(i)]; |
0 | 708 } |
709 | |
710 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) | |
711 { | |
712 int size, v, pred; | |
713 UINT16 *dc_val; | |
714 | |
715 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
716 if (n < 4) { | |
717 *dc_val = level * s->y_dc_scale; | |
718 } else { | |
719 *dc_val = level * s->c_dc_scale; | |
720 } | |
721 | |
722 /* do the prediction */ | |
723 level -= pred; | |
724 /* find number of bits */ | |
725 size = 0; | |
726 v = abs(level); | |
727 while (v) { | |
728 v >>= 1; | |
729 size++; | |
730 } | |
731 | |
732 if (n < 4) { | |
733 /* luminance */ | |
734 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
735 } else { | |
736 /* chrominance */ | |
737 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
738 } | |
739 | |
740 /* encode remaining bits */ | |
741 if (size > 0) { | |
742 if (level < 0) | |
743 level = (-level) ^ ((1 << size) - 1); | |
744 put_bits(&s->pb, size, level); | |
745 if (size > 8) | |
746 put_bits(&s->pb, 1, 1); | |
747 } | |
748 } | |
749 | |
750 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) | |
751 { | |
752 int level, run, last, i, j, last_index, last_non_zero, sign, slevel; | |
753 int code, dc_pred_dir; | |
754 const RLTable *rl; | |
755 | |
756 if (s->mb_intra) { | |
757 /* mpeg4 based DC predictor */ | |
758 mpeg4_encode_dc(s, block[0], n, &dc_pred_dir); | |
759 i = 1; | |
760 rl = &rl_intra; | |
761 } else { | |
762 i = 0; | |
763 rl = &rl_inter; | |
764 } | |
765 | |
766 /* AC coefs */ | |
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]; | |
771 level = block[j]; | |
772 if (level) { | |
773 run = i - last_non_zero - 1; | |
774 last = (i == last_index); | |
775 sign = 0; | |
776 slevel = level; | |
777 if (level < 0) { | |
778 sign = 1; | |
779 level = -level; | |
780 } | |
781 code = get_rl_index(rl, last, run, level); | |
782 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
783 if (code == rl->n) { | |
784 int level1, run1; | |
785 level1 = level - rl->max_level[last][run]; | |
786 if (level1 < 1) | |
787 goto esc2; | |
788 code = get_rl_index(rl, last, run, level1); | |
789 if (code == rl->n) { | |
790 esc2: | |
791 put_bits(&s->pb, 1, 1); | |
792 if (level > MAX_LEVEL) | |
793 goto esc3; | |
794 run1 = run - rl->max_run[last][level] - 1; | |
795 if (run1 < 0) | |
796 goto esc3; | |
797 code = get_rl_index(rl, last, run1, level); | |
798 if (code == rl->n) { | |
799 esc3: | |
800 /* third escape */ | |
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); | |
807 } else { | |
808 /* second escape */ | |
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); | |
812 } | |
813 } else { | |
814 /* first escape */ | |
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); | |
818 } | |
819 } else { | |
820 put_bits(&s->pb, 1, sign); | |
821 } | |
822 last_non_zero = i; | |
823 } | |
824 } | |
825 } | |
826 | |
827 | |
828 | |
829 /***********************************************/ | |
830 /* decoding */ | |
831 | |
832 static VLC intra_MCBPC_vlc; | |
833 static VLC inter_MCBPC_vlc; | |
834 static VLC cbpy_vlc; | |
835 static VLC mv_vlc; | |
836 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
837 static VLC sprite_trajectory; |
0 | 838 |
839 void init_rl(RLTable *rl) | |
840 { | |
841 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; | |
842 UINT8 index_run[MAX_RUN+1]; | |
843 int last, run, level, start, end, i; | |
844 | |
845 /* compute max_level[], max_run[] and index_run[] */ | |
846 for(last=0;last<2;last++) { | |
847 if (last == 0) { | |
848 start = 0; | |
849 end = rl->last; | |
850 } else { | |
851 start = rl->last; | |
852 end = rl->n; | |
853 } | |
854 | |
855 memset(max_level, 0, MAX_RUN + 1); | |
856 memset(max_run, 0, MAX_LEVEL + 1); | |
857 memset(index_run, rl->n, MAX_RUN + 1); | |
858 for(i=start;i<end;i++) { | |
859 run = rl->table_run[i]; | |
860 level = rl->table_level[i]; | |
861 if (index_run[run] == rl->n) | |
862 index_run[run] = i; | |
863 if (level > max_level[run]) | |
864 max_level[run] = level; | |
865 if (run > max_run[level]) | |
866 max_run[level] = run; | |
867 } | |
868 rl->max_level[last] = malloc(MAX_RUN + 1); | |
869 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); | |
870 rl->max_run[last] = malloc(MAX_LEVEL + 1); | |
871 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); | |
872 rl->index_run[last] = malloc(MAX_RUN + 1); | |
873 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); | |
874 } | |
875 } | |
876 | |
877 void init_vlc_rl(RLTable *rl) | |
878 { | |
879 init_vlc(&rl->vlc, 9, rl->n + 1, | |
880 &rl->table_vlc[0][1], 4, 2, | |
881 &rl->table_vlc[0][0], 4, 2); | |
882 } | |
883 | |
884 /* init vlcs */ | |
885 | |
886 /* XXX: find a better solution to handle static init */ | |
887 void h263_decode_init_vlc(MpegEncContext *s) | |
888 { | |
889 static int done = 0; | |
890 | |
891 if (!done) { | |
892 done = 1; | |
893 | |
894 init_vlc(&intra_MCBPC_vlc, 6, 8, | |
895 intra_MCBPC_bits, 1, 1, | |
896 intra_MCBPC_code, 1, 1); | |
161 | 897 init_vlc(&inter_MCBPC_vlc, 9, 25, |
0 | 898 inter_MCBPC_bits, 1, 1, |
899 inter_MCBPC_code, 1, 1); | |
900 init_vlc(&cbpy_vlc, 6, 16, | |
901 &cbpy_tab[0][1], 2, 1, | |
902 &cbpy_tab[0][0], 2, 1); | |
903 init_vlc(&mv_vlc, 9, 33, | |
904 &mvtab[0][1], 2, 1, | |
905 &mvtab[0][0], 2, 1); | |
906 init_rl(&rl_inter); | |
907 init_rl(&rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
908 init_rl(&rl_intra_aic); |
0 | 909 init_vlc_rl(&rl_inter); |
910 init_vlc_rl(&rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
911 init_vlc_rl(&rl_intra_aic); |
0 | 912 init_vlc(&dc_lum, 9, 13, |
913 &DCtab_lum[0][1], 2, 1, | |
914 &DCtab_lum[0][0], 2, 1); | |
915 init_vlc(&dc_chrom, 9, 13, | |
916 &DCtab_chrom[0][1], 2, 1, | |
917 &DCtab_chrom[0][0], 2, 1); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
918 init_vlc(&sprite_trajectory, 9, 15, |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
919 &sprite_trajectory_tab[0][1], 4, 2, |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
920 &sprite_trajectory_tab[0][0], 4, 2); |
0 | 921 } |
922 } | |
923 | |
162 | 924 int h263_decode_gob_header(MpegEncContext *s) |
925 { | |
926 unsigned int val, gfid; | |
927 | |
928 /* Check for GOB Start Code */ | |
929 val = show_bits(&s->gb, 16); | |
930 if (val == 0) { | |
931 /* We have a GBSC probably with GSTUFF */ | |
932 skip_bits(&s->gb, 16); /* Drop the zeros */ | |
933 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */ | |
934 #ifdef DEBUG | |
935 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x); | |
936 #endif | |
937 s->gob_number = get_bits(&s->gb, 5); /* GN */ | |
938 gfid = get_bits(&s->gb, 2); /* GFID */ | |
939 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
940 #ifdef DEBUG | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
941 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale); |
162 | 942 #endif |
943 return 1; | |
944 } | |
945 return 0; | |
946 | |
947 } | |
948 | |
0 | 949 int h263_decode_mb(MpegEncContext *s, |
950 DCTELEM block[6][64]) | |
951 { | |
952 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
953 INT16 *mot_val; | |
110 | 954 static INT8 quant_tab[4] = { -1, -2, 1, 2 }; |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
955 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
956 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
21 | 957 if (get_bits1(&s->gb)) { |
0 | 958 /* skip mb */ |
959 s->mb_intra = 0; | |
960 for(i=0;i<6;i++) | |
961 s->block_last_index[i] = -1; | |
962 s->mv_dir = MV_DIR_FORWARD; | |
963 s->mv_type = MV_TYPE_16X16; | |
964 s->mv[0][0][0] = 0; | |
965 s->mv[0][0][1] = 0; | |
7
1d3ac9654178
added skip macroblock optimization (big perf win on black regions for example)
glantau
parents:
0
diff
changeset
|
966 s->mb_skiped = 1; |
0 | 967 return 0; |
968 } | |
969 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc); | |
144 | 970 //fprintf(stderr, "\tCBPC: %d", cbpc); |
0 | 971 if (cbpc < 0) |
972 return -1; | |
161 | 973 if (cbpc > 20) |
974 cbpc+=3; | |
975 else if (cbpc == 20) | |
976 fprintf(stderr, "Stuffing !"); | |
144 | 977 |
0 | 978 dquant = cbpc & 8; |
979 s->mb_intra = ((cbpc & 4) != 0); | |
980 } else { | |
981 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc); | |
982 if (cbpc < 0) | |
983 return -1; | |
984 dquant = cbpc & 4; | |
985 s->mb_intra = 1; | |
986 } | |
987 | |
988 if (!s->mb_intra) { | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
989 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
990 s->mcsel= get_bits1(&s->gb); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
991 else s->mcsel= 0; |
0 | 992 cbpy = get_vlc(&s->gb, &cbpy_vlc); |
993 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2); | |
994 if (dquant) { | |
995 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
996 if (s->qscale < 1) | |
997 s->qscale = 1; | |
998 else if (s->qscale > 31) | |
999 s->qscale = 31; | |
1000 } | |
1001 s->mv_dir = MV_DIR_FORWARD; | |
1002 if ((cbpc & 16) == 0) { | |
1003 /* 16x16 motion prediction */ | |
1004 s->mv_type = MV_TYPE_16X16; | |
1005 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1006 if (s->umvplus_dec) |
78 | 1007 mx = h263p_decode_umotion(s, pred_x); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1008 else if(!s->mcsel) |
78 | 1009 mx = h263_decode_motion(s, pred_x); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1010 else mx=0; |
0 | 1011 if (mx >= 0xffff) |
1012 return -1; | |
78 | 1013 |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1014 if (s->umvplus_dec) |
78 | 1015 my = h263p_decode_umotion(s, pred_y); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1016 else if(!s->mcsel) |
78 | 1017 my = h263_decode_motion(s, pred_y); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1018 else my=0; |
0 | 1019 if (my >= 0xffff) |
1020 return -1; | |
1021 s->mv[0][0][0] = mx; | |
1022 s->mv[0][0][1] = my; | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
1023 /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x); |
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
1024 fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x); |
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
1025 fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1026 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1) |
78 | 1027 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
1028 | |
0 | 1029 } else { |
1030 s->mv_type = MV_TYPE_8X8; | |
1031 for(i=0;i<4;i++) { | |
1032 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); | |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1033 if (s->umvplus_dec) |
78 | 1034 mx = h263p_decode_umotion(s, pred_x); |
1035 else | |
1036 mx = h263_decode_motion(s, pred_x); | |
0 | 1037 if (mx >= 0xffff) |
1038 return -1; | |
78 | 1039 |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1040 if (s->umvplus_dec) |
78 | 1041 my = h263p_decode_umotion(s, pred_y); |
1042 else | |
1043 my = h263_decode_motion(s, pred_y); | |
0 | 1044 if (my >= 0xffff) |
1045 return -1; | |
1046 s->mv[0][i][0] = mx; | |
1047 s->mv[0][i][1] = my; | |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
1048 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1) |
78 | 1049 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
0 | 1050 mot_val[0] = mx; |
1051 mot_val[1] = my; | |
1052 } | |
1053 } | |
1054 } else { | |
1055 s->ac_pred = 0; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1056 if (s->h263_pred || s->h263_aic) { |
21 | 1057 s->ac_pred = get_bits1(&s->gb); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1058 if (s->ac_pred && s->h263_aic) |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1059 s->h263_aic_dir = get_bits1(&s->gb); |
0 | 1060 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1061 if (s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1062 s->y_dc_scale = 2 * s->qscale; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1063 s->c_dc_scale = 2 * s->qscale; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1064 } |
0 | 1065 cbpy = get_vlc(&s->gb, &cbpy_vlc); |
1066 cbp = (cbpc & 3) | (cbpy << 2); | |
1067 if (dquant) { | |
1068 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
1069 if (s->qscale < 1) | |
1070 s->qscale = 1; | |
1071 else if (s->qscale > 31) | |
1072 s->qscale = 31; | |
1073 } | |
1074 } | |
1075 | |
1076 /* decode each block */ | |
1077 if (s->h263_pred) { | |
1078 for (i = 0; i < 6; i++) { | |
1079 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0) | |
1080 return -1; | |
1081 } | |
1082 } else { | |
1083 for (i = 0; i < 6; i++) { | |
1084 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0) | |
1085 return -1; | |
1086 } | |
1087 } | |
1088 return 0; | |
1089 } | |
1090 | |
1091 static int h263_decode_motion(MpegEncContext * s, int pred) | |
1092 { | |
1093 int code, val, sign, shift, l, m; | |
1094 | |
1095 code = get_vlc(&s->gb, &mv_vlc); | |
1096 if (code < 0) | |
1097 return 0xffff; | |
1098 | |
1099 if (code == 0) | |
1100 return pred; | |
21 | 1101 sign = get_bits1(&s->gb); |
0 | 1102 shift = s->f_code - 1; |
1103 val = (code - 1) << shift; | |
1104 if (shift > 0) | |
1105 val |= get_bits(&s->gb, shift); | |
1106 val++; | |
1107 if (sign) | |
1108 val = -val; | |
1109 val += pred; | |
1110 | |
1111 /* modulo decoding */ | |
1112 if (!s->h263_long_vectors) { | |
1113 l = (1 << (s->f_code - 1)) * 32; | |
1114 m = 2 * l; | |
1115 if (val < -l) { | |
1116 val += m; | |
1117 } else if (val >= l) { | |
1118 val -= m; | |
1119 } | |
1120 } else { | |
1121 /* horrible h263 long vector mode */ | |
1122 if (pred < -31 && val < -63) | |
1123 val += 64; | |
1124 if (pred > 32 && val > 63) | |
1125 val -= 64; | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
1126 |
0 | 1127 } |
1128 return val; | |
1129 } | |
1130 | |
78 | 1131 /* Decodes RVLC of H.263+ UMV */ |
1132 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
1133 { | |
1134 int code = 0, sign; | |
1135 | |
1136 if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
1137 return pred; | |
1138 | |
1139 code = 2 + get_bits1(&s->gb); | |
1140 | |
1141 while (get_bits1(&s->gb)) | |
1142 { | |
1143 code <<= 1; | |
1144 code += get_bits1(&s->gb); | |
1145 } | |
1146 sign = code & 1; | |
1147 code >>= 1; | |
1148 | |
1149 code = (sign) ? (pred - code) : (pred + code); | |
1150 #ifdef DEBUG | |
1151 fprintf(stderr,"H.263+ UMV Motion = %d\n", code); | |
1152 #endif | |
1153 return code; | |
1154 | |
1155 } | |
1156 | |
0 | 1157 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
1158 int n, int coded) | |
1159 { | |
1160 int code, level, i, j, last, run; | |
1161 RLTable *rl = &rl_inter; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1162 const UINT8 *scan_table; |
0 | 1163 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1164 scan_table = zigzag_direct; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1165 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1166 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1167 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1168 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1169 if (s->h263_aic_dir) |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1170 scan_table = ff_alternate_vertical_scan; /* left */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1171 else |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1172 scan_table = ff_alternate_horizontal_scan; /* top */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1173 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1174 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1175 /* DC coef */ |
0 | 1176 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) { |
1177 int component, diff; | |
1178 component = (n <= 3 ? 0 : n - 4 + 1); | |
1179 level = s->last_dc[component]; | |
1180 if (s->rv10_first_dc_coded[component]) { | |
1181 diff = rv_decode_dc(s, n); | |
1182 if (diff == 0xffff) | |
1183 return -1; | |
1184 level += diff; | |
1185 level = level & 0xff; /* handle wrap round */ | |
1186 s->last_dc[component] = level; | |
1187 } else { | |
1188 s->rv10_first_dc_coded[component] = 1; | |
1189 } | |
1190 } else { | |
1191 level = get_bits(&s->gb, 8); | |
1192 if (level == 255) | |
1193 level = 128; | |
1194 } | |
1195 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1196 i = 1; |
0 | 1197 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1198 i = 0; |
0 | 1199 } |
1200 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1201 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1202 goto not_coded; |
0 | 1203 s->block_last_index[n] = i - 1; |
1204 return 0; | |
1205 } | |
1206 | |
1207 for(;;) { | |
1208 code = get_vlc(&s->gb, &rl->vlc); | |
1209 if (code < 0) | |
1210 return -1; | |
1211 if (code == rl->n) { | |
1212 /* escape */ | |
21 | 1213 last = get_bits1(&s->gb); |
0 | 1214 run = get_bits(&s->gb, 6); |
1215 level = (INT8)get_bits(&s->gb, 8); | |
1216 if (s->h263_rv10 && level == -128) { | |
1217 /* XXX: should patch encoder too */ | |
1218 level = get_bits(&s->gb, 12); | |
1219 level = (level << 20) >> 20; | |
1220 } | |
1221 } else { | |
1222 run = rl->table_run[code]; | |
1223 level = rl->table_level[code]; | |
1224 last = code >= rl->last; | |
21 | 1225 if (get_bits1(&s->gb)) |
0 | 1226 level = -level; |
1227 } | |
1228 i += run; | |
1229 if (i >= 64) | |
1230 return -1; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1231 j = scan_table[i]; |
0 | 1232 block[j] = level; |
1233 if (last) | |
1234 break; | |
1235 i++; | |
1236 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1237 not_coded: |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1238 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1239 h263_pred_acdc(s, block, n); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1240 i = 64; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1241 } |
0 | 1242 s->block_last_index[n] = i; |
1243 return 0; | |
1244 } | |
1245 | |
1246 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) | |
1247 { | |
1248 int level, pred, code; | |
1249 UINT16 *dc_val; | |
1250 | |
1251 if (n < 4) | |
1252 code = get_vlc(&s->gb, &dc_lum); | |
1253 else | |
1254 code = get_vlc(&s->gb, &dc_chrom); | |
1255 if (code < 0) | |
1256 return -1; | |
1257 if (code == 0) { | |
1258 level = 0; | |
1259 } else { | |
1260 level = get_bits(&s->gb, code); | |
1261 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ | |
1262 level = - (level ^ ((1 << code) - 1)); | |
1263 if (code > 8) | |
21 | 1264 skip_bits1(&s->gb); /* marker */ |
0 | 1265 } |
1266 | |
1267 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
1268 level += pred; | |
1269 if (level < 0) | |
1270 level = 0; | |
1271 if (n < 4) { | |
1272 *dc_val = level * s->y_dc_scale; | |
1273 } else { | |
1274 *dc_val = level * s->c_dc_scale; | |
1275 } | |
1276 return level; | |
1277 } | |
1278 | |
1279 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1280 int n, int coded) | |
1281 { | |
1282 int code, level, i, j, last, run; | |
1283 int dc_pred_dir; | |
1284 RLTable *rl; | |
1285 const UINT8 *scan_table; | |
1286 | |
1287 if (s->mb_intra) { | |
1288 /* DC coef */ | |
1289 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
1290 if (level < 0) | |
1291 return -1; | |
1292 block[0] = level; | |
1293 i = 1; | |
1294 if (!coded) | |
1295 goto not_coded; | |
1296 rl = &rl_intra; | |
1297 if (s->ac_pred) { | |
1298 if (dc_pred_dir == 0) | |
1299 scan_table = ff_alternate_vertical_scan; /* left */ | |
1300 else | |
1301 scan_table = ff_alternate_horizontal_scan; /* top */ | |
1302 } else { | |
1303 scan_table = zigzag_direct; | |
1304 } | |
1305 } else { | |
1306 i = 0; | |
1307 if (!coded) { | |
1308 s->block_last_index[n] = i - 1; | |
1309 return 0; | |
1310 } | |
1311 rl = &rl_inter; | |
1312 scan_table = zigzag_direct; | |
1313 } | |
1314 | |
1315 for(;;) { | |
1316 code = get_vlc(&s->gb, &rl->vlc); | |
1317 if (code < 0) | |
1318 return -1; | |
1319 if (code == rl->n) { | |
1320 /* escape */ | |
21 | 1321 if (get_bits1(&s->gb) != 0) { |
1322 if (get_bits1(&s->gb) != 0) { | |
0 | 1323 /* third escape */ |
21 | 1324 last = get_bits1(&s->gb); |
0 | 1325 run = get_bits(&s->gb, 6); |
21 | 1326 get_bits1(&s->gb); /* marker */ |
0 | 1327 level = get_bits(&s->gb, 12); |
1328 level = (level << 20) >> 20; /* sign extend */ | |
21 | 1329 skip_bits1(&s->gb); /* marker */ |
0 | 1330 } else { |
1331 /* second escape */ | |
1332 code = get_vlc(&s->gb, &rl->vlc); | |
1333 if (code < 0 || code >= rl->n) | |
1334 return -1; | |
1335 run = rl->table_run[code]; | |
1336 level = rl->table_level[code]; | |
1337 last = code >= rl->last; | |
1338 run += rl->max_run[last][level] + 1; | |
21 | 1339 if (get_bits1(&s->gb)) |
0 | 1340 level = -level; |
1341 } | |
1342 } else { | |
1343 /* first escape */ | |
1344 code = get_vlc(&s->gb, &rl->vlc); | |
1345 if (code < 0 || code >= rl->n) | |
1346 return -1; | |
1347 run = rl->table_run[code]; | |
1348 level = rl->table_level[code]; | |
1349 last = code >= rl->last; | |
1350 level += rl->max_level[last][run]; | |
21 | 1351 if (get_bits1(&s->gb)) |
0 | 1352 level = -level; |
1353 } | |
1354 } else { | |
1355 run = rl->table_run[code]; | |
1356 level = rl->table_level[code]; | |
1357 last = code >= rl->last; | |
21 | 1358 if (get_bits1(&s->gb)) |
0 | 1359 level = -level; |
1360 } | |
1361 i += run; | |
1362 if (i >= 64) | |
1363 return -1; | |
1364 j = scan_table[i]; | |
1365 block[j] = level; | |
1366 i++; | |
1367 if (last) | |
1368 break; | |
1369 } | |
1370 not_coded: | |
1371 if (s->mb_intra) { | |
1372 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
1373 if (s->ac_pred) { | |
1374 i = 64; /* XXX: not optimal */ | |
1375 } | |
1376 } | |
1377 s->block_last_index[n] = i - 1; | |
1378 return 0; | |
1379 } | |
1380 | |
1381 /* most is hardcoded. should extend to handle all h263 streams */ | |
1382 int h263_decode_picture_header(MpegEncContext *s) | |
1383 { | |
1384 int format, width, height; | |
1385 | |
1386 /* picture header */ | |
1387 if (get_bits(&s->gb, 22) != 0x20) | |
1388 return -1; | |
231 | 1389 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
1390 | |
21 | 1391 if (get_bits1(&s->gb) != 1) |
0 | 1392 return -1; /* marker */ |
21 | 1393 if (get_bits1(&s->gb) != 0) |
0 | 1394 return -1; /* h263 id */ |
21 | 1395 skip_bits1(&s->gb); /* split screen off */ |
1396 skip_bits1(&s->gb); /* camera off */ | |
1397 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 1398 |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
1399 /* Reset GOB number */ |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
1400 s->gob_number = 0; |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
1401 |
0 | 1402 format = get_bits(&s->gb, 3); |
1403 | |
161 | 1404 if (format != 7 && format != 6) { |
0 | 1405 s->h263_plus = 0; |
1406 /* H.263v1 */ | |
1407 width = h263_format[format][0]; | |
1408 height = h263_format[format][1]; | |
1409 if (!width) | |
1410 return -1; | |
161 | 1411 |
1412 s->width = width; | |
1413 s->height = height; | |
21 | 1414 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 1415 |
21 | 1416 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 1417 s->h263_long_vectors = s->unrestricted_mv; |
1418 | |
21 | 1419 if (get_bits1(&s->gb) != 0) |
0 | 1420 return -1; /* SAC: off */ |
161 | 1421 if (get_bits1(&s->gb) != 0) { |
1422 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
1423 } | |
1424 | |
21 | 1425 if (get_bits1(&s->gb) != 0) |
0 | 1426 return -1; /* not PB frame */ |
1427 | |
1428 s->qscale = get_bits(&s->gb, 5); | |
21 | 1429 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 1430 } else { |
161 | 1431 int ufep; |
1432 | |
0 | 1433 /* H.263v2 */ |
161 | 1434 s->h263_plus = 1; |
1435 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
1436 | |
1437 if (ufep == 1) { | |
1438 /* OPPTYPE */ | |
1439 format = get_bits(&s->gb, 3); | |
1440 skip_bits(&s->gb,1); /* Custom PCF */ | |
1441 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */ | |
1442 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */ | |
1443 if (get_bits1(&s->gb) != 0) { | |
1444 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
1445 } | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1446 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1447 s->h263_aic = 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1448 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1449 skip_bits(&s->gb, 7); |
161 | 1450 skip_bits(&s->gb, 3); /* Reserved */ |
1451 } else if (ufep != 0) | |
0 | 1452 return -1; |
161 | 1453 |
78 | 1454 /* MPPTYPE */ |
0 | 1455 s->pict_type = get_bits(&s->gb, 3) + 1; |
1456 if (s->pict_type != I_TYPE && | |
1457 s->pict_type != P_TYPE) | |
1458 return -1; | |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
1459 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
1460 s->no_rounding = get_bits1(&s->gb); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
1461 //fprintf(stderr, "\nRTYPE: %d", s->no_rounding); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
1462 skip_bits(&s->gb, 4); |
78 | 1463 |
1464 /* Get the picture dimensions */ | |
161 | 1465 if (ufep) { |
1466 if (format == 6) { | |
1467 /* Custom Picture Format (CPFMT) */ | |
1468 skip_bits(&s->gb, 4); /* aspect ratio */ | |
1469 width = (get_bits(&s->gb, 9) + 1) * 4; | |
1470 skip_bits1(&s->gb); | |
1471 height = get_bits(&s->gb, 9) * 4; | |
78 | 1472 #ifdef DEBUG |
161 | 1473 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height); |
78 | 1474 #endif |
161 | 1475 } |
1476 else { | |
1477 width = h263_format[format][0]; | |
1478 height = h263_format[format][1]; | |
1479 } | |
1480 if ((width == 0) || (height == 0)) | |
1481 return -1; | |
1482 s->width = width; | |
1483 s->height = height; | |
1484 if (s->umvplus_dec) { | |
1485 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
1486 } | |
78 | 1487 } |
1488 | |
0 | 1489 s->qscale = get_bits(&s->gb, 5); |
1490 } | |
1491 /* PEI */ | |
21 | 1492 while (get_bits1(&s->gb) != 0) { |
1493 skip_bits(&s->gb, 8); | |
0 | 1494 } |
1495 s->f_code = 1; | |
1496 return 0; | |
1497 } | |
1498 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1499 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1500 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1501 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1502 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1503 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1504 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1505 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1506 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1507 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1508 int virtual_ref[2][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1509 int w2, h2; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1510 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1511 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1512 int h= s->height; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1513 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1514 for(i=0; i<s->num_sprite_warping_points; i++){ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1515 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1516 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1517 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1518 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1519 if(length){ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1520 x= get_bits(&s->gb, length); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1521 if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1522 x = - (x ^ ((1 << length) - 1)); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1523 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1524 // FIXME the mpeg4 std says that here should be a marker but but divx5 doesnt have one here |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1525 // skip_bits1(&s->gb); /* marker bit */ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1526 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1527 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1528 if(length){ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1529 y=get_bits(&s->gb, length); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1530 if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1531 y = - (y ^ ((1 << length) - 1)); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1532 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1533 skip_bits1(&s->gb); /* marker bit */ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1534 // printf("%d %d\n", x, y); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1535 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1536 d[i][0]= x; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1537 d[i][1]= y; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1538 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1539 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1540 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1541 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1542 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1543 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1544 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1545 // Note, the 4th point isnt used for GMC |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1546 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1547 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1548 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1549 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1550 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1551 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1552 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1553 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1554 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1555 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1556 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1557 // perhaps it should be reordered to be more readable ... |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1558 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1559 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1560 // FIXME rounding (they should be positive but who knows ...) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1561 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1562 + ((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0]) + w/2)/w; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1563 virtual_ref[0][1]= 16*vop_ref[0][1] |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1564 + ((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1]) + w/2)/w; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1565 virtual_ref[1][0]= 16*vop_ref[0][0] |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1566 + ((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0]) + h/2)/h; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1567 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1568 + ((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1]) + h/2)/h; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1569 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1570 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1571 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1572 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1573 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1574 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1575 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1576 s->sprite_offset[1][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1577 s->sprite_delta[0][0][0]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1578 s->sprite_delta[0][0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1579 s->sprite_delta[0][1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1580 s->sprite_delta[0][1][1]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1581 s->sprite_delta[1][0][0]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1582 s->sprite_delta[1][0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1583 s->sprite_delta[1][1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1584 s->sprite_delta[1][1][1]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1585 s->sprite_shift[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1586 s->sprite_shift[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1587 s->sprite_shift[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1588 s->sprite_shift[1][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1589 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1590 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1591 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1592 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1593 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1594 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1595 s->sprite_delta[0][0][0]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1596 s->sprite_delta[0][0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1597 s->sprite_delta[0][1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1598 s->sprite_delta[0][1][1]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1599 s->sprite_delta[1][0][0]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1600 s->sprite_delta[1][0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1601 s->sprite_delta[1][1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1602 s->sprite_delta[1][1][1]= a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1603 s->sprite_shift[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1604 s->sprite_shift[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1605 s->sprite_shift[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1606 s->sprite_shift[1][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1607 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1608 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1609 case 3: //FIXME |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1610 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1611 + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1612 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1613 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1614 + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1615 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1616 s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1617 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1618 +2*w2*r*sprite_ref[0][0] - 16*w2); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1619 s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1620 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1621 +2*w2*r*sprite_ref[0][1] - 16*w2); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1622 s->sprite_delta[0][0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1623 s->sprite_delta[0][0][1]= ( r*sprite_ref[0][1] - virtual_ref[0][1]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1624 s->sprite_delta[0][1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1625 s->sprite_delta[0][1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1626 s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1627 s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1628 s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1629 s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1630 s->sprite_shift[0][0]= alpha+rho; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1631 s->sprite_shift[0][1]= alpha+rho; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1632 s->sprite_shift[1][0]= alpha+rho+2; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1633 s->sprite_shift[1][1]= alpha+rho+2; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1634 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1635 // case 3: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1636 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1637 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1638 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1639 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1640 |
0 | 1641 /* decode mpeg4 VOP header */ |
1642 int mpeg4_decode_picture_header(MpegEncContext * s) | |
1643 { | |
1644 int time_incr, startcode, state, v; | |
1645 | |
1646 redo: | |
1647 /* search next start code */ | |
1648 align_get_bits(&s->gb); | |
1649 state = 0xff; | |
1650 for(;;) { | |
1651 v = get_bits(&s->gb, 8); | |
1652 if (state == 0x000001) { | |
1653 state = ((state << 8) | v) & 0xffffff; | |
1654 startcode = state; | |
1655 break; | |
1656 } | |
1657 state = ((state << 8) | v) & 0xffffff; | |
1658 /* XXX: really detect end of frame */ | |
1659 if (state == 0) | |
1660 return -1; | |
1661 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1662 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb)); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1663 if (startcode == 0x120) { // Video Object Layer |
63 | 1664 int time_increment_resolution, width, height, vo_ver_id; |
0 | 1665 |
1666 /* vol header */ | |
21 | 1667 skip_bits(&s->gb, 1); /* random access */ |
1668 skip_bits(&s->gb, 8); /* vo_type */ | |
63 | 1669 if (get_bits1(&s->gb) != 0) { /* is_ol_id */ |
1670 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */ | |
1671 skip_bits(&s->gb, 3); /* vo_priority */ | |
1672 } else { | |
1673 vo_ver_id = 1; | |
1674 } | |
0 | 1675 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1676 s->aspect_ratio_info= get_bits(&s->gb, 4); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1677 if(s->aspect_ratio_info == EXTENDET_PAR){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1678 skip_bits(&s->gb, 8); //par_width |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1679 skip_bits(&s->gb, 8); // par_height |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1680 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1681 if(get_bits1(&s->gb)){ /* vol control parameter */ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1682 printf("vol control parameter not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1683 return -1; |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1684 } |
63 | 1685 s->shape = get_bits(&s->gb, 2); /* vol shape */ |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1686 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1687 printf("Gray shape not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1688 skip_bits(&s->gb, 4); //video_object_layer_shape_extension |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1689 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1690 |
21 | 1691 skip_bits1(&s->gb); /* marker */ |
0 | 1692 |
1693 time_increment_resolution = get_bits(&s->gb, 16); | |
70 | 1694 s->time_increment_bits = av_log2(time_increment_resolution - 1) + 1; |
63 | 1695 if (s->time_increment_bits < 1) |
1696 s->time_increment_bits = 1; | |
21 | 1697 skip_bits1(&s->gb); /* marker */ |
0 | 1698 |
63 | 1699 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */ |
1700 skip_bits(&s->gb, s->time_increment_bits); | |
1701 } | |
0 | 1702 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1703 if (s->shape != BIN_ONLY_SHAPE) { |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1704 if (s->shape == RECT_SHAPE) { |
63 | 1705 skip_bits1(&s->gb); /* marker */ |
1706 width = get_bits(&s->gb, 13); | |
1707 skip_bits1(&s->gb); /* marker */ | |
1708 height = get_bits(&s->gb, 13); | |
1709 skip_bits1(&s->gb); /* marker */ | |
1710 } | |
1711 | |
1712 skip_bits1(&s->gb); /* interlaced */ | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1713 if(!get_bits1(&s->gb)) printf("OBMC not supported\n"); /* OBMC Disable */ |
63 | 1714 if (vo_ver_id == 1) { |
1715 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */ | |
1716 } else { | |
1717 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */ | |
1718 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1719 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n"); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1720 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1721 if(s->vol_sprite_usage==STATIC_SPRITE){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1722 s->sprite_width = get_bits(&s->gb, 13); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1723 skip_bits1(&s->gb); /* marker */ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1724 s->sprite_height= get_bits(&s->gb, 13); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1725 skip_bits1(&s->gb); /* marker */ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1726 s->sprite_left = get_bits(&s->gb, 13); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1727 skip_bits1(&s->gb); /* marker */ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1728 s->sprite_top = get_bits(&s->gb, 13); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1729 skip_bits1(&s->gb); /* marker */ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1730 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1731 s->num_sprite_warping_points= get_bits(&s->gb, 6); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1732 s->sprite_warping_accuracy = get_bits(&s->gb, 2); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1733 s->sprite_brightness_change= get_bits1(&s->gb); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1734 if(s->vol_sprite_usage==STATIC_SPRITE) |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1735 s->low_latency_sprite= get_bits1(&s->gb); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1736 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1737 // FIXME sadct disable bit if verid!=1 && shape not rect |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1738 |
63 | 1739 if (get_bits1(&s->gb) == 1) { /* not_8_bit */ |
1740 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */ | |
1741 skip_bits(&s->gb, 4); /* bits_per_pixel */ | |
1742 } else { | |
1743 s->quant_precision = 5; | |
1744 } | |
1745 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1746 // FIXME a bunch of grayscale shape things |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1747 if(get_bits1(&s->gb)) printf("Quant-Type not supported\n"); /* vol_quant_type */ //FIXME |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1748 if(vo_ver_id != 1) |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1749 s->quarter_sample= get_bits1(&s->gb); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1750 else s->quarter_sample=0; |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1751 if(s->quarter_sample) printf("Quarter sample not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1752 #if 0 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1753 if(get_bits1(&s->gb)) printf("Complexity est disabled\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1754 if(get_bits1(&s->gb)) printf("resync disable\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1755 #else |
63 | 1756 skip_bits1(&s->gb); /* complexity_estimation_disabled */ |
1757 skip_bits1(&s->gb); /* resync_marker_disabled */ | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1758 #endif |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1759 s->data_partioning= get_bits1(&s->gb); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1760 if(s->data_partioning){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1761 printf("data partitioning not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1762 skip_bits1(&s->gb); // reversible vlc |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1763 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1764 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1765 if(vo_ver_id != 1) { |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1766 s->new_pred= get_bits1(&s->gb); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1767 if(s->new_pred){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1768 printf("new pred not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1769 skip_bits(&s->gb, 2); /* requested upstream message type */ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1770 skip_bits1(&s->gb); /* newpred segment type */ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1771 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1772 s->reduced_res_vop= get_bits1(&s->gb); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1773 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1774 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1775 else{ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1776 s->new_pred=0; |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1777 s->reduced_res_vop= 0; |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1778 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1779 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1780 s->scalability= get_bits1(&s->gb); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1781 if (s->scalability) { |
63 | 1782 printf("bad scalability!!!\n"); |
1783 return -1; | |
1784 } | |
1785 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1786 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7); |
0 | 1787 goto redo; |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1788 } else if (startcode == 0x1b2) { //userdata |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1789 //printf("user Data %X\n", show_bits(&s->gb, 32)); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1790 goto redo; |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1791 } else if (startcode != 0x1b6) { //VOP |
0 | 1792 goto redo; |
1793 } | |
1794 | |
1795 s->pict_type = get_bits(&s->gb, 2) + 1; /* pict type: I = 0 , P = 1 */ | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1796 if(s->pict_type == B_TYPE) |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1797 { |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1798 printf("B-VOP\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1799 return -1; |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1800 } |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1801 if(s->pict_type == S_TYPE) |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1802 { |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1803 printf("S-VOP\n"); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1804 // return -1; |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1805 } |
0 | 1806 |
1807 /* XXX: parse time base */ | |
1808 time_incr = 0; | |
21 | 1809 while (get_bits1(&s->gb) != 0) |
0 | 1810 time_incr++; |
1811 | |
21 | 1812 skip_bits1(&s->gb); /* marker */ |
1813 skip_bits(&s->gb, s->time_increment_bits); | |
1814 skip_bits1(&s->gb); /* marker */ | |
0 | 1815 /* vop coded */ |
21 | 1816 if (get_bits1(&s->gb) != 1) |
63 | 1817 goto redo; |
0 | 1818 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1819 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1820 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { |
0 | 1821 /* rounding type for motion estimation */ |
21 | 1822 s->no_rounding = get_bits1(&s->gb); |
63 | 1823 } else { |
1824 s->no_rounding = 0; | |
0 | 1825 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1826 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1827 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1828 if (s->shape != RECT_SHAPE) { |
63 | 1829 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { |
1830 int width, height, hor_spat_ref, ver_spat_ref; | |
1831 | |
1832 width = get_bits(&s->gb, 13); | |
1833 skip_bits1(&s->gb); /* marker */ | |
1834 height = get_bits(&s->gb, 13); | |
1835 skip_bits1(&s->gb); /* marker */ | |
1836 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */ | |
1837 skip_bits1(&s->gb); /* marker */ | |
1838 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */ | |
1839 } | |
1840 skip_bits1(&s->gb); /* change_CR_disable */ | |
1841 | |
1842 if (get_bits1(&s->gb) != 0) { | |
1843 skip_bits(&s->gb, 8); /* constant_alpha_value */ | |
1844 } | |
1845 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1846 //FIXME complexity estimation stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1847 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1848 if (s->shape != BIN_ONLY_SHAPE) { |
63 | 1849 skip_bits(&s->gb, 3); /* intra dc VLC threshold */ |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1850 //FIXME interlaced specific bits |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1851 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1852 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1853 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1854 if(s->num_sprite_warping_points){ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1855 mpeg4_decode_sprite_trajectory(s); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1856 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1857 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1858 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1859 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1860 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1861 if (s->shape != BIN_ONLY_SHAPE) { |
63 | 1862 /* note: we do not use quant_precision to avoid problem if no |
1863 MPEG4 vol header as it is found on some old opendivx | |
1864 movies */ | |
1865 s->qscale = get_bits(&s->gb, 5); | |
1866 | |
1867 if (s->pict_type != I_TYPE) { | |
1868 s->f_code = get_bits(&s->gb, 3); /* fcode_for */ | |
1869 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1870 if (s->pict_type == B_TYPE) { |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1871 s->b_code = get_bits(&s->gb, 3); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1872 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
1873 //printf("quant:%d fcode:%d\n", s->qscale, s->f_code); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1874 if(!s->scalability){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1875 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) { |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1876 skip_bits1(&s->gb); // vop shape coding type |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1877 } |
63 | 1878 } |
1879 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
1880 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7); |
63 | 1881 return 0; |
0 | 1882 } |
1883 | |
1884 /* don't understand why they choose a different header ! */ | |
1885 int intel_h263_decode_picture_header(MpegEncContext *s) | |
1886 { | |
1887 int format; | |
1888 | |
1889 /* picture header */ | |
1890 if (get_bits(&s->gb, 22) != 0x20) | |
1891 return -1; | |
21 | 1892 skip_bits(&s->gb, 8); /* picture timestamp */ |
0 | 1893 |
21 | 1894 if (get_bits1(&s->gb) != 1) |
0 | 1895 return -1; /* marker */ |
21 | 1896 if (get_bits1(&s->gb) != 0) |
0 | 1897 return -1; /* h263 id */ |
21 | 1898 skip_bits1(&s->gb); /* split screen off */ |
1899 skip_bits1(&s->gb); /* camera off */ | |
1900 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 1901 |
1902 format = get_bits(&s->gb, 3); | |
1903 if (format != 7) | |
1904 return -1; | |
1905 | |
1906 s->h263_plus = 0; | |
1907 | |
21 | 1908 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 1909 |
21 | 1910 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 1911 s->h263_long_vectors = s->unrestricted_mv; |
1912 | |
21 | 1913 if (get_bits1(&s->gb) != 0) |
0 | 1914 return -1; /* SAC: off */ |
21 | 1915 if (get_bits1(&s->gb) != 0) |
0 | 1916 return -1; /* advanced prediction mode: off */ |
21 | 1917 if (get_bits1(&s->gb) != 0) |
0 | 1918 return -1; /* not PB frame */ |
1919 | |
1920 /* skip unknown header garbage */ | |
21 | 1921 skip_bits(&s->gb, 41); |
0 | 1922 |
1923 s->qscale = get_bits(&s->gb, 5); | |
21 | 1924 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 1925 |
1926 /* PEI */ | |
21 | 1927 while (get_bits1(&s->gb) != 0) { |
1928 skip_bits(&s->gb, 8); | |
0 | 1929 } |
1930 s->f_code = 1; | |
1931 return 0; | |
1932 } | |
144 | 1933 |