9d99da5517bc8f475dab3b0a136b7f7d8a471d4f
[libav.git] / libavcodec / svq3.c
1 /*
2 * Copyright (c) 2003 The Libav Project
3 *
4 * This file is part of Libav.
5 *
6 * Libav 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 * Libav 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 Libav; 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.libav.org/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41 */
42
43 #include <inttypes.h>
44
45 #include "libavutil/attributes.h"
46 #include "internal.h"
47 #include "avcodec.h"
48 #include "mpegutils.h"
49 #include "h264.h"
50 #include "h264_mvpred.h"
51 #include "h264data.h"
52 #include "golomb.h"
53 #include "hpeldsp.h"
54 #include "mathops.h"
55 #include "rectangle.h"
56 #include "tpeldsp.h"
57
58 #if CONFIG_ZLIB
59 #include <zlib.h>
60 #endif
61
62 #include "svq1.h"
63
64 /**
65 * @file
66 * svq3 decoder.
67 */
68
69 typedef struct SVQ3Context {
70 H264Context h;
71
72 H264DSPContext h264dsp;
73 H264PredContext hpc;
74 HpelDSPContext hdsp;
75 TpelDSPContext tdsp;
76 VideoDSPContext vdsp;
77
78 H264Picture *cur_pic;
79 H264Picture *next_pic;
80 H264Picture *last_pic;
81 GetBitContext gb;
82 uint8_t *slice_buf;
83 int slice_size;
84 int halfpel_flag;
85 int thirdpel_flag;
86 int unknown_flag;
87 uint32_t watermark_key;
88 int adaptive_quant;
89 int next_p_frame_damaged;
90 int h_edge_pos;
91 int v_edge_pos;
92 int last_frame_output;
93 } SVQ3Context;
94
95 #define FULLPEL_MODE 1
96 #define HALFPEL_MODE 2
97 #define THIRDPEL_MODE 3
98 #define PREDICT_MODE 4
99
100 /* dual scan (from some older h264 draft)
101 * o-->o-->o o
102 * | /|
103 * o o o / o
104 * | / | |/ |
105 * o o o o
106 * /
107 * o-->o-->o-->o
108 */
109 static const uint8_t svq3_scan[16] = {
110 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
111 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
112 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
113 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
114 };
115
116 static const uint8_t luma_dc_zigzag_scan[16] = {
117 0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
118 3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
119 1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
120 3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
121 };
122
123 static const uint8_t svq3_pred_0[25][2] = {
124 { 0, 0 },
125 { 1, 0 }, { 0, 1 },
126 { 0, 2 }, { 1, 1 }, { 2, 0 },
127 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
128 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
129 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
130 { 2, 4 }, { 3, 3 }, { 4, 2 },
131 { 4, 3 }, { 3, 4 },
132 { 4, 4 }
133 };
134
135 static const int8_t svq3_pred_1[6][6][5] = {
136 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
137 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
138 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
139 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
140 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
141 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
142 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
143 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
144 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
145 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
146 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
147 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
148 };
149
150 static const struct {
151 uint8_t run;
152 uint8_t level;
153 } svq3_dct_tables[2][16] = {
154 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
155 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
156 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
157 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
158 };
159
160 static const uint32_t svq3_dequant_coeff[32] = {
161 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
162 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
163 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
164 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
165 };
166
167 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
168 {
169 const int qmul = svq3_dequant_coeff[qp];
170 #define stride 16
171 int i;
172 int temp[16];
173 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
174
175 for (i = 0; i < 4; i++) {
176 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
177 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
178 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
179 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
180
181 temp[4 * i + 0] = z0 + z3;
182 temp[4 * i + 1] = z1 + z2;
183 temp[4 * i + 2] = z1 - z2;
184 temp[4 * i + 3] = z0 - z3;
185 }
186
187 for (i = 0; i < 4; i++) {
188 const int offset = x_offset[i];
189 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
190 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
191 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
192 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
193
194 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
195 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
196 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
197 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
198 }
199 }
200 #undef stride
201
202 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
203 int stride, int qp, int dc)
204 {
205 const int qmul = svq3_dequant_coeff[qp];
206 int i;
207
208 if (dc) {
209 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
210 : qmul * (block[0] >> 3) / 2);
211 block[0] = 0;
212 }
213
214 for (i = 0; i < 4; i++) {
215 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
216 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
217 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
218 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
219
220 block[0 + 4 * i] = z0 + z3;
221 block[1 + 4 * i] = z1 + z2;
222 block[2 + 4 * i] = z1 - z2;
223 block[3 + 4 * i] = z0 - z3;
224 }
225
226 for (i = 0; i < 4; i++) {
227 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
228 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
229 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
230 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
231 const int rr = (dc + 0x80000);
232
233 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
234 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
235 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
236 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
237 }
238
239 memset(block, 0, 16 * sizeof(int16_t));
240 }
241
242 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
243 int index, const int type)
244 {
245 static const uint8_t *const scan_patterns[4] = {
246 luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
247 };
248
249 int run, level, limit;
250 unsigned vlc;
251 const int intra = 3 * type >> 2;
252 const uint8_t *const scan = scan_patterns[type];
253
254 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
255 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
256 int sign = (vlc & 1) ? 0 : -1;
257 vlc = vlc + 1 >> 1;
258
259 if (type == 3) {
260 if (vlc < 3) {
261 run = 0;
262 level = vlc;
263 } else if (vlc < 4) {
264 run = 1;
265 level = 1;
266 } else {
267 run = vlc & 0x3;
268 level = (vlc + 9 >> 2) - run;
269 }
270 } else {
271 if (vlc < 16) {
272 run = svq3_dct_tables[intra][vlc].run;
273 level = svq3_dct_tables[intra][vlc].level;
274 } else if (intra) {
275 run = vlc & 0x7;
276 level = (vlc >> 3) +
277 ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
278 } else {
279 run = vlc & 0xF;
280 level = (vlc >> 4) +
281 ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
282 }
283 }
284
285 if ((index += run) >= limit)
286 return -1;
287
288 block[scan[index]] = (level ^ sign) - sign;
289 }
290
291 if (type != 2) {
292 break;
293 }
294 }
295
296 return 0;
297 }
298
299 static inline void svq3_mc_dir_part(SVQ3Context *s,
300 int x, int y, int width, int height,
301 int mx, int my, int dxy,
302 int thirdpel, int dir, int avg)
303 {
304 H264Context *h = &s->h;
305 H264SliceContext *sl = &h->slice_ctx[0];
306 const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
307 uint8_t *src, *dest;
308 int i, emu = 0;
309 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
310
311 mx += x;
312 my += y;
313
314 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
315 my < 0 || my >= s->v_edge_pos - height - 1) {
316 emu = 1;
317 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
318 my = av_clip(my, -16, s->v_edge_pos - height + 15);
319 }
320
321 /* form component predictions */
322 dest = h->cur_pic.f->data[0] + x + y * sl->linesize;
323 src = pic->f->data[0] + mx + my * sl->linesize;
324
325 if (emu) {
326 s->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
327 sl->linesize, sl->linesize,
328 width + 1, height + 1,
329 mx, my, s->h_edge_pos, s->v_edge_pos);
330 src = sl->edge_emu_buffer;
331 }
332 if (thirdpel)
333 (avg ? s->tdsp.avg_tpel_pixels_tab
334 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, sl->linesize,
335 width, height);
336 else
337 (avg ? s->hdsp.avg_pixels_tab
338 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, sl->linesize,
339 height);
340
341 if (!(h->flags & AV_CODEC_FLAG_GRAY)) {
342 mx = mx + (mx < (int) x) >> 1;
343 my = my + (my < (int) y) >> 1;
344 width = width >> 1;
345 height = height >> 1;
346 blocksize++;
347
348 for (i = 1; i < 3; i++) {
349 dest = h->cur_pic.f->data[i] + (x >> 1) + (y >> 1) * sl->uvlinesize;
350 src = pic->f->data[i] + mx + my * sl->uvlinesize;
351
352 if (emu) {
353 s->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
354 sl->uvlinesize, sl->uvlinesize,
355 width + 1, height + 1,
356 mx, my, (s->h_edge_pos >> 1),
357 s->v_edge_pos >> 1);
358 src = sl->edge_emu_buffer;
359 }
360 if (thirdpel)
361 (avg ? s->tdsp.avg_tpel_pixels_tab
362 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
363 sl->uvlinesize,
364 width, height);
365 else
366 (avg ? s->hdsp.avg_pixels_tab
367 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
368 sl->uvlinesize,
369 height);
370 }
371 }
372 }
373
374 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
375 int dir, int avg)
376 {
377 int i, j, k, mx, my, dx, dy, x, y;
378 H264Context *h = &s->h;
379 H264SliceContext *sl = &h->slice_ctx[0];
380 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
381 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
382 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
383 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
384 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
385
386 for (i = 0; i < 16; i += part_height)
387 for (j = 0; j < 16; j += part_width) {
388 const int b_xy = (4 * sl->mb_x + (j >> 2)) +
389 (4 * sl->mb_y + (i >> 2)) * h->b_stride;
390 int dxy;
391 x = 16 * sl->mb_x + j;
392 y = 16 * sl->mb_y + i;
393 k = (j >> 2 & 1) + (i >> 1 & 2) +
394 (j >> 1 & 4) + (i & 8);
395
396 if (mode != PREDICT_MODE) {
397 pred_motion(h, sl, k, part_width >> 2, dir, 1, &mx, &my);
398 } else {
399 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
400 my = s->next_pic->motion_val[0][b_xy][1] << 1;
401
402 if (dir == 0) {
403 mx = mx * h->frame_num_offset /
404 h->prev_frame_num_offset + 1 >> 1;
405 my = my * h->frame_num_offset /
406 h->prev_frame_num_offset + 1 >> 1;
407 } else {
408 mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
409 h->prev_frame_num_offset + 1 >> 1;
410 my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
411 h->prev_frame_num_offset + 1 >> 1;
412 }
413 }
414
415 /* clip motion vector prediction to frame border */
416 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
417 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
418
419 /* get (optional) motion vector differential */
420 if (mode == PREDICT_MODE) {
421 dx = dy = 0;
422 } else {
423 dy = svq3_get_se_golomb(&h->gb);
424 dx = svq3_get_se_golomb(&h->gb);
425
426 if (dx == INVALID_VLC || dy == INVALID_VLC) {
427 av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
428 return -1;
429 }
430 }
431
432 /* compute motion vector */
433 if (mode == THIRDPEL_MODE) {
434 int fx, fy;
435 mx = (mx + 1 >> 1) + dx;
436 my = (my + 1 >> 1) + dy;
437 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
438 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
439 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
440
441 svq3_mc_dir_part(s, x, y, part_width, part_height,
442 fx, fy, dxy, 1, dir, avg);
443 mx += mx;
444 my += my;
445 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
446 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
447 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
448 dxy = (mx & 1) + 2 * (my & 1);
449
450 svq3_mc_dir_part(s, x, y, part_width, part_height,
451 mx >> 1, my >> 1, dxy, 0, dir, avg);
452 mx *= 3;
453 my *= 3;
454 } else {
455 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
456 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
457
458 svq3_mc_dir_part(s, x, y, part_width, part_height,
459 mx, my, 0, 0, dir, avg);
460 mx *= 6;
461 my *= 6;
462 }
463
464 /* update mv_cache */
465 if (mode != PREDICT_MODE) {
466 int32_t mv = pack16to32(mx, my);
467
468 if (part_height == 8 && i < 8) {
469 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 * 8], mv);
470
471 if (part_width == 8 && j < 8)
472 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
473 }
474 if (part_width == 8 && j < 8)
475 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1], mv);
476 if (part_width == 4 || part_height == 4)
477 AV_WN32A(sl->mv_cache[dir][scan8[k]], mv);
478 }
479
480 /* write back motion vectors */
481 fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
482 part_width >> 2, part_height >> 2, h->b_stride,
483 pack16to32(mx, my), 4);
484 }
485
486 return 0;
487 }
488
489 static av_always_inline void hl_decode_mb_idct_luma(const H264Context *h, H264SliceContext *sl,
490 int mb_type, const int *block_offset,
491 int linesize, uint8_t *dest_y)
492 {
493 int i;
494 if (!IS_INTRA4x4(mb_type)) {
495 for (i = 0; i < 16; i++)
496 if (sl->non_zero_count_cache[scan8[i]] || sl->mb[i * 16]) {
497 uint8_t *const ptr = dest_y + block_offset[i];
498 svq3_add_idct_c(ptr, sl->mb + i * 16, linesize,
499 sl->qscale, IS_INTRA(mb_type) ? 1 : 0);
500 }
501 }
502 }
503
504 static av_always_inline int dctcoef_get(int16_t *mb, int index)
505 {
506 return AV_RN16A(mb + index);
507 }
508
509 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
510 const H264Context *h,
511 H264SliceContext *sl,
512 int mb_type,
513 const int *block_offset,
514 int linesize,
515 uint8_t *dest_y)
516 {
517 int i;
518 int qscale = sl->qscale;
519
520 if (IS_INTRA4x4(mb_type)) {
521 for (i = 0; i < 16; i++) {
522 uint8_t *const ptr = dest_y + block_offset[i];
523 const int dir = sl->intra4x4_pred_mode_cache[scan8[i]];
524
525 uint8_t *topright;
526 int nnz, tr;
527 if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
528 const int topright_avail = (sl->topright_samples_available << i) & 0x8000;
529 assert(sl->mb_y || linesize <= block_offset[i]);
530 if (!topright_avail) {
531 tr = ptr[3 - linesize] * 0x01010101u;
532 topright = (uint8_t *)&tr;
533 } else
534 topright = ptr + 4 - linesize;
535 } else
536 topright = NULL;
537
538 s->hpc.pred4x4[dir](ptr, topright, linesize);
539 nnz = sl->non_zero_count_cache[scan8[i]];
540 if (nnz) {
541 svq3_add_idct_c(ptr, sl->mb + i * 16, linesize, qscale, 0);
542 }
543 }
544 } else {
545 s->hpc.pred16x16[sl->intra16x16_pred_mode](dest_y, linesize);
546 svq3_luma_dc_dequant_idct_c(sl->mb, sl->mb_luma_dc[0], qscale);
547 }
548 }
549
550 static void hl_decode_mb(SVQ3Context *s, const H264Context *h, H264SliceContext *sl)
551 {
552 const int mb_x = sl->mb_x;
553 const int mb_y = sl->mb_y;
554 const int mb_xy = sl->mb_xy;
555 const int mb_type = h->cur_pic.mb_type[mb_xy];
556 uint8_t *dest_y, *dest_cb, *dest_cr;
557 int linesize, uvlinesize;
558 int i, j;
559 const int *block_offset = &h->block_offset[0];
560 const int block_h = 16 >> h->chroma_y_shift;
561
562 dest_y = h->cur_pic.f->data[0] + (mb_x + mb_y * sl->linesize) * 16;
563 dest_cb = h->cur_pic.f->data[1] + mb_x * 8 + mb_y * sl->uvlinesize * block_h;
564 dest_cr = h->cur_pic.f->data[2] + mb_x * 8 + mb_y * sl->uvlinesize * block_h;
565
566 s->vdsp.prefetch(dest_y + (sl->mb_x & 3) * 4 * sl->linesize + 64, sl->linesize, 4);
567 s->vdsp.prefetch(dest_cb + (sl->mb_x & 7) * sl->uvlinesize + 64, dest_cr - dest_cb, 2);
568
569 h->list_counts[mb_xy] = sl->list_count;
570
571 linesize = sl->mb_linesize = sl->linesize;
572 uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
573
574 if (IS_INTRA(mb_type)) {
575 s->hpc.pred8x8[sl->chroma_pred_mode](dest_cb, uvlinesize);
576 s->hpc.pred8x8[sl->chroma_pred_mode](dest_cr, uvlinesize);
577
578 hl_decode_mb_predict_luma(s, h, sl, mb_type, block_offset, linesize, dest_y);
579 }
580
581 hl_decode_mb_idct_luma(h, sl, mb_type, block_offset, linesize, dest_y);
582
583 if (sl->cbp & 0x30) {
584 uint8_t *dest[2] = { dest_cb, dest_cr };
585 s->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + 16 * 16 * 1,
586 h->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][sl->chroma_qp[0]][0]);
587 s->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + 16 * 16 * 2,
588 h->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][sl->chroma_qp[1]][0]);
589 for (j = 1; j < 3; j++) {
590 for (i = j * 16; i < j * 16 + 4; i++)
591 if (sl->non_zero_count_cache[scan8[i]] || sl->mb[i * 16]) {
592 uint8_t *const ptr = dest[j - 1] + block_offset[i];
593 svq3_add_idct_c(ptr, sl->mb + i * 16,
594 uvlinesize, ff_h264_chroma_qp[0][sl->qscale + 12] - 12, 2);
595 }
596 }
597 }
598 }
599
600 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
601 {
602 H264Context *h = &s->h;
603 H264SliceContext *sl = &h->slice_ctx[0];
604 int i, j, k, m, dir, mode;
605 int cbp = 0;
606 uint32_t vlc;
607 int8_t *top, *left;
608 const int mb_xy = sl->mb_xy;
609 const int b_xy = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride;
610
611 sl->top_samples_available = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
612 sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
613 sl->topright_samples_available = 0xFFFF;
614
615 if (mb_type == 0) { /* SKIP */
616 if (h->pict_type == AV_PICTURE_TYPE_P ||
617 s->next_pic->mb_type[mb_xy] == -1) {
618 svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
619 0, 0, 0, 0, 0, 0);
620
621 if (h->pict_type == AV_PICTURE_TYPE_B)
622 svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
623 0, 0, 0, 0, 1, 1);
624
625 mb_type = MB_TYPE_SKIP;
626 } else {
627 mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
628 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
629 return -1;
630 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
631 return -1;
632
633 mb_type = MB_TYPE_16x16;
634 }
635 } else if (mb_type < 8) { /* INTER */
636 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
637 mode = THIRDPEL_MODE;
638 else if (s->halfpel_flag &&
639 s->thirdpel_flag == !get_bits1(&h->gb))
640 mode = HALFPEL_MODE;
641 else
642 mode = FULLPEL_MODE;
643
644 /* fill caches */
645 /* note ref_cache should contain here:
646 * ????????
647 * ???11111
648 * N??11111
649 * N??11111
650 * N??11111
651 */
652
653 for (m = 0; m < 2; m++) {
654 if (sl->mb_x > 0 && sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
655 for (i = 0; i < 4; i++)
656 AV_COPY32(sl->mv_cache[m][scan8[0] - 1 + i * 8],
657 h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
658 } else {
659 for (i = 0; i < 4; i++)
660 AV_ZERO32(sl->mv_cache[m][scan8[0] - 1 + i * 8]);
661 }
662 if (sl->mb_y > 0) {
663 memcpy(sl->mv_cache[m][scan8[0] - 1 * 8],
664 h->cur_pic.motion_val[m][b_xy - h->b_stride],
665 4 * 2 * sizeof(int16_t));
666 memset(&sl->ref_cache[m][scan8[0] - 1 * 8],
667 (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
668
669 if (sl->mb_x < h->mb_width - 1) {
670 AV_COPY32(sl->mv_cache[m][scan8[0] + 4 - 1 * 8],
671 h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
672 sl->ref_cache[m][scan8[0] + 4 - 1 * 8] =
673 (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
674 sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
675 } else
676 sl->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
677 if (sl->mb_x > 0) {
678 AV_COPY32(sl->mv_cache[m][scan8[0] - 1 - 1 * 8],
679 h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
680 sl->ref_cache[m][scan8[0] - 1 - 1 * 8] =
681 (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
682 } else
683 sl->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
684 } else
685 memset(&sl->ref_cache[m][scan8[0] - 1 * 8 - 1],
686 PART_NOT_AVAILABLE, 8);
687
688 if (h->pict_type != AV_PICTURE_TYPE_B)
689 break;
690 }
691
692 /* decode motion vector(s) and form prediction(s) */
693 if (h->pict_type == AV_PICTURE_TYPE_P) {
694 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
695 return -1;
696 } else { /* AV_PICTURE_TYPE_B */
697 if (mb_type != 2) {
698 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
699 return -1;
700 } else {
701 for (i = 0; i < 4; i++)
702 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
703 0, 4 * 2 * sizeof(int16_t));
704 }
705 if (mb_type != 1) {
706 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
707 return -1;
708 } else {
709 for (i = 0; i < 4; i++)
710 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
711 0, 4 * 2 * sizeof(int16_t));
712 }
713 }
714
715 mb_type = MB_TYPE_16x16;
716 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
717 memset(sl->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
718
719 if (mb_type == 8) {
720 if (sl->mb_x > 0) {
721 for (i = 0; i < 4; i++)
722 sl->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
723 if (sl->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
724 sl->left_samples_available = 0x5F5F;
725 }
726 if (sl->mb_y > 0) {
727 sl->intra4x4_pred_mode_cache[4 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
728 sl->intra4x4_pred_mode_cache[5 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
729 sl->intra4x4_pred_mode_cache[6 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
730 sl->intra4x4_pred_mode_cache[7 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
731
732 if (sl->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
733 sl->top_samples_available = 0x33FF;
734 }
735
736 /* decode prediction codes for luma blocks */
737 for (i = 0; i < 16; i += 2) {
738 vlc = svq3_get_ue_golomb(&h->gb);
739
740 if (vlc >= 25) {
741 av_log(h->avctx, AV_LOG_ERROR,
742 "luma prediction:%"PRIu32"\n", vlc);
743 return -1;
744 }
745
746 left = &sl->intra4x4_pred_mode_cache[scan8[i] - 1];
747 top = &sl->intra4x4_pred_mode_cache[scan8[i] - 8];
748
749 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
750 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
751
752 if (left[1] == -1 || left[2] == -1) {
753 av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
754 return -1;
755 }
756 }
757 } else { /* mb_type == 33, DC_128_PRED block type */
758 for (i = 0; i < 4; i++)
759 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
760 }
761
762 write_back_intra_pred_mode(h, sl);
763
764 if (mb_type == 8) {
765 ff_h264_check_intra4x4_pred_mode(h, sl);
766
767 sl->top_samples_available = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
768 sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
769 } else {
770 for (i = 0; i < 4; i++)
771 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
772
773 sl->top_samples_available = 0x33FF;
774 sl->left_samples_available = 0x5F5F;
775 }
776
777 mb_type = MB_TYPE_INTRA4x4;
778 } else { /* INTRA16x16 */
779 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
780 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
781
782 if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
783 av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
784 return sl->intra16x16_pred_mode;
785 }
786
787 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
788 mb_type = MB_TYPE_INTRA16x16;
789 }
790
791 if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
792 for (i = 0; i < 4; i++)
793 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
794 0, 4 * 2 * sizeof(int16_t));
795 if (h->pict_type == AV_PICTURE_TYPE_B) {
796 for (i = 0; i < 4; i++)
797 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
798 0, 4 * 2 * sizeof(int16_t));
799 }
800 }
801 if (!IS_INTRA4x4(mb_type)) {
802 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
803 }
804 if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
805 memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
806 }
807
808 if (!IS_INTRA16x16(mb_type) &&
809 (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
810 if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48) {
811 av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
812 return -1;
813 }
814
815 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
816 : ff_h264_golomb_to_inter_cbp[vlc];
817 }
818 if (IS_INTRA16x16(mb_type) ||
819 (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
820 sl->qscale += svq3_get_se_golomb(&h->gb);
821
822 if (sl->qscale > 31u) {
823 av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
824 return -1;
825 }
826 }
827 if (IS_INTRA16x16(mb_type)) {
828 AV_ZERO128(sl->mb_luma_dc[0] + 0);
829 AV_ZERO128(sl->mb_luma_dc[0] + 8);
830 if (svq3_decode_block(&h->gb, sl->mb_luma_dc[0], 0, 1)) {
831 av_log(h->avctx, AV_LOG_ERROR,
832 "error while decoding intra luma dc\n");
833 return -1;
834 }
835 }
836
837 if (cbp) {
838 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
839 const int type = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
840
841 for (i = 0; i < 4; i++)
842 if ((cbp & (1 << i))) {
843 for (j = 0; j < 4; j++) {
844 k = index ? (1 * (j & 1) + 2 * (i & 1) +
845 2 * (j & 2) + 4 * (i & 2))
846 : (4 * i + j);
847 sl->non_zero_count_cache[scan8[k]] = 1;
848
849 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
850 av_log(h->avctx, AV_LOG_ERROR,
851 "error while decoding block\n");
852 return -1;
853 }
854 }
855 }
856
857 if ((cbp & 0x30)) {
858 for (i = 1; i < 3; ++i)
859 if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
860 av_log(h->avctx, AV_LOG_ERROR,
861 "error while decoding chroma dc block\n");
862 return -1;
863 }
864
865 if ((cbp & 0x20)) {
866 for (i = 1; i < 3; i++) {
867 for (j = 0; j < 4; j++) {
868 k = 16 * i + j;
869 sl->non_zero_count_cache[scan8[k]] = 1;
870
871 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
872 av_log(h->avctx, AV_LOG_ERROR,
873 "error while decoding chroma ac block\n");
874 return -1;
875 }
876 }
877 }
878 }
879 }
880 }
881
882 sl->cbp = cbp;
883 h->cur_pic.mb_type[mb_xy] = mb_type;
884
885 if (IS_INTRA(mb_type))
886 sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, sl, DC_PRED8x8, 1);
887
888 return 0;
889 }
890
891 static int svq3_decode_slice_header(AVCodecContext *avctx)
892 {
893 SVQ3Context *s = avctx->priv_data;
894 H264Context *h = &s->h;
895 H264SliceContext *sl = &h->slice_ctx[0];
896 const int mb_xy = sl->mb_xy;
897 int i, header;
898 unsigned slice_id;
899
900 header = get_bits(&s->gb, 8);
901
902 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
903 /* TODO: what? */
904 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
905 return -1;
906 } else {
907 int slice_bits, slice_bytes, slice_length;
908 int length = header >> 5 & 3;
909
910 slice_length = show_bits(&s->gb, 8 * length);
911 slice_bits = slice_length * 8;
912 slice_bytes = slice_length + length - 1;
913
914 if (slice_bytes > get_bits_left(&s->gb)) {
915 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
916 return -1;
917 }
918
919 skip_bits(&s->gb, 8);
920
921 av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
922 if (!s->slice_buf)
923 return AVERROR(ENOMEM);
924
925 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
926
927 init_get_bits(&h->gb, s->slice_buf, slice_bits);
928
929 if (s->watermark_key) {
930 uint32_t header = AV_RL32(&h->gb.buffer[1]);
931 AV_WL32(&h->gb.buffer[1], header ^ s->watermark_key);
932 }
933 if (length > 0) {
934 memcpy(s->slice_buf, &s->slice_buf[slice_length], length - 1);
935 }
936 skip_bits_long(&s->gb, slice_bytes * 8);
937 }
938
939 if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
940 av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
941 return -1;
942 }
943
944 sl->slice_type = ff_h264_golomb_to_pict_type[slice_id];
945
946 if ((header & 0x9F) == 2) {
947 i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
948 sl->mb_skip_run = get_bits(&h->gb, i) -
949 (sl->mb_y * h->mb_width + sl->mb_x);
950 } else {
951 skip_bits1(&h->gb);
952 sl->mb_skip_run = 0;
953 }
954
955 sl->slice_num = get_bits(&h->gb, 8);
956 sl->qscale = get_bits(&h->gb, 5);
957 s->adaptive_quant = get_bits1(&h->gb);
958
959 /* unknown fields */
960 skip_bits1(&h->gb);
961
962 if (s->unknown_flag)
963 skip_bits1(&h->gb);
964
965 skip_bits1(&h->gb);
966 skip_bits(&h->gb, 2);
967
968 while (get_bits1(&h->gb))
969 skip_bits(&h->gb, 8);
970
971 /* reset intra predictors and invalidate motion vector references */
972 if (sl->mb_x > 0) {
973 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
974 -1, 4 * sizeof(int8_t));
975 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - sl->mb_x],
976 -1, 8 * sizeof(int8_t) * sl->mb_x);
977 }
978 if (sl->mb_y > 0) {
979 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
980 -1, 8 * sizeof(int8_t) * (h->mb_width - sl->mb_x));
981
982 if (sl->mb_x > 0)
983 sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
984 }
985
986 return 0;
987 }
988
989 static av_cold int svq3_decode_init(AVCodecContext *avctx)
990 {
991 SVQ3Context *s = avctx->priv_data;
992 H264Context *h = &s->h;
993 H264SliceContext *sl;
994 int m;
995 unsigned char *extradata;
996 unsigned char *extradata_end;
997 unsigned int size;
998 int marker_found = 0;
999
1000 s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1001 s->last_pic = av_mallocz(sizeof(*s->last_pic));
1002 s->next_pic = av_mallocz(sizeof(*s->next_pic));
1003 if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1004 av_freep(&s->cur_pic);
1005 av_freep(&s->last_pic);
1006 av_freep(&s->next_pic);
1007 return AVERROR(ENOMEM);
1008 }
1009
1010 s->cur_pic->f = av_frame_alloc();
1011 s->last_pic->f = av_frame_alloc();
1012 s->next_pic->f = av_frame_alloc();
1013 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1014 return AVERROR(ENOMEM);
1015
1016 if (ff_h264_decode_init(avctx) < 0)
1017 return -1;
1018
1019 // we will overwrite it later during decoding
1020 av_frame_free(&h->cur_pic.f);
1021
1022 ff_h264dsp_init(&s->h264dsp, 8, 1);
1023 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1024 ff_videodsp_init(&s->vdsp, 8);
1025
1026 memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
1027 memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
1028
1029 h->sps.bit_depth_luma = 8;
1030 h->chroma_format_idc = 1;
1031
1032 ff_hpeldsp_init(&s->hdsp, avctx->flags);
1033 ff_tpeldsp_init(&s->tdsp);
1034
1035 sl = h->slice_ctx;
1036
1037 h->flags = avctx->flags;
1038 sl->is_complex = 1;
1039 h->picture_structure = PICT_FRAME;
1040 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1041 avctx->color_range = AVCOL_RANGE_JPEG;
1042
1043 h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
1044 h->chroma_x_shift = h->chroma_y_shift = 1;
1045
1046 s->halfpel_flag = 1;
1047 s->thirdpel_flag = 1;
1048 s->unknown_flag = 0;
1049
1050 /* prowl for the "SEQH" marker in the extradata */
1051 extradata = (unsigned char *)avctx->extradata;
1052 extradata_end = avctx->extradata + avctx->extradata_size;
1053 if (extradata) {
1054 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1055 if (!memcmp(extradata, "SEQH", 4)) {
1056 marker_found = 1;
1057 break;
1058 }
1059 extradata++;
1060 }
1061 }
1062
1063 /* if a match was found, parse the extra data */
1064 if (marker_found) {
1065 GetBitContext gb;
1066 int frame_size_code;
1067
1068 size = AV_RB32(&extradata[4]);
1069 if (size > extradata_end - extradata - 8)
1070 return AVERROR_INVALIDDATA;
1071 init_get_bits(&gb, extradata + 8, size * 8);
1072
1073 /* 'frame size code' and optional 'width, height' */
1074 frame_size_code = get_bits(&gb, 3);
1075 switch (frame_size_code) {
1076 case 0:
1077 avctx->width = 160;
1078 avctx->height = 120;
1079 break;
1080 case 1:
1081 avctx->width = 128;
1082 avctx->height = 96;
1083 break;
1084 case 2:
1085 avctx->width = 176;
1086 avctx->height = 144;
1087 break;
1088 case 3:
1089 avctx->width = 352;
1090 avctx->height = 288;
1091 break;
1092 case 4:
1093 avctx->width = 704;
1094 avctx->height = 576;
1095 break;
1096 case 5:
1097 avctx->width = 240;
1098 avctx->height = 180;
1099 break;
1100 case 6:
1101 avctx->width = 320;
1102 avctx->height = 240;
1103 break;
1104 case 7:
1105 avctx->width = get_bits(&gb, 12);
1106 avctx->height = get_bits(&gb, 12);
1107 break;
1108 }
1109
1110 s->halfpel_flag = get_bits1(&gb);
1111 s->thirdpel_flag = get_bits1(&gb);
1112
1113 /* unknown fields */
1114 skip_bits1(&gb);
1115 skip_bits1(&gb);
1116 skip_bits1(&gb);
1117 skip_bits1(&gb);
1118
1119 h->low_delay = get_bits1(&gb);
1120
1121 /* unknown field */
1122 skip_bits1(&gb);
1123
1124 while (get_bits1(&gb))
1125 skip_bits(&gb, 8);
1126
1127 s->unknown_flag = get_bits1(&gb);
1128 avctx->has_b_frames = !h->low_delay;
1129 if (s->unknown_flag) {
1130 #if CONFIG_ZLIB
1131 unsigned watermark_width = svq3_get_ue_golomb(&gb);
1132 unsigned watermark_height = svq3_get_ue_golomb(&gb);
1133 int u1 = svq3_get_ue_golomb(&gb);
1134 int u2 = get_bits(&gb, 8);
1135 int u3 = get_bits(&gb, 2);
1136 int u4 = svq3_get_ue_golomb(&gb);
1137 unsigned long buf_len = watermark_width *
1138 watermark_height * 4;
1139 int offset = get_bits_count(&gb) + 7 >> 3;
1140 uint8_t *buf;
1141
1142 if (watermark_height > 0 &&
1143 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1144 return -1;
1145
1146 buf = av_malloc(buf_len);
1147 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1148 watermark_width, watermark_height);
1149 av_log(avctx, AV_LOG_DEBUG,
1150 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1151 u1, u2, u3, u4, offset);
1152 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1153 size - offset) != Z_OK) {
1154 av_log(avctx, AV_LOG_ERROR,
1155 "could not uncompress watermark logo\n");
1156 av_free(buf);
1157 return -1;
1158 }
1159 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1160 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1161 av_log(avctx, AV_LOG_DEBUG,
1162 "watermark key %#"PRIx32"\n", s->watermark_key);
1163 av_free(buf);
1164 #else
1165 av_log(avctx, AV_LOG_ERROR,
1166 "this svq3 file contains watermark which need zlib support compiled in\n");
1167 return -1;
1168 #endif
1169 }
1170 }
1171
1172 h->width = avctx->width;
1173 h->height = avctx->height;
1174 h->mb_width = (h->width + 15) / 16;
1175 h->mb_height = (h->height + 15) / 16;
1176 h->mb_stride = h->mb_width + 1;
1177 h->mb_num = h->mb_width * h->mb_height;
1178 h->b_stride = 4 * h->mb_width;
1179 s->h_edge_pos = h->mb_width * 16;
1180 s->v_edge_pos = h->mb_height * 16;
1181
1182 if (ff_h264_alloc_tables(h) < 0) {
1183 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1184 return AVERROR(ENOMEM);
1185 }
1186
1187 return 0;
1188 }
1189
1190 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1191 {
1192 int i;
1193 for (i = 0; i < 2; i++) {
1194 av_buffer_unref(&pic->motion_val_buf[i]);
1195 av_buffer_unref(&pic->ref_index_buf[i]);
1196 }
1197 av_buffer_unref(&pic->mb_type_buf);
1198
1199 av_frame_unref(pic->f);
1200 }
1201
1202 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1203 {
1204 SVQ3Context *s = avctx->priv_data;
1205 H264Context *h = &s->h;
1206 H264SliceContext *sl = &h->slice_ctx[0];
1207 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1208 const int mb_array_size = h->mb_stride * h->mb_height;
1209 const int b4_stride = h->mb_width * 4 + 1;
1210 const int b4_array_size = b4_stride * h->mb_height * 4;
1211 int ret;
1212
1213 if (!pic->motion_val_buf[0]) {
1214 int i;
1215
1216 pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1217 if (!pic->mb_type_buf)
1218 return AVERROR(ENOMEM);
1219 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1220
1221 for (i = 0; i < 2; i++) {
1222 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1223 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1224 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1225 ret = AVERROR(ENOMEM);
1226 goto fail;
1227 }
1228
1229 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1230 pic->ref_index[i] = pic->ref_index_buf[i]->data;
1231 }
1232 }
1233 pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1234
1235 ret = ff_get_buffer(avctx, pic->f,
1236 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1237 if (ret < 0)
1238 goto fail;
1239
1240 if (!sl->edge_emu_buffer) {
1241 sl->edge_emu_buffer = av_mallocz(pic->f->linesize[0] * 17);
1242 if (!sl->edge_emu_buffer)
1243 return AVERROR(ENOMEM);
1244 }
1245
1246 sl->linesize = pic->f->linesize[0];
1247 sl->uvlinesize = pic->f->linesize[1];
1248
1249 return 0;
1250 fail:
1251 free_picture(avctx, pic);
1252 return ret;
1253 }
1254
1255 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1256 int *got_frame, AVPacket *avpkt)
1257 {
1258 const uint8_t *buf = avpkt->data;
1259 SVQ3Context *s = avctx->priv_data;
1260 H264Context *h = &s->h;
1261 H264SliceContext *sl = &h->slice_ctx[0];
1262 int buf_size = avpkt->size;
1263 int ret, m, i;
1264
1265 /* special case for last picture */
1266 if (buf_size == 0) {
1267 if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
1268 ret = av_frame_ref(data, s->next_pic->f);
1269 if (ret < 0)
1270 return ret;
1271 s->last_frame_output = 1;
1272 *got_frame = 1;
1273 }
1274 return 0;
1275 }
1276
1277 ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1278 if (ret < 0)
1279 return ret;
1280
1281 sl->mb_x = sl->mb_y = sl->mb_xy = 0;
1282
1283 if (svq3_decode_slice_header(avctx))
1284 return -1;
1285
1286 h->pict_type = sl->slice_type;
1287
1288 if (h->pict_type != AV_PICTURE_TYPE_B)
1289 FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1290
1291 av_frame_unref(s->cur_pic->f);
1292
1293 /* for skipping the frame */
1294 s->cur_pic->f->pict_type = h->pict_type;
1295 s->cur_pic->f->key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1296
1297 ret = get_buffer(avctx, s->cur_pic);
1298 if (ret < 0)
1299 return ret;
1300
1301 h->cur_pic_ptr = s->cur_pic;
1302 h->cur_pic = *s->cur_pic;
1303
1304 for (i = 0; i < 16; i++) {
1305 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1306 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1307 }
1308 for (i = 0; i < 16; i++) {
1309 h->block_offset[16 + i] =
1310 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1311 h->block_offset[48 + 16 + i] =
1312 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1313 }
1314
1315 if (h->pict_type != AV_PICTURE_TYPE_I) {
1316 if (!s->last_pic->f->data[0]) {
1317 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1318 ret = get_buffer(avctx, s->last_pic);
1319 if (ret < 0)
1320 return ret;
1321 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1322 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1323 s->last_pic->f->linesize[1]);
1324 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1325 s->last_pic->f->linesize[2]);
1326 }
1327
1328 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1329 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1330 ret = get_buffer(avctx, s->next_pic);
1331 if (ret < 0)
1332 return ret;
1333 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1334 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1335 s->next_pic->f->linesize[1]);
1336 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1337 s->next_pic->f->linesize[2]);
1338 }
1339 }
1340
1341 if (avctx->debug & FF_DEBUG_PICT_INFO)
1342 av_log(h->avctx, AV_LOG_DEBUG,
1343 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1344 av_get_picture_type_char(h->pict_type),
1345 s->halfpel_flag, s->thirdpel_flag,
1346 s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
1347
1348 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1349 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1350 avctx->skip_frame >= AVDISCARD_ALL)
1351 return 0;
1352
1353 if (s->next_p_frame_damaged) {
1354 if (h->pict_type == AV_PICTURE_TYPE_B)
1355 return 0;
1356 else
1357 s->next_p_frame_damaged = 0;
1358 }
1359
1360 if (h->pict_type == AV_PICTURE_TYPE_B) {
1361 h->frame_num_offset = sl->slice_num - h->prev_frame_num;
1362
1363 if (h->frame_num_offset < 0)
1364 h->frame_num_offset += 256;
1365 if (h->frame_num_offset == 0 ||
1366 h->frame_num_offset >= h->prev_frame_num_offset) {
1367 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1368 return -1;
1369 }
1370 } else {
1371 h->prev_frame_num = h->frame_num;
1372 h->frame_num = sl->slice_num;
1373 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1374
1375 if (h->prev_frame_num_offset < 0)
1376 h->prev_frame_num_offset += 256;
1377 }
1378
1379 for (m = 0; m < 2; m++) {
1380 int i;
1381 for (i = 0; i < 4; i++) {
1382 int j;
1383 for (j = -1; j < 4; j++)
1384 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1385 if (i < 3)
1386 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1387 }
1388 }
1389
1390 for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
1391 for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
1392 unsigned mb_type;
1393 sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
1394
1395 if ((get_bits_left(&h->gb)) <= 7) {
1396 if (((get_bits_count(&h->gb) & 7) == 0 ||
1397 show_bits(&h->gb, get_bits_left(&h->gb) & 7) == 0)) {
1398
1399 if (svq3_decode_slice_header(avctx))
1400 return -1;
1401 }
1402 /* TODO: support s->mb_skip_run */
1403 }
1404
1405 mb_type = svq3_get_ue_golomb(&h->gb);
1406
1407 if (h->pict_type == AV_PICTURE_TYPE_I)
1408 mb_type += 8;
1409 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1410 mb_type += 4;
1411 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1412 av_log(h->avctx, AV_LOG_ERROR,
1413 "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
1414 return -1;
1415 }
1416
1417 if (mb_type != 0)
1418 hl_decode_mb(s, h, &h->slice_ctx[0]);
1419
1420 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1421 h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
1422 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1423 }
1424
1425 ff_draw_horiz_band(avctx, s->cur_pic->f,
1426 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1427 16 * sl->mb_y, 16, h->picture_structure, 0,
1428 h->low_delay);
1429 }
1430
1431 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1432 ret = av_frame_ref(data, s->cur_pic->f);
1433 else if (s->last_pic->f->data[0])
1434 ret = av_frame_ref(data, s->last_pic->f);
1435 if (ret < 0)
1436 return ret;
1437
1438 /* Do not output the last pic after seeking. */
1439 if (s->last_pic->f->data[0] || h->low_delay)
1440 *got_frame = 1;
1441
1442 if (h->pict_type != AV_PICTURE_TYPE_B) {
1443 FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1444 } else {
1445 av_frame_unref(s->cur_pic->f);
1446 }
1447
1448 return buf_size;
1449 }
1450
1451 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1452 {
1453 SVQ3Context *s = avctx->priv_data;
1454 H264Context *h = &s->h;
1455
1456 free_picture(avctx, s->cur_pic);
1457 free_picture(avctx, s->next_pic);
1458 free_picture(avctx, s->last_pic);
1459 av_frame_free(&s->cur_pic->f);
1460 av_frame_free(&s->next_pic->f);
1461 av_frame_free(&s->last_pic->f);
1462 av_freep(&s->cur_pic);
1463 av_freep(&s->next_pic);
1464 av_freep(&s->last_pic);
1465 av_freep(&s->slice_buf);
1466
1467 memset(&h->cur_pic, 0, sizeof(h->cur_pic));
1468
1469 ff_h264_free_context(h);
1470
1471 return 0;
1472 }
1473
1474 AVCodec ff_svq3_decoder = {
1475 .name = "svq3",
1476 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1477 .type = AVMEDIA_TYPE_VIDEO,
1478 .id = AV_CODEC_ID_SVQ3,
1479 .priv_data_size = sizeof(SVQ3Context),
1480 .init = svq3_decode_init,
1481 .close = svq3_decode_end,
1482 .decode = svq3_decode_frame,
1483 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1484 AV_CODEC_CAP_DR1 |
1485 AV_CODEC_CAP_DELAY,
1486 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1487 AV_PIX_FMT_NONE},
1488 };