Mercurial > libavcodec.hg
annotate h263.c @ 241:4bb6289eff93 libavcodec
avoid overflow of picturenumber*fps*10000
bug found by Lennert Buytenhek <buytenh@gnu.org>
author | michaelni |
---|---|
date | Mon, 18 Feb 2002 01:58:00 +0000 |
parents | 5fc0c3af3fe4 |
children | a023f78e0cc2 |
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 | |
276 static inline int mid_pred(int a, int b, int c) | |
277 { | |
278 int vmin, vmax; | |
279 vmin = a; | |
280 if (b < vmin) | |
281 vmin = b; | |
282 if (c < vmin) | |
283 vmin = c; | |
284 | |
285 vmax = a; | |
286 if (b > vmax) | |
287 vmax = b; | |
288 if (c > vmax) | |
289 vmax = c; | |
290 | |
291 return a + b + c - vmin - vmax; | |
292 } | |
293 | |
294 INT16 *h263_pred_motion(MpegEncContext * s, int block, | |
295 int *px, int *py) | |
296 { | |
297 int x, y, wrap; | |
298 INT16 *A, *B, *C, *mot_val; | |
299 | |
300 x = 2 * s->mb_x + 1 + (block & 1); | |
301 y = 2 * s->mb_y + 1 + ((block >> 1) & 1); | |
302 wrap = 2 * s->mb_width + 2; | |
303 | |
304 mot_val = s->motion_val[(x) + (y) * wrap]; | |
305 | |
306 /* 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
|
307 if (y == 1 || s->first_slice_line || s->first_gob_line) { |
0 | 308 A = s->motion_val[(x-1) + (y) * wrap]; |
309 *px = A[0]; | |
310 *py = A[1]; | |
311 } else { | |
312 switch(block) { | |
313 default: | |
314 case 0: | |
315 A = s->motion_val[(x-1) + (y) * wrap]; | |
316 B = s->motion_val[(x) + (y-1) * wrap]; | |
317 C = s->motion_val[(x+2) + (y-1) * wrap]; | |
318 break; | |
319 case 1: | |
320 case 2: | |
321 A = s->motion_val[(x-1) + (y) * wrap]; | |
322 B = s->motion_val[(x) + (y-1) * wrap]; | |
323 C = s->motion_val[(x+1) + (y-1) * wrap]; | |
324 break; | |
325 case 3: | |
326 A = s->motion_val[(x-1) + (y) * wrap]; | |
327 B = s->motion_val[(x-1) + (y-1) * wrap]; | |
328 C = s->motion_val[(x) + (y-1) * wrap]; | |
329 break; | |
330 } | |
331 *px = mid_pred(A[0], B[0], C[0]); | |
332 *py = mid_pred(A[1], B[1], C[1]); | |
333 } | |
334 return mot_val; | |
335 } | |
336 | |
337 | |
338 static void h263_encode_motion(MpegEncContext * s, int val) | |
339 { | |
340 int range, l, m, bit_size, sign, code, bits; | |
341 | |
342 if (val == 0) { | |
343 /* zero vector */ | |
344 code = 0; | |
345 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
346 } else { | |
347 bit_size = s->f_code - 1; | |
348 range = 1 << bit_size; | |
349 /* modulo encoding */ | |
350 l = range * 32; | |
351 m = 2 * l; | |
352 if (val < -l) { | |
353 val += m; | |
354 } else if (val >= l) { | |
355 val -= m; | |
356 } | |
357 | |
358 if (val >= 0) { | |
359 val--; | |
360 code = (val >> bit_size) + 1; | |
361 bits = val & (range - 1); | |
362 sign = 0; | |
363 } else { | |
364 val = -val; | |
365 val--; | |
366 code = (val >> bit_size) + 1; | |
367 bits = val & (range - 1); | |
368 sign = 1; | |
369 } | |
370 | |
371 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); | |
372 if (bit_size > 0) { | |
373 put_bits(&s->pb, bit_size, bits); | |
374 } | |
375 } | |
376 } | |
377 | |
78 | 378 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
379 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
380 { | |
381 short sval = 0; | |
382 short i = 0; | |
383 short n_bits = 0; | |
384 short temp_val; | |
385 int code = 0; | |
386 int tcode; | |
387 | |
388 if ( val == 0) | |
389 put_bits(&s->pb, 1, 1); | |
390 else if (val == 1) | |
391 put_bits(&s->pb, 3, 0); | |
392 else if (val == -1) | |
393 put_bits(&s->pb, 3, 2); | |
394 else { | |
395 | |
396 sval = ((val < 0) ? (short)(-val):(short)val); | |
397 temp_val = sval; | |
398 | |
399 while (temp_val != 0) { | |
400 temp_val = temp_val >> 1; | |
401 n_bits++; | |
402 } | |
403 | |
404 i = n_bits - 1; | |
405 while (i > 0) { | |
406 tcode = (sval & (1 << (i-1))) >> (i-1); | |
407 tcode = (tcode << 1) | 1; | |
408 code = (code << 2) | tcode; | |
409 i--; | |
410 } | |
411 code = ((code << 1) | (val < 0)) << 1; | |
412 put_bits(&s->pb, (2*n_bits)+1, code); | |
413 //printf("\nVal = %d\tCode = %d", sval, code); | |
414 } | |
415 } | |
416 | |
0 | 417 void h263_encode_init_vlc(MpegEncContext *s) |
418 { | |
419 static int done = 0; | |
420 | |
421 if (!done) { | |
422 done = 1; | |
423 init_rl(&rl_inter); | |
424 init_rl(&rl_intra); | |
425 } | |
426 } | |
427 | |
428 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) | |
429 { | |
430 int level, run, last, i, j, last_index, last_non_zero, sign, slevel; | |
431 int code; | |
432 RLTable *rl = &rl_inter; | |
433 | |
434 if (s->mb_intra) { | |
231 | 435 /* DC coef */ |
436 level = block[0]; | |
0 | 437 /* 255 cannot be represented, so we clamp */ |
438 if (level > 254) { | |
439 level = 254; | |
440 block[0] = 254; | |
441 } | |
231 | 442 /* 0 cannot be represented also */ |
443 else if (!level) { | |
444 level = 1; | |
445 block[0] = 1; | |
446 } | |
447 if (level == 128) | |
448 put_bits(&s->pb, 8, 0xff); | |
449 else | |
450 put_bits(&s->pb, 8, level & 0xff); | |
451 i = 1; | |
0 | 452 } else { |
231 | 453 i = 0; |
0 | 454 } |
455 | |
456 /* AC coefs */ | |
457 last_index = s->block_last_index[n]; | |
458 last_non_zero = i - 1; | |
459 for (; i <= last_index; i++) { | |
460 j = zigzag_direct[i]; | |
461 level = block[j]; | |
462 if (level) { | |
463 run = i - last_non_zero - 1; | |
464 last = (i == last_index); | |
465 sign = 0; | |
466 slevel = level; | |
467 if (level < 0) { | |
468 sign = 1; | |
469 level = -level; | |
470 } | |
471 code = get_rl_index(rl, last, run, level); | |
472 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
473 if (code == rl->n) { | |
474 put_bits(&s->pb, 1, last); | |
475 put_bits(&s->pb, 6, run); | |
476 put_bits(&s->pb, 8, slevel & 0xff); | |
477 } else { | |
478 put_bits(&s->pb, 1, sign); | |
479 } | |
480 last_non_zero = i; | |
481 } | |
482 } | |
483 } | |
484 | |
485 /***************************************************/ | |
486 | |
487 /* write mpeg4 VOP header */ | |
488 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
489 { | |
490 align_put_bits(&s->pb); | |
491 | |
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
|
492 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
|
493 put_bits(&s->pb, 16, 0x1B6); /* vop header */ |
0 | 494 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
495 /* XXX: time base + 1 not always correct */ | |
496 put_bits(&s->pb, 1, 1); | |
497 put_bits(&s->pb, 1, 0); | |
498 | |
499 put_bits(&s->pb, 1, 1); /* marker */ | |
500 put_bits(&s->pb, 4, 1); /* XXX: correct time increment */ | |
501 put_bits(&s->pb, 1, 1); /* marker */ | |
502 put_bits(&s->pb, 1, 1); /* vop coded */ | |
503 if (s->pict_type == P_TYPE) { | |
504 s->no_rounding = 0; | |
505 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ | |
506 } | |
507 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
508 | |
509 put_bits(&s->pb, 5, s->qscale); | |
510 | |
511 if (s->pict_type != I_TYPE) | |
512 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ | |
513 // printf("****frame %d\n", picture_number); | |
514 } | |
515 | |
516 void h263_dc_scale(MpegEncContext * s) | |
517 { | |
518 int quant; | |
519 | |
520 quant = s->qscale; | |
521 /* luminance */ | |
522 if (quant < 5) | |
523 s->y_dc_scale = 8; | |
524 else if (quant > 4 && quant < 9) | |
525 s->y_dc_scale = (2 * quant); | |
526 else if (quant > 8 && quant < 25) | |
527 s->y_dc_scale = (quant + 8); | |
528 else | |
529 s->y_dc_scale = (2 * quant - 16); | |
530 /* chrominance */ | |
531 if (quant < 5) | |
532 s->c_dc_scale = 8; | |
533 else if (quant > 4 && quant < 25) | |
534 s->c_dc_scale = ((quant + 13) / 2); | |
535 else | |
536 s->c_dc_scale = (quant - 6); | |
537 } | |
538 | |
539 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) | |
540 { | |
541 int a, b, c, x, y, wrap, pred, scale; | |
542 UINT16 *dc_val; | |
543 | |
544 /* find prediction */ | |
545 if (n < 4) { | |
546 x = 2 * s->mb_x + 1 + (n & 1); | |
547 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); | |
548 wrap = s->mb_width * 2 + 2; | |
549 dc_val = s->dc_val[0]; | |
550 scale = s->y_dc_scale; | |
551 } else { | |
552 x = s->mb_x + 1; | |
553 y = s->mb_y + 1; | |
554 wrap = s->mb_width + 2; | |
555 dc_val = s->dc_val[n - 4 + 1]; | |
556 scale = s->c_dc_scale; | |
557 } | |
558 | |
559 /* B C | |
560 * A X | |
561 */ | |
562 a = dc_val[(x - 1) + (y) * wrap]; | |
563 b = dc_val[(x - 1) + (y - 1) * wrap]; | |
564 c = dc_val[(x) + (y - 1) * wrap]; | |
565 | |
566 if (abs(a - b) < abs(b - c)) { | |
567 pred = c; | |
568 *dir_ptr = 1; /* top */ | |
569 } else { | |
570 pred = a; | |
571 *dir_ptr = 0; /* left */ | |
572 } | |
573 /* we assume pred is positive */ | |
574 pred = (pred + (scale >> 1)) / scale; | |
575 | |
576 /* prepare address for prediction update */ | |
577 *dc_val_ptr = &dc_val[(x) + (y) * wrap]; | |
578 | |
579 return pred; | |
580 } | |
581 | |
174
ac5075a55488
new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents:
162
diff
changeset
|
582 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n, |
0 | 583 int dir) |
584 { | |
585 int x, y, wrap, i; | |
586 INT16 *ac_val, *ac_val1; | |
587 | |
588 /* find prediction */ | |
589 if (n < 4) { | |
590 x = 2 * s->mb_x + 1 + (n & 1); | |
591 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); | |
592 wrap = s->mb_width * 2 + 2; | |
593 ac_val = s->ac_val[0][0]; | |
594 } else { | |
595 x = s->mb_x + 1; | |
596 y = s->mb_y + 1; | |
597 wrap = s->mb_width + 2; | |
598 ac_val = s->ac_val[n - 4 + 1][0]; | |
599 } | |
600 ac_val += ((y) * wrap + (x)) * 16; | |
601 ac_val1 = ac_val; | |
602 if (s->ac_pred) { | |
603 if (dir == 0) { | |
604 /* left prediction */ | |
605 ac_val -= 16; | |
606 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
|
607 block[block_permute_op(i*8)] += ac_val[i]; |
0 | 608 } |
609 } else { | |
610 /* top prediction */ | |
611 ac_val -= 16 * wrap; | |
612 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
|
613 block[block_permute_op(i)] += ac_val[i + 8]; |
0 | 614 } |
615 } | |
616 } | |
617 /* left copy */ | |
618 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
|
619 ac_val1[i] = block[block_permute_op(i * 8)]; |
0 | 620 /* top copy */ |
621 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
|
622 ac_val1[8 + i] = block[block_permute_op(i)]; |
0 | 623 } |
624 | |
625 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) | |
626 { | |
627 int size, v, pred; | |
628 UINT16 *dc_val; | |
629 | |
630 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
631 if (n < 4) { | |
632 *dc_val = level * s->y_dc_scale; | |
633 } else { | |
634 *dc_val = level * s->c_dc_scale; | |
635 } | |
636 | |
637 /* do the prediction */ | |
638 level -= pred; | |
639 /* find number of bits */ | |
640 size = 0; | |
641 v = abs(level); | |
642 while (v) { | |
643 v >>= 1; | |
644 size++; | |
645 } | |
646 | |
647 if (n < 4) { | |
648 /* luminance */ | |
649 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
650 } else { | |
651 /* chrominance */ | |
652 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
653 } | |
654 | |
655 /* encode remaining bits */ | |
656 if (size > 0) { | |
657 if (level < 0) | |
658 level = (-level) ^ ((1 << size) - 1); | |
659 put_bits(&s->pb, size, level); | |
660 if (size > 8) | |
661 put_bits(&s->pb, 1, 1); | |
662 } | |
663 } | |
664 | |
665 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) | |
666 { | |
667 int level, run, last, i, j, last_index, last_non_zero, sign, slevel; | |
668 int code, dc_pred_dir; | |
669 const RLTable *rl; | |
670 | |
671 if (s->mb_intra) { | |
672 /* mpeg4 based DC predictor */ | |
673 mpeg4_encode_dc(s, block[0], n, &dc_pred_dir); | |
674 i = 1; | |
675 rl = &rl_intra; | |
676 } else { | |
677 i = 0; | |
678 rl = &rl_inter; | |
679 } | |
680 | |
681 /* AC coefs */ | |
682 last_index = s->block_last_index[n]; | |
683 last_non_zero = i - 1; | |
684 for (; i <= last_index; i++) { | |
685 j = zigzag_direct[i]; | |
686 level = block[j]; | |
687 if (level) { | |
688 run = i - last_non_zero - 1; | |
689 last = (i == last_index); | |
690 sign = 0; | |
691 slevel = level; | |
692 if (level < 0) { | |
693 sign = 1; | |
694 level = -level; | |
695 } | |
696 code = get_rl_index(rl, last, run, level); | |
697 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
698 if (code == rl->n) { | |
699 int level1, run1; | |
700 level1 = level - rl->max_level[last][run]; | |
701 if (level1 < 1) | |
702 goto esc2; | |
703 code = get_rl_index(rl, last, run, level1); | |
704 if (code == rl->n) { | |
705 esc2: | |
706 put_bits(&s->pb, 1, 1); | |
707 if (level > MAX_LEVEL) | |
708 goto esc3; | |
709 run1 = run - rl->max_run[last][level] - 1; | |
710 if (run1 < 0) | |
711 goto esc3; | |
712 code = get_rl_index(rl, last, run1, level); | |
713 if (code == rl->n) { | |
714 esc3: | |
715 /* third escape */ | |
716 put_bits(&s->pb, 1, 1); | |
717 put_bits(&s->pb, 1, last); | |
718 put_bits(&s->pb, 6, run); | |
719 put_bits(&s->pb, 1, 1); | |
720 put_bits(&s->pb, 12, slevel & 0xfff); | |
721 put_bits(&s->pb, 1, 1); | |
722 } else { | |
723 /* second escape */ | |
724 put_bits(&s->pb, 1, 0); | |
725 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
726 put_bits(&s->pb, 1, sign); | |
727 } | |
728 } else { | |
729 /* first escape */ | |
730 put_bits(&s->pb, 1, 0); | |
731 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
732 put_bits(&s->pb, 1, sign); | |
733 } | |
734 } else { | |
735 put_bits(&s->pb, 1, sign); | |
736 } | |
737 last_non_zero = i; | |
738 } | |
739 } | |
740 } | |
741 | |
742 | |
743 | |
744 /***********************************************/ | |
745 /* decoding */ | |
746 | |
747 static VLC intra_MCBPC_vlc; | |
748 static VLC inter_MCBPC_vlc; | |
749 static VLC cbpy_vlc; | |
750 static VLC mv_vlc; | |
751 static VLC dc_lum, dc_chrom; | |
752 | |
753 void init_rl(RLTable *rl) | |
754 { | |
755 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; | |
756 UINT8 index_run[MAX_RUN+1]; | |
757 int last, run, level, start, end, i; | |
758 | |
759 /* compute max_level[], max_run[] and index_run[] */ | |
760 for(last=0;last<2;last++) { | |
761 if (last == 0) { | |
762 start = 0; | |
763 end = rl->last; | |
764 } else { | |
765 start = rl->last; | |
766 end = rl->n; | |
767 } | |
768 | |
769 memset(max_level, 0, MAX_RUN + 1); | |
770 memset(max_run, 0, MAX_LEVEL + 1); | |
771 memset(index_run, rl->n, MAX_RUN + 1); | |
772 for(i=start;i<end;i++) { | |
773 run = rl->table_run[i]; | |
774 level = rl->table_level[i]; | |
775 if (index_run[run] == rl->n) | |
776 index_run[run] = i; | |
777 if (level > max_level[run]) | |
778 max_level[run] = level; | |
779 if (run > max_run[level]) | |
780 max_run[level] = run; | |
781 } | |
782 rl->max_level[last] = malloc(MAX_RUN + 1); | |
783 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); | |
784 rl->max_run[last] = malloc(MAX_LEVEL + 1); | |
785 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); | |
786 rl->index_run[last] = malloc(MAX_RUN + 1); | |
787 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); | |
788 } | |
789 } | |
790 | |
791 void init_vlc_rl(RLTable *rl) | |
792 { | |
793 init_vlc(&rl->vlc, 9, rl->n + 1, | |
794 &rl->table_vlc[0][1], 4, 2, | |
795 &rl->table_vlc[0][0], 4, 2); | |
796 } | |
797 | |
798 /* init vlcs */ | |
799 | |
800 /* XXX: find a better solution to handle static init */ | |
801 void h263_decode_init_vlc(MpegEncContext *s) | |
802 { | |
803 static int done = 0; | |
804 | |
805 if (!done) { | |
806 done = 1; | |
807 | |
808 init_vlc(&intra_MCBPC_vlc, 6, 8, | |
809 intra_MCBPC_bits, 1, 1, | |
810 intra_MCBPC_code, 1, 1); | |
161 | 811 init_vlc(&inter_MCBPC_vlc, 9, 25, |
0 | 812 inter_MCBPC_bits, 1, 1, |
813 inter_MCBPC_code, 1, 1); | |
814 init_vlc(&cbpy_vlc, 6, 16, | |
815 &cbpy_tab[0][1], 2, 1, | |
816 &cbpy_tab[0][0], 2, 1); | |
817 init_vlc(&mv_vlc, 9, 33, | |
818 &mvtab[0][1], 2, 1, | |
819 &mvtab[0][0], 2, 1); | |
820 init_rl(&rl_inter); | |
821 init_rl(&rl_intra); | |
822 init_vlc_rl(&rl_inter); | |
823 init_vlc_rl(&rl_intra); | |
824 init_vlc(&dc_lum, 9, 13, | |
825 &DCtab_lum[0][1], 2, 1, | |
826 &DCtab_lum[0][0], 2, 1); | |
827 init_vlc(&dc_chrom, 9, 13, | |
828 &DCtab_chrom[0][1], 2, 1, | |
829 &DCtab_chrom[0][0], 2, 1); | |
830 } | |
831 } | |
832 | |
162 | 833 int h263_decode_gob_header(MpegEncContext *s) |
834 { | |
835 unsigned int val, gfid; | |
836 | |
837 /* Check for GOB Start Code */ | |
838 val = show_bits(&s->gb, 16); | |
839 if (val == 0) { | |
840 /* We have a GBSC probably with GSTUFF */ | |
841 skip_bits(&s->gb, 16); /* Drop the zeros */ | |
842 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */ | |
843 #ifdef DEBUG | |
844 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x); | |
845 #endif | |
846 s->gob_number = get_bits(&s->gb, 5); /* GN */ | |
847 gfid = get_bits(&s->gb, 2); /* GFID */ | |
848 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
849 #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
|
850 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale); |
162 | 851 #endif |
852 return 1; | |
853 } | |
854 return 0; | |
855 | |
856 } | |
857 | |
0 | 858 int h263_decode_mb(MpegEncContext *s, |
859 DCTELEM block[6][64]) | |
860 { | |
861 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
862 INT16 *mot_val; | |
110 | 863 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
|
864 |
0 | 865 if (s->pict_type == P_TYPE) { |
21 | 866 if (get_bits1(&s->gb)) { |
0 | 867 /* skip mb */ |
868 s->mb_intra = 0; | |
869 for(i=0;i<6;i++) | |
870 s->block_last_index[i] = -1; | |
871 s->mv_dir = MV_DIR_FORWARD; | |
872 s->mv_type = MV_TYPE_16X16; | |
873 s->mv[0][0][0] = 0; | |
874 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
|
875 s->mb_skiped = 1; |
0 | 876 return 0; |
877 } | |
878 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc); | |
144 | 879 //fprintf(stderr, "\tCBPC: %d", cbpc); |
0 | 880 if (cbpc < 0) |
881 return -1; | |
161 | 882 if (cbpc > 20) |
883 cbpc+=3; | |
884 else if (cbpc == 20) | |
885 fprintf(stderr, "Stuffing !"); | |
144 | 886 |
0 | 887 dquant = cbpc & 8; |
888 s->mb_intra = ((cbpc & 4) != 0); | |
889 } else { | |
890 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc); | |
891 if (cbpc < 0) | |
892 return -1; | |
893 dquant = cbpc & 4; | |
894 s->mb_intra = 1; | |
895 } | |
896 | |
897 if (!s->mb_intra) { | |
898 cbpy = get_vlc(&s->gb, &cbpy_vlc); | |
899 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2); | |
900 if (dquant) { | |
901 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
902 if (s->qscale < 1) | |
903 s->qscale = 1; | |
904 else if (s->qscale > 31) | |
905 s->qscale = 31; | |
906 } | |
907 s->mv_dir = MV_DIR_FORWARD; | |
908 if ((cbpc & 16) == 0) { | |
909 /* 16x16 motion prediction */ | |
910 s->mv_type = MV_TYPE_16X16; | |
911 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
|
912 if (s->umvplus_dec) |
78 | 913 mx = h263p_decode_umotion(s, pred_x); |
914 else | |
915 mx = h263_decode_motion(s, pred_x); | |
0 | 916 if (mx >= 0xffff) |
917 return -1; | |
78 | 918 |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
919 if (s->umvplus_dec) |
78 | 920 my = h263p_decode_umotion(s, pred_y); |
921 else | |
922 my = h263_decode_motion(s, pred_y); | |
0 | 923 if (my >= 0xffff) |
924 return -1; | |
925 s->mv[0][0][0] = mx; | |
926 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
|
927 /*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
|
928 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
|
929 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
|
930 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1) |
78 | 931 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
932 | |
0 | 933 } else { |
934 s->mv_type = MV_TYPE_8X8; | |
935 for(i=0;i<4;i++) { | |
936 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
|
937 if (s->umvplus_dec) |
78 | 938 mx = h263p_decode_umotion(s, pred_x); |
939 else | |
940 mx = h263_decode_motion(s, pred_x); | |
0 | 941 if (mx >= 0xffff) |
942 return -1; | |
78 | 943 |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
944 if (s->umvplus_dec) |
78 | 945 my = h263p_decode_umotion(s, pred_y); |
946 else | |
947 my = h263_decode_motion(s, pred_y); | |
0 | 948 if (my >= 0xffff) |
949 return -1; | |
950 s->mv[0][i][0] = mx; | |
951 s->mv[0][i][1] = my; | |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
952 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1) |
78 | 953 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
0 | 954 mot_val[0] = mx; |
955 mot_val[1] = my; | |
956 } | |
957 } | |
958 } else { | |
959 s->ac_pred = 0; | |
144 | 960 if (s->h263_pred) { |
21 | 961 s->ac_pred = get_bits1(&s->gb); |
0 | 962 } |
963 cbpy = get_vlc(&s->gb, &cbpy_vlc); | |
964 cbp = (cbpc & 3) | (cbpy << 2); | |
965 if (dquant) { | |
966 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
967 if (s->qscale < 1) | |
968 s->qscale = 1; | |
969 else if (s->qscale > 31) | |
970 s->qscale = 31; | |
971 } | |
972 } | |
973 | |
974 /* decode each block */ | |
975 if (s->h263_pred) { | |
976 for (i = 0; i < 6; i++) { | |
977 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0) | |
978 return -1; | |
979 } | |
980 } else { | |
981 for (i = 0; i < 6; i++) { | |
982 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0) | |
983 return -1; | |
984 } | |
985 } | |
986 return 0; | |
987 } | |
988 | |
989 static int h263_decode_motion(MpegEncContext * s, int pred) | |
990 { | |
991 int code, val, sign, shift, l, m; | |
992 | |
993 code = get_vlc(&s->gb, &mv_vlc); | |
994 if (code < 0) | |
995 return 0xffff; | |
996 | |
997 if (code == 0) | |
998 return pred; | |
21 | 999 sign = get_bits1(&s->gb); |
0 | 1000 shift = s->f_code - 1; |
1001 val = (code - 1) << shift; | |
1002 if (shift > 0) | |
1003 val |= get_bits(&s->gb, shift); | |
1004 val++; | |
1005 if (sign) | |
1006 val = -val; | |
1007 val += pred; | |
1008 | |
1009 /* modulo decoding */ | |
1010 if (!s->h263_long_vectors) { | |
1011 l = (1 << (s->f_code - 1)) * 32; | |
1012 m = 2 * l; | |
1013 if (val < -l) { | |
1014 val += m; | |
1015 } else if (val >= l) { | |
1016 val -= m; | |
1017 } | |
1018 } else { | |
1019 /* horrible h263 long vector mode */ | |
1020 if (pred < -31 && val < -63) | |
1021 val += 64; | |
1022 if (pred > 32 && val > 63) | |
1023 val -= 64; | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
1024 |
0 | 1025 } |
1026 return val; | |
1027 } | |
1028 | |
78 | 1029 /* Decodes RVLC of H.263+ UMV */ |
1030 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
1031 { | |
1032 int code = 0, sign; | |
1033 | |
1034 if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
1035 return pred; | |
1036 | |
1037 code = 2 + get_bits1(&s->gb); | |
1038 | |
1039 while (get_bits1(&s->gb)) | |
1040 { | |
1041 code <<= 1; | |
1042 code += get_bits1(&s->gb); | |
1043 } | |
1044 sign = code & 1; | |
1045 code >>= 1; | |
1046 | |
1047 code = (sign) ? (pred - code) : (pred + code); | |
1048 #ifdef DEBUG | |
1049 fprintf(stderr,"H.263+ UMV Motion = %d\n", code); | |
1050 #endif | |
1051 return code; | |
1052 | |
1053 } | |
1054 | |
0 | 1055 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
1056 int n, int coded) | |
1057 { | |
1058 int code, level, i, j, last, run; | |
1059 RLTable *rl = &rl_inter; | |
1060 | |
1061 if (s->mb_intra) { | |
1062 /* DC coef */ | |
1063 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) { | |
1064 int component, diff; | |
1065 component = (n <= 3 ? 0 : n - 4 + 1); | |
1066 level = s->last_dc[component]; | |
1067 if (s->rv10_first_dc_coded[component]) { | |
1068 diff = rv_decode_dc(s, n); | |
1069 if (diff == 0xffff) | |
1070 return -1; | |
1071 level += diff; | |
1072 level = level & 0xff; /* handle wrap round */ | |
1073 s->last_dc[component] = level; | |
1074 } else { | |
1075 s->rv10_first_dc_coded[component] = 1; | |
1076 } | |
1077 } else { | |
1078 level = get_bits(&s->gb, 8); | |
1079 if (level == 255) | |
1080 level = 128; | |
1081 } | |
1082 block[0] = level; | |
1083 i = 1; | |
1084 } else { | |
1085 i = 0; | |
1086 } | |
1087 if (!coded) { | |
1088 s->block_last_index[n] = i - 1; | |
1089 return 0; | |
1090 } | |
1091 | |
1092 for(;;) { | |
1093 code = get_vlc(&s->gb, &rl->vlc); | |
1094 if (code < 0) | |
1095 return -1; | |
1096 if (code == rl->n) { | |
1097 /* escape */ | |
21 | 1098 last = get_bits1(&s->gb); |
0 | 1099 run = get_bits(&s->gb, 6); |
1100 level = (INT8)get_bits(&s->gb, 8); | |
1101 if (s->h263_rv10 && level == -128) { | |
1102 /* XXX: should patch encoder too */ | |
1103 level = get_bits(&s->gb, 12); | |
1104 level = (level << 20) >> 20; | |
1105 } | |
1106 } else { | |
1107 run = rl->table_run[code]; | |
1108 level = rl->table_level[code]; | |
1109 last = code >= rl->last; | |
21 | 1110 if (get_bits1(&s->gb)) |
0 | 1111 level = -level; |
1112 } | |
1113 i += run; | |
1114 if (i >= 64) | |
1115 return -1; | |
1116 j = zigzag_direct[i]; | |
1117 block[j] = level; | |
1118 if (last) | |
1119 break; | |
1120 i++; | |
1121 } | |
1122 s->block_last_index[n] = i; | |
1123 return 0; | |
1124 } | |
1125 | |
1126 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) | |
1127 { | |
1128 int level, pred, code; | |
1129 UINT16 *dc_val; | |
1130 | |
1131 if (n < 4) | |
1132 code = get_vlc(&s->gb, &dc_lum); | |
1133 else | |
1134 code = get_vlc(&s->gb, &dc_chrom); | |
1135 if (code < 0) | |
1136 return -1; | |
1137 if (code == 0) { | |
1138 level = 0; | |
1139 } else { | |
1140 level = get_bits(&s->gb, code); | |
1141 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ | |
1142 level = - (level ^ ((1 << code) - 1)); | |
1143 if (code > 8) | |
21 | 1144 skip_bits1(&s->gb); /* marker */ |
0 | 1145 } |
1146 | |
1147 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | |
1148 level += pred; | |
1149 if (level < 0) | |
1150 level = 0; | |
1151 if (n < 4) { | |
1152 *dc_val = level * s->y_dc_scale; | |
1153 } else { | |
1154 *dc_val = level * s->c_dc_scale; | |
1155 } | |
1156 return level; | |
1157 } | |
1158 | |
1159 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1160 int n, int coded) | |
1161 { | |
1162 int code, level, i, j, last, run; | |
1163 int dc_pred_dir; | |
1164 RLTable *rl; | |
1165 const UINT8 *scan_table; | |
1166 | |
1167 if (s->mb_intra) { | |
1168 /* DC coef */ | |
1169 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
1170 if (level < 0) | |
1171 return -1; | |
1172 block[0] = level; | |
1173 i = 1; | |
1174 if (!coded) | |
1175 goto not_coded; | |
1176 rl = &rl_intra; | |
1177 if (s->ac_pred) { | |
1178 if (dc_pred_dir == 0) | |
1179 scan_table = ff_alternate_vertical_scan; /* left */ | |
1180 else | |
1181 scan_table = ff_alternate_horizontal_scan; /* top */ | |
1182 } else { | |
1183 scan_table = zigzag_direct; | |
1184 } | |
1185 } else { | |
1186 i = 0; | |
1187 if (!coded) { | |
1188 s->block_last_index[n] = i - 1; | |
1189 return 0; | |
1190 } | |
1191 rl = &rl_inter; | |
1192 scan_table = zigzag_direct; | |
1193 } | |
1194 | |
1195 for(;;) { | |
1196 code = get_vlc(&s->gb, &rl->vlc); | |
1197 if (code < 0) | |
1198 return -1; | |
1199 if (code == rl->n) { | |
1200 /* escape */ | |
21 | 1201 if (get_bits1(&s->gb) != 0) { |
1202 if (get_bits1(&s->gb) != 0) { | |
0 | 1203 /* third escape */ |
21 | 1204 last = get_bits1(&s->gb); |
0 | 1205 run = get_bits(&s->gb, 6); |
21 | 1206 get_bits1(&s->gb); /* marker */ |
0 | 1207 level = get_bits(&s->gb, 12); |
1208 level = (level << 20) >> 20; /* sign extend */ | |
21 | 1209 skip_bits1(&s->gb); /* marker */ |
0 | 1210 } else { |
1211 /* second escape */ | |
1212 code = get_vlc(&s->gb, &rl->vlc); | |
1213 if (code < 0 || code >= rl->n) | |
1214 return -1; | |
1215 run = rl->table_run[code]; | |
1216 level = rl->table_level[code]; | |
1217 last = code >= rl->last; | |
1218 run += rl->max_run[last][level] + 1; | |
21 | 1219 if (get_bits1(&s->gb)) |
0 | 1220 level = -level; |
1221 } | |
1222 } else { | |
1223 /* first escape */ | |
1224 code = get_vlc(&s->gb, &rl->vlc); | |
1225 if (code < 0 || code >= rl->n) | |
1226 return -1; | |
1227 run = rl->table_run[code]; | |
1228 level = rl->table_level[code]; | |
1229 last = code >= rl->last; | |
1230 level += rl->max_level[last][run]; | |
21 | 1231 if (get_bits1(&s->gb)) |
0 | 1232 level = -level; |
1233 } | |
1234 } else { | |
1235 run = rl->table_run[code]; | |
1236 level = rl->table_level[code]; | |
1237 last = code >= rl->last; | |
21 | 1238 if (get_bits1(&s->gb)) |
0 | 1239 level = -level; |
1240 } | |
1241 i += run; | |
1242 if (i >= 64) | |
1243 return -1; | |
1244 j = scan_table[i]; | |
1245 block[j] = level; | |
1246 i++; | |
1247 if (last) | |
1248 break; | |
1249 } | |
1250 not_coded: | |
1251 if (s->mb_intra) { | |
1252 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
1253 if (s->ac_pred) { | |
1254 i = 64; /* XXX: not optimal */ | |
1255 } | |
1256 } | |
1257 s->block_last_index[n] = i - 1; | |
1258 return 0; | |
1259 } | |
1260 | |
1261 /* most is hardcoded. should extend to handle all h263 streams */ | |
1262 int h263_decode_picture_header(MpegEncContext *s) | |
1263 { | |
1264 int format, width, height; | |
1265 | |
1266 /* picture header */ | |
1267 if (get_bits(&s->gb, 22) != 0x20) | |
1268 return -1; | |
231 | 1269 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
1270 | |
21 | 1271 if (get_bits1(&s->gb) != 1) |
0 | 1272 return -1; /* marker */ |
21 | 1273 if (get_bits1(&s->gb) != 0) |
0 | 1274 return -1; /* h263 id */ |
21 | 1275 skip_bits1(&s->gb); /* split screen off */ |
1276 skip_bits1(&s->gb); /* camera off */ | |
1277 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 1278 |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
1279 /* Reset GOB number */ |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
1280 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
|
1281 |
0 | 1282 format = get_bits(&s->gb, 3); |
1283 | |
161 | 1284 if (format != 7 && format != 6) { |
0 | 1285 s->h263_plus = 0; |
1286 /* H.263v1 */ | |
1287 width = h263_format[format][0]; | |
1288 height = h263_format[format][1]; | |
1289 if (!width) | |
1290 return -1; | |
161 | 1291 |
1292 s->width = width; | |
1293 s->height = height; | |
21 | 1294 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 1295 |
21 | 1296 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 1297 s->h263_long_vectors = s->unrestricted_mv; |
1298 | |
21 | 1299 if (get_bits1(&s->gb) != 0) |
0 | 1300 return -1; /* SAC: off */ |
161 | 1301 if (get_bits1(&s->gb) != 0) { |
1302 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
1303 } | |
1304 | |
21 | 1305 if (get_bits1(&s->gb) != 0) |
0 | 1306 return -1; /* not PB frame */ |
1307 | |
1308 s->qscale = get_bits(&s->gb, 5); | |
21 | 1309 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 1310 } else { |
161 | 1311 int ufep; |
1312 | |
0 | 1313 /* H.263v2 */ |
161 | 1314 s->h263_plus = 1; |
1315 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
1316 | |
1317 if (ufep == 1) { | |
1318 /* OPPTYPE */ | |
1319 format = get_bits(&s->gb, 3); | |
1320 skip_bits(&s->gb,1); /* Custom PCF */ | |
1321 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */ | |
1322 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */ | |
1323 if (get_bits1(&s->gb) != 0) { | |
1324 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
1325 } | |
1326 skip_bits(&s->gb, 8); | |
1327 skip_bits(&s->gb, 3); /* Reserved */ | |
1328 } else if (ufep != 0) | |
0 | 1329 return -1; |
161 | 1330 |
78 | 1331 /* MPPTYPE */ |
0 | 1332 s->pict_type = get_bits(&s->gb, 3) + 1; |
1333 if (s->pict_type != I_TYPE && | |
1334 s->pict_type != P_TYPE) | |
1335 return -1; | |
21 | 1336 skip_bits(&s->gb, 7); |
78 | 1337 |
1338 /* Get the picture dimensions */ | |
161 | 1339 if (ufep) { |
1340 if (format == 6) { | |
1341 /* Custom Picture Format (CPFMT) */ | |
1342 skip_bits(&s->gb, 4); /* aspect ratio */ | |
1343 width = (get_bits(&s->gb, 9) + 1) * 4; | |
1344 skip_bits1(&s->gb); | |
1345 height = get_bits(&s->gb, 9) * 4; | |
78 | 1346 #ifdef DEBUG |
161 | 1347 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height); |
78 | 1348 #endif |
161 | 1349 } |
1350 else { | |
1351 width = h263_format[format][0]; | |
1352 height = h263_format[format][1]; | |
1353 } | |
1354 if ((width == 0) || (height == 0)) | |
1355 return -1; | |
1356 s->width = width; | |
1357 s->height = height; | |
1358 if (s->umvplus_dec) { | |
1359 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
1360 } | |
78 | 1361 } |
1362 | |
0 | 1363 s->qscale = get_bits(&s->gb, 5); |
1364 } | |
1365 /* PEI */ | |
21 | 1366 while (get_bits1(&s->gb) != 0) { |
1367 skip_bits(&s->gb, 8); | |
0 | 1368 } |
1369 s->f_code = 1; | |
1370 return 0; | |
1371 } | |
1372 | |
1373 /* decode mpeg4 VOP header */ | |
1374 int mpeg4_decode_picture_header(MpegEncContext * s) | |
1375 { | |
1376 int time_incr, startcode, state, v; | |
1377 | |
1378 redo: | |
1379 /* search next start code */ | |
1380 align_get_bits(&s->gb); | |
1381 state = 0xff; | |
1382 for(;;) { | |
1383 v = get_bits(&s->gb, 8); | |
1384 if (state == 0x000001) { | |
1385 state = ((state << 8) | v) & 0xffffff; | |
1386 startcode = state; | |
1387 break; | |
1388 } | |
1389 state = ((state << 8) | v) & 0xffffff; | |
1390 /* XXX: really detect end of frame */ | |
1391 if (state == 0) | |
1392 return -1; | |
1393 } | |
1394 | |
1395 if (startcode == 0x120) { | |
63 | 1396 int time_increment_resolution, width, height, vo_ver_id; |
0 | 1397 |
1398 /* vol header */ | |
21 | 1399 skip_bits(&s->gb, 1); /* random access */ |
1400 skip_bits(&s->gb, 8); /* vo_type */ | |
63 | 1401 if (get_bits1(&s->gb) != 0) { /* is_ol_id */ |
1402 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */ | |
1403 skip_bits(&s->gb, 3); /* vo_priority */ | |
1404 } else { | |
1405 vo_ver_id = 1; | |
1406 } | |
0 | 1407 |
21 | 1408 skip_bits(&s->gb, 4); /* aspect_ratio_info */ |
63 | 1409 skip_bits1(&s->gb); /* vol control parameter */ |
1410 s->shape = get_bits(&s->gb, 2); /* vol shape */ | |
21 | 1411 skip_bits1(&s->gb); /* marker */ |
0 | 1412 |
1413 time_increment_resolution = get_bits(&s->gb, 16); | |
70 | 1414 s->time_increment_bits = av_log2(time_increment_resolution - 1) + 1; |
63 | 1415 if (s->time_increment_bits < 1) |
1416 s->time_increment_bits = 1; | |
21 | 1417 skip_bits1(&s->gb); /* marker */ |
0 | 1418 |
63 | 1419 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */ |
1420 skip_bits(&s->gb, s->time_increment_bits); | |
1421 } | |
0 | 1422 |
63 | 1423 if (s->shape != 2) { |
1424 if (s->shape == 0) { | |
1425 skip_bits1(&s->gb); /* marker */ | |
1426 width = get_bits(&s->gb, 13); | |
1427 skip_bits1(&s->gb); /* marker */ | |
1428 height = get_bits(&s->gb, 13); | |
1429 skip_bits1(&s->gb); /* marker */ | |
1430 } | |
1431 | |
1432 skip_bits1(&s->gb); /* interlaced */ | |
1433 skip_bits1(&s->gb); /* OBMC */ | |
1434 if (vo_ver_id == 1) { | |
1435 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */ | |
1436 } else { | |
1437 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */ | |
1438 } | |
1439 if (get_bits1(&s->gb) == 1) { /* not_8_bit */ | |
1440 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */ | |
1441 skip_bits(&s->gb, 4); /* bits_per_pixel */ | |
1442 } else { | |
1443 s->quant_precision = 5; | |
1444 } | |
1445 | |
1446 skip_bits1(&s->gb); /* vol_quant_type */ | |
1447 skip_bits1(&s->gb); /* vol_quarter_pixel */ | |
1448 skip_bits1(&s->gb); /* complexity_estimation_disabled */ | |
1449 skip_bits1(&s->gb); /* resync_marker_disabled */ | |
1450 skip_bits1(&s->gb); /* data_partioning_enabled */ | |
1451 if (get_bits1(&s->gb) != 0) { /* scalability */ | |
1452 printf("bad scalability!!!\n"); | |
1453 return -1; | |
1454 } | |
1455 } | |
0 | 1456 goto redo; |
1457 } else if (startcode != 0x1b6) { | |
1458 goto redo; | |
1459 } | |
1460 | |
1461 s->pict_type = get_bits(&s->gb, 2) + 1; /* pict type: I = 0 , P = 1 */ | |
1462 if (s->pict_type != I_TYPE && | |
1463 s->pict_type != P_TYPE) | |
1464 return -1; | |
1465 | |
1466 /* XXX: parse time base */ | |
1467 time_incr = 0; | |
21 | 1468 while (get_bits1(&s->gb) != 0) |
0 | 1469 time_incr++; |
1470 | |
21 | 1471 skip_bits1(&s->gb); /* marker */ |
1472 skip_bits(&s->gb, s->time_increment_bits); | |
1473 skip_bits1(&s->gb); /* marker */ | |
0 | 1474 /* vop coded */ |
21 | 1475 if (get_bits1(&s->gb) != 1) |
63 | 1476 goto redo; |
0 | 1477 |
63 | 1478 if (s->shape != 2 && s->pict_type == P_TYPE) { |
0 | 1479 /* rounding type for motion estimation */ |
21 | 1480 s->no_rounding = get_bits1(&s->gb); |
63 | 1481 } else { |
1482 s->no_rounding = 0; | |
0 | 1483 } |
63 | 1484 |
1485 if (s->shape != 0) { | |
1486 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { | |
1487 int width, height, hor_spat_ref, ver_spat_ref; | |
1488 | |
1489 width = get_bits(&s->gb, 13); | |
1490 skip_bits1(&s->gb); /* marker */ | |
1491 height = get_bits(&s->gb, 13); | |
1492 skip_bits1(&s->gb); /* marker */ | |
1493 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */ | |
1494 skip_bits1(&s->gb); /* marker */ | |
1495 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */ | |
1496 } | |
1497 skip_bits1(&s->gb); /* change_CR_disable */ | |
1498 | |
1499 if (get_bits1(&s->gb) != 0) { | |
1500 skip_bits(&s->gb, 8); /* constant_alpha_value */ | |
1501 } | |
1502 } | |
0 | 1503 |
63 | 1504 if (s->shape != 2) { |
1505 skip_bits(&s->gb, 3); /* intra dc VLC threshold */ | |
1506 | |
1507 /* note: we do not use quant_precision to avoid problem if no | |
1508 MPEG4 vol header as it is found on some old opendivx | |
1509 movies */ | |
1510 s->qscale = get_bits(&s->gb, 5); | |
1511 | |
1512 if (s->pict_type != I_TYPE) { | |
1513 s->f_code = get_bits(&s->gb, 3); /* fcode_for */ | |
1514 } | |
1515 if (s->shape && (s->pict_type != I_TYPE)) { | |
1516 skip_bits1(&s->gb); // vop shape coding type | |
1517 } | |
1518 } | |
1519 return 0; | |
0 | 1520 } |
1521 | |
1522 /* don't understand why they choose a different header ! */ | |
1523 int intel_h263_decode_picture_header(MpegEncContext *s) | |
1524 { | |
1525 int format; | |
1526 | |
1527 /* picture header */ | |
1528 if (get_bits(&s->gb, 22) != 0x20) | |
1529 return -1; | |
21 | 1530 skip_bits(&s->gb, 8); /* picture timestamp */ |
0 | 1531 |
21 | 1532 if (get_bits1(&s->gb) != 1) |
0 | 1533 return -1; /* marker */ |
21 | 1534 if (get_bits1(&s->gb) != 0) |
0 | 1535 return -1; /* h263 id */ |
21 | 1536 skip_bits1(&s->gb); /* split screen off */ |
1537 skip_bits1(&s->gb); /* camera off */ | |
1538 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 1539 |
1540 format = get_bits(&s->gb, 3); | |
1541 if (format != 7) | |
1542 return -1; | |
1543 | |
1544 s->h263_plus = 0; | |
1545 | |
21 | 1546 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 1547 |
21 | 1548 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 1549 s->h263_long_vectors = s->unrestricted_mv; |
1550 | |
21 | 1551 if (get_bits1(&s->gb) != 0) |
0 | 1552 return -1; /* SAC: off */ |
21 | 1553 if (get_bits1(&s->gb) != 0) |
0 | 1554 return -1; /* advanced prediction mode: off */ |
21 | 1555 if (get_bits1(&s->gb) != 0) |
0 | 1556 return -1; /* not PB frame */ |
1557 | |
1558 /* skip unknown header garbage */ | |
21 | 1559 skip_bits(&s->gb, 41); |
0 | 1560 |
1561 s->qscale = get_bits(&s->gb, 5); | |
21 | 1562 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 1563 |
1564 /* PEI */ | |
21 | 1565 while (get_bits1(&s->gb) != 0) { |
1566 skip_bits(&s->gb, 8); | |
0 | 1567 } |
1568 s->f_code = 1; | |
1569 return 0; | |
1570 } | |
144 | 1571 |