projects / libav.git / blob
? search:


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