Fix sample URL.
[libav.git] / libavcodec / svq3.c
1 /*
2 * Copyright (c) 2003 The FFmpeg Project.
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /*
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24 * have stsd atoms to describe media trak properties. A stsd atom for a
25 * video trak contains 1 or more ImageDescription atoms. These atoms begin
26 * with the 4-byte length of the atom followed by the codec fourcc. Some
27 * decoders need information in this atom to operate correctly. Such
28 * is the case with SVQ3. In order to get the best use out of this decoder,
29 * the calling app must make the SVQ3 ImageDescription atom available
30 * via the AVCodecContext's extradata[_size] field:
31 *
32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
36 * from the QT file, minus 4 bytes since the length is missing)
37 *
38 * You will know you have these parameters passed correctly when the decoder
39 * correctly decodes this file:
40 * http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41 */
42
43 #ifdef CONFIG_ZLIB
44 #include <zlib.h>
45 #endif
46
47 #include "svq1.h"
48
49 /**
50 * @file svq3.c
51 * svq3 decoder.
52 */
53
54 #define FULLPEL_MODE 1
55 #define HALFPEL_MODE 2
56 #define THIRDPEL_MODE 3
57 #define PREDICT_MODE 4
58
59 /* dual scan (from some older h264 draft)
60 o-->o-->o o
61 | /|
62 o o o / o
63 | / | |/ |
64 o o o o
65 /
66 o-->o-->o-->o
67 */
68 static const uint8_t svq3_scan[16] = {
69 0+0*4, 1+0*4, 2+0*4, 2+1*4,
70 2+2*4, 3+0*4, 3+1*4, 3+2*4,
71 0+1*4, 0+2*4, 1+1*4, 1+2*4,
72 0+3*4, 1+3*4, 2+3*4, 3+3*4,
73 };
74
75 static const uint8_t svq3_pred_0[25][2] = {
76 { 0, 0 },
77 { 1, 0 }, { 0, 1 },
78 { 0, 2 }, { 1, 1 }, { 2, 0 },
79 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
80 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
81 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
82 { 2, 4 }, { 3, 3 }, { 4, 2 },
83 { 4, 3 }, { 3, 4 },
84 { 4, 4 }
85 };
86
87 static const int8_t svq3_pred_1[6][6][5] = {
88 { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
89 { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
90 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
91 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
92 { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
93 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
94 { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
95 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
96 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
97 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
98 { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
99 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
100 };
101
102 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
103 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
104 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
105 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
106 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
107 };
108
109 static const uint32_t svq3_dequant_coeff[32] = {
110 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
111 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
112 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
113 61694, 68745, 77615, 89113,100253,109366,126635,141533
114 };
115
116
117 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp)
118 {
119 const int qmul = svq3_dequant_coeff[qp];
120 #define stride 16
121 int i;
122 int temp[16];
123 static const int x_offset[4] = {0, 1*stride, 4* stride, 5*stride};
124 static const int y_offset[4] = {0, 2*stride, 8* stride, 10*stride};
125
126 for (i = 0; i < 4; i++){
127 const int offset = y_offset[i];
128 const int z0 = 13*(block[offset+stride*0] + block[offset+stride*4]);
129 const int z1 = 13*(block[offset+stride*0] - block[offset+stride*4]);
130 const int z2 = 7* block[offset+stride*1] - 17*block[offset+stride*5];
131 const int z3 = 17* block[offset+stride*1] + 7*block[offset+stride*5];
132
133 temp[4*i+0] = z0+z3;
134 temp[4*i+1] = z1+z2;
135 temp[4*i+2] = z1-z2;
136 temp[4*i+3] = z0-z3;
137 }
138
139 for (i = 0; i < 4; i++){
140 const int offset = x_offset[i];
141 const int z0 = 13*(temp[4*0+i] + temp[4*2+i]);
142 const int z1 = 13*(temp[4*0+i] - temp[4*2+i]);
143 const int z2 = 7* temp[4*1+i] - 17*temp[4*3+i];
144 const int z3 = 17* temp[4*1+i] + 7*temp[4*3+i];
145
146 block[stride*0 +offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
147 block[stride*2 +offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
148 block[stride*8 +offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
149 block[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
150 }
151 }
152 #undef stride
153
154 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
155 int dc)
156 {
157 const int qmul = svq3_dequant_coeff[qp];
158 int i;
159 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
160
161 if (dc) {
162 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
163 block[0] = 0;
164 }
165
166 for (i = 0; i < 4; i++) {
167 const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]);
168 const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]);
169 const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i];
170 const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i];
171
172 block[0 + 4*i] = z0 + z3;
173 block[1 + 4*i] = z1 + z2;
174 block[2 + 4*i] = z1 - z2;
175 block[3 + 4*i] = z0 - z3;
176 }
177
178 for (i = 0; i < 4; i++) {
179 const int z0 = 13*(block[i + 4*0] + block[i + 4*2]);
180 const int z1 = 13*(block[i + 4*0] - block[i + 4*2]);
181 const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3];
182 const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3];
183 const int rr = (dc + 0x80000);
184
185 dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
186 dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
187 dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
188 dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
189 }
190 }
191
192 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
193 int index, const int type)
194 {
195 static const uint8_t *const scan_patterns[4] =
196 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
197
198 int run, level, sign, vlc, limit;
199 const int intra = (3 * type) >> 2;
200 const uint8_t *const scan = scan_patterns[type];
201
202 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
203 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
204
205 if (vlc == INVALID_VLC)
206 return -1;
207
208 sign = (vlc & 0x1) - 1;
209 vlc = (vlc + 1) >> 1;
210
211 if (type == 3) {
212 if (vlc < 3) {
213 run = 0;
214 level = vlc;
215 } else if (vlc < 4) {
216 run = 1;
217 level = 1;
218 } else {
219 run = (vlc & 0x3);
220 level = ((vlc + 9) >> 2) - run;
221 }
222 } else {
223 if (vlc < 16) {
224 run = svq3_dct_tables[intra][vlc].run;
225 level = svq3_dct_tables[intra][vlc].level;
226 } else if (intra) {
227 run = (vlc & 0x7);
228 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
229 } else {
230 run = (vlc & 0xF);
231 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
232 }
233 }
234
235 if ((index += run) >= limit)
236 return -1;
237
238 block[scan[index]] = (level ^ sign) - sign;
239 }
240
241 if (type != 2) {
242 break;
243 }
244 }
245
246 return 0;
247 }
248
249 static inline void svq3_mc_dir_part(MpegEncContext *s,
250 int x, int y, int width, int height,
251 int mx, int my, int dxy,
252 int thirdpel, int dir, int avg)
253 {
254 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
255 uint8_t *src, *dest;
256 int i, emu = 0;
257 int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
258
259 mx += x;
260 my += y;
261
262 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
263 my < 0 || my >= (s->v_edge_pos - height - 1)) {
264
265 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
266 emu = 1;
267 }
268
269 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
270 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
271 }
272
273 /* form component predictions */
274 dest = s->current_picture.data[0] + x + y*s->linesize;
275 src = pic->data[0] + mx + my*s->linesize;
276
277 if (emu) {
278 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
279 mx, my, s->h_edge_pos, s->v_edge_pos);
280 src = s->edge_emu_buffer;
281 }
282 if (thirdpel)
283 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
284 else
285 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
286
287 if (!(s->flags & CODEC_FLAG_GRAY)) {
288 mx = (mx + (mx < (int) x)) >> 1;
289 my = (my + (my < (int) y)) >> 1;
290 width = (width >> 1);
291 height = (height >> 1);
292 blocksize++;
293
294 for (i = 1; i < 3; i++) {
295 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
296 src = pic->data[i] + mx + my*s->uvlinesize;
297
298 if (emu) {
299 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
300 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
301 src = s->edge_emu_buffer;
302 }
303 if (thirdpel)
304 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
305 else
306 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
307 }
308 }
309 }
310
311 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
312 int avg)
313 {
314 int i, j, k, mx, my, dx, dy, x, y;
315 MpegEncContext *const s = (MpegEncContext *) h;
316 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
317 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
318 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
319 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
320 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
321
322 for (i = 0; i < 16; i += part_height) {
323 for (j = 0; j < 16; j += part_width) {
324 const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
325 int dxy;
326 x = 16*s->mb_x + j;
327 y = 16*s->mb_y + i;
328 k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
329
330 if (mode != PREDICT_MODE) {
331 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
332 } else {
333 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
334 my = s->next_picture.motion_val[0][b_xy][1]<<1;
335
336 if (dir == 0) {
337 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
338 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
339 } else {
340 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
341 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
342 }
343 }
344
345 /* clip motion vector prediction to frame border */
346 mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
347 my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
348
349 /* get (optional) motion vector differential */
350 if (mode == PREDICT_MODE) {
351 dx = dy = 0;
352 } else {
353 dy = svq3_get_se_golomb(&s->gb);
354 dx = svq3_get_se_golomb(&s->gb);
355
356 if (dx == INVALID_VLC || dy == INVALID_VLC) {
357 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
358 return -1;
359 }
360 }
361
362 /* compute motion vector */
363 if (mode == THIRDPEL_MODE) {
364 int fx, fy;
365 mx = ((mx + 1)>>1) + dx;
366 my = ((my + 1)>>1) + dy;
367 fx = ((unsigned)(mx + 0x3000))/3 - 0x1000;
368 fy = ((unsigned)(my + 0x3000))/3 - 0x1000;
369 dxy = (mx - 3*fx) + 4*(my - 3*fy);
370
371 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
372 mx += mx;
373 my += my;
374 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
375 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
376 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
377 dxy = (mx&1) + 2*(my&1);
378
379 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
380 mx *= 3;
381 my *= 3;
382 } else {
383 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
384 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
385
386 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
387 mx *= 6;
388 my *= 6;
389 }
390
391 /* update mv_cache */
392 if (mode != PREDICT_MODE) {
393 int32_t mv = pack16to32(mx,my);
394
395 if (part_height == 8 && i < 8) {
396 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
397
398 if (part_width == 8 && j < 8) {
399 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
400 }
401 }
402 if (part_width == 8 && j < 8) {
403 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
404 }
405 if (part_width == 4 || part_height == 4) {
406 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
407 }
408 }
409
410 /* write back motion vectors */
411 fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
412 }
413 }
414
415 return 0;
416 }
417
418 static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
419 {
420 int i, j, k, m, dir, mode;
421 int cbp = 0;
422 uint32_t vlc;
423 int8_t *top, *left;
424 MpegEncContext *const s = (MpegEncContext *) h;
425 const int mb_xy = h->mb_xy;
426 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
427
428 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
429 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
430 h->topright_samples_available = 0xFFFF;
431
432 if (mb_type == 0) { /* SKIP */
433 if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
434 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
435
436 if (s->pict_type == FF_B_TYPE) {
437 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
438 }
439
440 mb_type = MB_TYPE_SKIP;
441 } else {
442 mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
443 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
444 return -1;
445 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
446 return -1;
447
448 mb_type = MB_TYPE_16x16;
449 }
450 } else if (mb_type < 8) { /* INTER */
451 if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
452 mode = THIRDPEL_MODE;
453 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
454 mode = HALFPEL_MODE;
455 } else {
456 mode = FULLPEL_MODE;
457 }
458
459 /* fill caches */
460 /* note ref_cache should contain here:
461 ????????
462 ???11111
463 N??11111
464 N??11111
465 N??11111
466 */
467
468 for (m = 0; m < 2; m++) {
469 if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
470 for (i = 0; i < 4; i++) {
471 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
472 }
473 } else {
474 for (i = 0; i < 4; i++) {
475 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
476 }
477 }
478 if (s->mb_y > 0) {
479 memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
480 memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);
481
482 if (s->mb_x < (s->mb_width - 1)) {
483 *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
484 h->ref_cache[m][scan8[0] + 4 - 1*8] =
485 (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
486 h->intra4x4_pred_mode[mb_xy - s->mb_stride ][4] == -1) ? PART_NOT_AVAILABLE : 1;
487 }else
488 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
489 if (s->mb_x > 0) {
490 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
491 h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;
492 }else
493 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
494 }else
495 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
496
497 if (s->pict_type != FF_B_TYPE)
498 break;
499 }
500
501 /* decode motion vector(s) and form prediction(s) */
502 if (s->pict_type == FF_P_TYPE) {
503 if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
504 return -1;
505 } else { /* FF_B_TYPE */
506 if (mb_type != 2) {
507 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
508 return -1;
509 } else {
510 for (i = 0; i < 4; i++) {
511 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
512 }
513 }
514 if (mb_type != 1) {
515 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
516 return -1;
517 } else {
518 for (i = 0; i < 4; i++) {
519 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
520 }
521 }
522 }
523
524 mb_type = MB_TYPE_16x16;
525 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
526 memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
527
528 if (mb_type == 8) {
529 if (s->mb_x > 0) {
530 for (i = 0; i < 4; i++) {
531 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
532 }
533 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
534 h->left_samples_available = 0x5F5F;
535 }
536 }
537 if (s->mb_y > 0) {
538 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
539 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
540 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
541 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
542
543 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
544 h->top_samples_available = 0x33FF;
545 }
546 }
547
548 /* decode prediction codes for luma blocks */
549 for (i = 0; i < 16; i+=2) {
550 vlc = svq3_get_ue_golomb(&s->gb);
551
552 if (vlc >= 25){
553 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
554 return -1;
555 }
556
557 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
558 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
559
560 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
561 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
562
563 if (left[1] == -1 || left[2] == -1){
564 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
565 return -1;
566 }
567 }
568 } else { /* mb_type == 33, DC_128_PRED block type */
569 for (i = 0; i < 4; i++) {
570 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
571 }
572 }
573
574 write_back_intra_pred_mode(h);
575
576 if (mb_type == 8) {
577 check_intra4x4_pred_mode(h);
578
579 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
580 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
581 } else {
582 for (i = 0; i < 4; i++) {
583 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
584 }
585
586 h->top_samples_available = 0x33FF;
587 h->left_samples_available = 0x5F5F;
588 }
589
590 mb_type = MB_TYPE_INTRA4x4;
591 } else { /* INTRA16x16 */
592 dir = i_mb_type_info[mb_type - 8].pred_mode;
593 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
594
595 if ((h->intra16x16_pred_mode = check_intra_pred_mode(h, dir)) == -1){
596 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
597 return -1;
598 }
599
600 cbp = i_mb_type_info[mb_type - 8].cbp;
601 mb_type = MB_TYPE_INTRA16x16;
602 }
603
604 if (!IS_INTER(mb_type) && s->pict_type != FF_I_TYPE) {
605 for (i = 0; i < 4; i++) {
606 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
607 }
608 if (s->pict_type == FF_B_TYPE) {
609 for (i = 0; i < 4; i++) {
610 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
611 }
612 }
613 }
614 if (!IS_INTRA4x4(mb_type)) {
615 memset(h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
616 }
617 if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
618 memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
619 s->dsp.clear_blocks(h->mb);
620 }
621
622 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
623 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
624 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
625 return -1;
626 }
627
628 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
629 }
630 if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
631 s->qscale += svq3_get_se_golomb(&s->gb);
632
633 if (s->qscale > 31){
634 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
635 return -1;
636 }
637 }
638 if (IS_INTRA16x16(mb_type)) {
639 if (svq3_decode_block(&s->gb, h->mb, 0, 0)){
640 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
641 return -1;
642 }
643 }
644
645 if (cbp) {
646 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
647 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
648
649 for (i = 0; i < 4; i++) {
650 if ((cbp & (1 << i))) {
651 for (j = 0; j < 4; j++) {
652 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
653 h->non_zero_count_cache[ scan8[k] ] = 1;
654
655 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
656 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
657 return -1;
658 }
659 }
660 }
661 }
662
663 if ((cbp & 0x30)) {
664 for (i = 0; i < 2; ++i) {
665 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
666 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
667 return -1;
668 }
669 }
670
671 if ((cbp & 0x20)) {
672 for (i = 0; i < 8; i++) {
673 h->non_zero_count_cache[ scan8[16+i] ] = 1;
674
675 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
676 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
677 return -1;
678 }
679 }
680 }
681 }
682 }
683
684 h->cbp= cbp;
685 s->current_picture.mb_type[mb_xy] = mb_type;
686
687 if (IS_INTRA(mb_type)) {
688 h->chroma_pred_mode = check_intra_pred_mode(h, DC_PRED8x8);
689 }
690
691 return 0;
692 }
693
694 static int svq3_decode_slice_header(H264Context *h)
695 {
696 MpegEncContext *const s = (MpegEncContext *) h;
697 const int mb_xy = h->mb_xy;
698 int i, header;
699
700 header = get_bits(&s->gb, 8);
701
702 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
703 /* TODO: what? */
704 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
705 return -1;
706 } else {
707 int length = (header >> 5) & 3;
708
709 h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
710
711 if (h->next_slice_index > s->gb.size_in_bits) {
712 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
713 return -1;
714 }
715
716 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
717 skip_bits(&s->gb, 8);
718
719 if (h->svq3_watermark_key) {
720 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
721 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
722 }
723 if (length > 0) {
724 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
725 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
726 }
727 }
728
729 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
730 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
731 return -1;
732 }
733
734 h->slice_type = golomb_to_pict_type[i];
735
736 if ((header & 0x9F) == 2) {
737 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
738 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
739 } else {
740 skip_bits1(&s->gb);
741 s->mb_skip_run = 0;
742 }
743
744 h->slice_num = get_bits(&s->gb, 8);
745 s->qscale = get_bits(&s->gb, 5);
746 s->adaptive_quant = get_bits1(&s->gb);
747
748 /* unknown fields */
749 skip_bits1(&s->gb);
750
751 if (h->unknown_svq3_flag) {
752 skip_bits1(&s->gb);
753 }
754
755 skip_bits1(&s->gb);
756 skip_bits(&s->gb, 2);
757
758 while (get_bits1(&s->gb)) {
759 skip_bits(&s->gb, 8);
760 }
761
762 /* reset intra predictors and invalidate motion vector references */
763 if (s->mb_x > 0) {
764 memset(h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
765 memset(h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
766 }
767 if (s->mb_y > 0) {
768 memset(h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
769
770 if (s->mb_x > 0) {
771 h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
772 }
773 }
774
775 return 0;
776 }
777
778 static int svq3_decode_init(AVCodecContext *avctx)
779 {
780 MpegEncContext *const s = avctx->priv_data;
781 H264Context *const h = avctx->priv_data;
782 int m;
783 unsigned char *extradata;
784 unsigned int size;
785
786 if (decode_init(avctx) < 0)
787 return -1;
788
789 s->flags = avctx->flags;
790 s->flags2 = avctx->flags2;
791 s->unrestricted_mv = 1;
792 h->is_complex=1;
793
794 if (!s->context_initialized) {
795 s->width = avctx->width;
796 s->height = avctx->height;
797 h->halfpel_flag = 1;
798 h->thirdpel_flag = 1;
799 h->unknown_svq3_flag = 0;
800 h->chroma_qp[0] = h->chroma_qp[1] = 4;
801
802 if (MPV_common_init(s) < 0)
803 return -1;
804
805 h->b_stride = 4*s->mb_width;
806
807 alloc_tables(h);
808
809 /* prowl for the "SEQH" marker in the extradata */
810 extradata = (unsigned char *)avctx->extradata;
811 for (m = 0; m < avctx->extradata_size; m++) {
812 if (!memcmp(extradata, "SEQH", 4))
813 break;
814 extradata++;
815 }
816
817 /* if a match was found, parse the extra data */
818 if (extradata && !memcmp(extradata, "SEQH", 4)) {
819
820 GetBitContext gb;
821
822 size = AV_RB32(&extradata[4]);
823 init_get_bits(&gb, extradata + 8, size*8);
824
825 /* 'frame size code' and optional 'width, height' */
826 if (get_bits(&gb, 3) == 7) {
827 skip_bits(&gb, 12);
828 skip_bits(&gb, 12);
829 }
830
831 h->halfpel_flag = get_bits1(&gb);
832 h->thirdpel_flag = get_bits1(&gb);
833
834 /* unknown fields */
835 skip_bits1(&gb);
836 skip_bits1(&gb);
837 skip_bits1(&gb);
838 skip_bits1(&gb);
839
840 s->low_delay = get_bits1(&gb);
841
842 /* unknown field */
843 skip_bits1(&gb);
844
845 while (get_bits1(&gb)) {
846 skip_bits(&gb, 8);
847 }
848
849 h->unknown_svq3_flag = get_bits1(&gb);
850 avctx->has_b_frames = !s->low_delay;
851 if (h->unknown_svq3_flag) {
852 #ifdef CONFIG_ZLIB
853 unsigned watermark_width = svq3_get_ue_golomb(&gb);
854 unsigned watermark_height = svq3_get_ue_golomb(&gb);
855 int u1 = svq3_get_ue_golomb(&gb);
856 int u2 = get_bits(&gb, 8);
857 int u3 = get_bits(&gb, 2);
858 int u4 = svq3_get_ue_golomb(&gb);
859 unsigned buf_len = watermark_width*watermark_height*4;
860 int offset = (get_bits_count(&gb)+7)>>3;
861 uint8_t *buf;
862
863 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
864 return -1;
865
866 buf = av_malloc(buf_len);
867 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
868 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
869 if (uncompress(buf, (uLong*)&buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
870 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
871 av_free(buf);
872 return -1;
873 }
874 h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
875 h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
876 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
877 av_free(buf);
878 #else
879 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
880 return -1;
881 #endif
882 }
883 }
884 }
885
886 return 0;
887 }
888
889 static int svq3_decode_frame(AVCodecContext *avctx,
890 void *data, int *data_size,
891 const uint8_t *buf, int buf_size)
892 {
893 MpegEncContext *const s = avctx->priv_data;
894 H264Context *const h = avctx->priv_data;
895 int m, mb_type;
896
897 /* special case for last picture */
898 if (buf_size == 0) {
899 if (s->next_picture_ptr && !s->low_delay) {
900 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
901 s->next_picture_ptr = NULL;
902 *data_size = sizeof(AVFrame);
903 }
904 return 0;
905 }
906
907 init_get_bits (&s->gb, buf, 8*buf_size);
908
909 s->mb_x = s->mb_y = h->mb_xy = 0;
910
911 if (svq3_decode_slice_header(h))
912 return -1;
913
914 s->pict_type = h->slice_type;
915 s->picture_number = h->slice_num;
916
917 if (avctx->debug&FF_DEBUG_PICT_INFO){
918 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
919 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
920 s->adaptive_quant, s->qscale, h->slice_num);
921 }
922
923 /* for hurry_up == 5 */
924 s->current_picture.pict_type = s->pict_type;
925 s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
926
927 /* Skip B-frames if we do not have reference frames. */
928 if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
929 return 0;
930 /* Skip B-frames if we are in a hurry. */
931 if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
932 return 0;
933 /* Skip everything if we are in a hurry >= 5. */
934 if (avctx->hurry_up >= 5)
935 return 0;
936 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
937 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
938 || avctx->skip_frame >= AVDISCARD_ALL)
939 return 0;
940
941 if (s->next_p_frame_damaged) {
942 if (s->pict_type == FF_B_TYPE)
943 return 0;
944 else
945 s->next_p_frame_damaged = 0;
946 }
947
948 if (frame_start(h) < 0)
949 return -1;
950
951 if (s->pict_type == FF_B_TYPE) {
952 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
953
954 if (h->frame_num_offset < 0) {
955 h->frame_num_offset += 256;
956 }
957 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
958 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
959 return -1;
960 }
961 } else {
962 h->prev_frame_num = h->frame_num;
963 h->frame_num = h->slice_num;
964 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
965
966 if (h->prev_frame_num_offset < 0) {
967 h->prev_frame_num_offset += 256;
968 }
969 }
970
971 for (m = 0; m < 2; m++){
972 int i;
973 for (i = 0; i < 4; i++){
974 int j;
975 for (j = -1; j < 4; j++)
976 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
977 if (i < 3)
978 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
979 }
980 }
981
982 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
983 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
984 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
985
986 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
987 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
988
989 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
990 s->gb.size_in_bits = 8*buf_size;
991
992 if (svq3_decode_slice_header(h))
993 return -1;
994
995 /* TODO: support s->mb_skip_run */
996 }
997
998 mb_type = svq3_get_ue_golomb(&s->gb);
999
1000 if (s->pict_type == FF_I_TYPE) {
1001 mb_type += 8;
1002 } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1003 mb_type += 4;
1004 }
1005 if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1006 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1007 return -1;
1008 }
1009
1010 if (mb_type != 0) {
1011 hl_decode_mb (h);
1012 }
1013
1014 if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1015 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1016 (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1017 }
1018 }
1019
1020 ff_draw_horiz_band(s, 16*s->mb_y, 16);
1021 }
1022
1023 MPV_frame_end(s);
1024
1025 if (s->pict_type == FF_B_TYPE || s->low_delay) {
1026 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1027 } else {
1028 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1029 }
1030
1031 avctx->frame_number = s->picture_number - 1;
1032
1033 /* Do not output the last pic after seeking. */
1034 if (s->last_picture_ptr || s->low_delay) {
1035 *data_size = sizeof(AVFrame);
1036 }
1037
1038 return buf_size;
1039 }
1040
1041
1042 AVCodec svq3_decoder = {
1043 "svq3",
1044 CODEC_TYPE_VIDEO,
1045 CODEC_ID_SVQ3,
1046 sizeof(H264Context),
1047 svq3_decode_init,
1048 NULL,
1049 decode_end,
1050 svq3_decode_frame,
1051 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1052 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),
1053 };