h264: move ff_h264_check_intra[4x4]_pred_mode() to h264_parse
[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(sl->intra4x4_pred_mode_cache,
775 h->avctx, sl->top_samples_available,
776 sl->left_samples_available);
777
778 sl->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
779 sl->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
780 } else {
781 for (i = 0; i < 4; i++)
782 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
783
784 sl->top_samples_available = 0x33FF;
785 sl->left_samples_available = 0x5F5F;
786 }
787
788 mb_type = MB_TYPE_INTRA4x4;
789 } else { /* INTRA16x16 */
790 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
791 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
792
793 if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
794 sl->left_samples_available, dir, 0)) < 0) {
795 av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
796 return sl->intra16x16_pred_mode;
797 }
798
799 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
800 mb_type = MB_TYPE_INTRA16x16;
801 }
802
803 if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
804 for (i = 0; i < 4; i++)
805 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
806 0, 4 * 2 * sizeof(int16_t));
807 if (h->pict_type == AV_PICTURE_TYPE_B) {
808 for (i = 0; i < 4; i++)
809 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
810 0, 4 * 2 * sizeof(int16_t));
811 }
812 }
813 if (!IS_INTRA4x4(mb_type)) {
814 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
815 }
816 if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
817 memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
818 }
819
820 if (!IS_INTRA16x16(mb_type) &&
821 (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
822 if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48) {
823 av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
824 return -1;
825 }
826
827 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
828 : ff_h264_golomb_to_inter_cbp[vlc];
829 }
830 if (IS_INTRA16x16(mb_type) ||
831 (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
832 sl->qscale += svq3_get_se_golomb(&h->gb);
833
834 if (sl->qscale > 31u) {
835 av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
836 return -1;
837 }
838 }
839 if (IS_INTRA16x16(mb_type)) {
840 AV_ZERO128(sl->mb_luma_dc[0] + 0);
841 AV_ZERO128(sl->mb_luma_dc[0] + 8);
842 if (svq3_decode_block(&h->gb, sl->mb_luma_dc[0], 0, 1)) {
843 av_log(h->avctx, AV_LOG_ERROR,
844 "error while decoding intra luma dc\n");
845 return -1;
846 }
847 }
848
849 if (cbp) {
850 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
851 const int type = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
852
853 for (i = 0; i < 4; i++)
854 if ((cbp & (1 << i))) {
855 for (j = 0; j < 4; j++) {
856 k = index ? (1 * (j & 1) + 2 * (i & 1) +
857 2 * (j & 2) + 4 * (i & 2))
858 : (4 * i + j);
859 sl->non_zero_count_cache[scan8[k]] = 1;
860
861 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
862 av_log(h->avctx, AV_LOG_ERROR,
863 "error while decoding block\n");
864 return -1;
865 }
866 }
867 }
868
869 if ((cbp & 0x30)) {
870 for (i = 1; i < 3; ++i)
871 if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
872 av_log(h->avctx, AV_LOG_ERROR,
873 "error while decoding chroma dc block\n");
874 return -1;
875 }
876
877 if ((cbp & 0x20)) {
878 for (i = 1; i < 3; i++) {
879 for (j = 0; j < 4; j++) {
880 k = 16 * i + j;
881 sl->non_zero_count_cache[scan8[k]] = 1;
882
883 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
884 av_log(h->avctx, AV_LOG_ERROR,
885 "error while decoding chroma ac block\n");
886 return -1;
887 }
888 }
889 }
890 }
891 }
892 }
893
894 sl->cbp = cbp;
895 h->cur_pic.mb_type[mb_xy] = mb_type;
896
897 if (IS_INTRA(mb_type))
898 sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
899 sl->left_samples_available, DC_PRED8x8, 1);
900
901 return 0;
902 }
903
904 static int svq3_decode_slice_header(AVCodecContext *avctx)
905 {
906 SVQ3Context *s = avctx->priv_data;
907 H264Context *h = &s->h;
908 H264SliceContext *sl = &h->slice_ctx[0];
909 const int mb_xy = s->mb_xy;
910 int i, header;
911 unsigned slice_id;
912
913 header = get_bits(&s->gb, 8);
914
915 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
916 /* TODO: what? */
917 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
918 return -1;
919 } else {
920 int slice_bits, slice_bytes, slice_length;
921 int length = header >> 5 & 3;
922
923 slice_length = show_bits(&s->gb, 8 * length);
924 slice_bits = slice_length * 8;
925 slice_bytes = slice_length + length - 1;
926
927 if (slice_bytes > get_bits_left(&s->gb)) {
928 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
929 return -1;
930 }
931
932 skip_bits(&s->gb, 8);
933
934 av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
935 if (!s->slice_buf)
936 return AVERROR(ENOMEM);
937
938 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
939
940 init_get_bits(&h->gb, s->slice_buf, slice_bits);
941
942 if (s->watermark_key) {
943 uint32_t header = AV_RL32(&h->gb.buffer[1]);
944 AV_WL32(&h->gb.buffer[1], header ^ s->watermark_key);
945 }
946 if (length > 0) {
947 memcpy(s->slice_buf, &s->slice_buf[slice_length], length - 1);
948 }
949 skip_bits_long(&s->gb, slice_bytes * 8);
950 }
951
952 if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
953 av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
954 return -1;
955 }
956
957 sl->slice_type = ff_h264_golomb_to_pict_type[slice_id];
958
959 if ((header & 0x9F) == 2) {
960 i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
961 sl->mb_skip_run = get_bits(&h->gb, i) -
962 (s->mb_y * h->mb_width + s->mb_x);
963 } else {
964 skip_bits1(&h->gb);
965 sl->mb_skip_run = 0;
966 }
967
968 sl->slice_num = get_bits(&h->gb, 8);
969 sl->qscale = get_bits(&h->gb, 5);
970 s->adaptive_quant = get_bits1(&h->gb);
971
972 /* unknown fields */
973 skip_bits1(&h->gb);
974
975 if (s->unknown_flag)
976 skip_bits1(&h->gb);
977
978 skip_bits1(&h->gb);
979 skip_bits(&h->gb, 2);
980
981 while (get_bits1(&h->gb))
982 skip_bits(&h->gb, 8);
983
984 /* reset intra predictors and invalidate motion vector references */
985 if (s->mb_x > 0) {
986 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
987 -1, 4 * sizeof(int8_t));
988 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
989 -1, 8 * sizeof(int8_t) * s->mb_x);
990 }
991 if (s->mb_y > 0) {
992 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
993 -1, 8 * sizeof(int8_t) * (h->mb_width - s->mb_x));
994
995 if (s->mb_x > 0)
996 sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
997 }
998
999 return 0;
1000 }
1001
1002 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1003 {
1004 SVQ3Context *s = avctx->priv_data;
1005 H264Context *h = &s->h;
1006 H264SliceContext *sl;
1007 int m;
1008 unsigned char *extradata;
1009 unsigned char *extradata_end;
1010 unsigned int size;
1011 int marker_found = 0;
1012
1013 s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1014 s->last_pic = av_mallocz(sizeof(*s->last_pic));
1015 s->next_pic = av_mallocz(sizeof(*s->next_pic));
1016 if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1017 av_freep(&s->cur_pic);
1018 av_freep(&s->last_pic);
1019 av_freep(&s->next_pic);
1020 return AVERROR(ENOMEM);
1021 }
1022
1023 s->cur_pic->f = av_frame_alloc();
1024 s->last_pic->f = av_frame_alloc();
1025 s->next_pic->f = av_frame_alloc();
1026 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1027 return AVERROR(ENOMEM);
1028
1029 if (ff_h264_decode_init(avctx) < 0)
1030 return -1;
1031
1032 // we will overwrite it later during decoding
1033 av_frame_free(&h->cur_pic.f);
1034
1035 ff_h264dsp_init(&s->h264dsp, 8, 1);
1036 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1037 ff_videodsp_init(&s->vdsp, 8);
1038
1039 memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
1040 memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
1041
1042 h->sps.bit_depth_luma = 8;
1043 h->chroma_format_idc = 1;
1044
1045 ff_hpeldsp_init(&s->hdsp, avctx->flags);
1046 ff_tpeldsp_init(&s->tdsp);
1047
1048 sl = h->slice_ctx;
1049
1050 h->flags = avctx->flags;
1051 sl->is_complex = 1;
1052 h->picture_structure = PICT_FRAME;
1053 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1054 avctx->color_range = AVCOL_RANGE_JPEG;
1055
1056 h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
1057 h->chroma_x_shift = h->chroma_y_shift = 1;
1058
1059 s->halfpel_flag = 1;
1060 s->thirdpel_flag = 1;
1061 s->unknown_flag = 0;
1062
1063 /* prowl for the "SEQH" marker in the extradata */
1064 extradata = (unsigned char *)avctx->extradata;
1065 extradata_end = avctx->extradata + avctx->extradata_size;
1066 if (extradata) {
1067 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1068 if (!memcmp(extradata, "SEQH", 4)) {
1069 marker_found = 1;
1070 break;
1071 }
1072 extradata++;
1073 }
1074 }
1075
1076 /* if a match was found, parse the extra data */
1077 if (marker_found) {
1078 GetBitContext gb;
1079 int frame_size_code;
1080
1081 size = AV_RB32(&extradata[4]);
1082 if (size > extradata_end - extradata - 8)
1083 return AVERROR_INVALIDDATA;
1084 init_get_bits(&gb, extradata + 8, size * 8);
1085
1086 /* 'frame size code' and optional 'width, height' */
1087 frame_size_code = get_bits(&gb, 3);
1088 switch (frame_size_code) {
1089 case 0:
1090 avctx->width = 160;
1091 avctx->height = 120;
1092 break;
1093 case 1:
1094 avctx->width = 128;
1095 avctx->height = 96;
1096 break;
1097 case 2:
1098 avctx->width = 176;
1099 avctx->height = 144;
1100 break;
1101 case 3:
1102 avctx->width = 352;
1103 avctx->height = 288;
1104 break;
1105 case 4:
1106 avctx->width = 704;
1107 avctx->height = 576;
1108 break;
1109 case 5:
1110 avctx->width = 240;
1111 avctx->height = 180;
1112 break;
1113 case 6:
1114 avctx->width = 320;
1115 avctx->height = 240;
1116 break;
1117 case 7:
1118 avctx->width = get_bits(&gb, 12);
1119 avctx->height = get_bits(&gb, 12);
1120 break;
1121 }
1122
1123 s->halfpel_flag = get_bits1(&gb);
1124 s->thirdpel_flag = get_bits1(&gb);
1125
1126 /* unknown fields */
1127 skip_bits1(&gb);
1128 skip_bits1(&gb);
1129 skip_bits1(&gb);
1130 skip_bits1(&gb);
1131
1132 h->low_delay = get_bits1(&gb);
1133
1134 /* unknown field */
1135 skip_bits1(&gb);
1136
1137 while (get_bits1(&gb))
1138 skip_bits(&gb, 8);
1139
1140 s->unknown_flag = get_bits1(&gb);
1141 avctx->has_b_frames = !h->low_delay;
1142 if (s->unknown_flag) {
1143 #if CONFIG_ZLIB
1144 unsigned watermark_width = svq3_get_ue_golomb(&gb);
1145 unsigned watermark_height = svq3_get_ue_golomb(&gb);
1146 int u1 = svq3_get_ue_golomb(&gb);
1147 int u2 = get_bits(&gb, 8);
1148 int u3 = get_bits(&gb, 2);
1149 int u4 = svq3_get_ue_golomb(&gb);
1150 unsigned long buf_len = watermark_width *
1151 watermark_height * 4;
1152 int offset = get_bits_count(&gb) + 7 >> 3;
1153 uint8_t *buf;
1154
1155 if (watermark_height > 0 &&
1156 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1157 return -1;
1158
1159 buf = av_malloc(buf_len);
1160 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1161 watermark_width, watermark_height);
1162 av_log(avctx, AV_LOG_DEBUG,
1163 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1164 u1, u2, u3, u4, offset);
1165 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1166 size - offset) != Z_OK) {
1167 av_log(avctx, AV_LOG_ERROR,
1168 "could not uncompress watermark logo\n");
1169 av_free(buf);
1170 return -1;
1171 }
1172 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1173 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1174 av_log(avctx, AV_LOG_DEBUG,
1175 "watermark key %#"PRIx32"\n", s->watermark_key);
1176 av_free(buf);
1177 #else
1178 av_log(avctx, AV_LOG_ERROR,
1179 "this svq3 file contains watermark which need zlib support compiled in\n");
1180 return -1;
1181 #endif
1182 }
1183 }
1184
1185 h->width = avctx->width;
1186 h->height = avctx->height;
1187 h->mb_width = (h->width + 15) / 16;
1188 h->mb_height = (h->height + 15) / 16;
1189 h->mb_stride = h->mb_width + 1;
1190 h->mb_num = h->mb_width * h->mb_height;
1191 h->b_stride = 4 * h->mb_width;
1192 s->h_edge_pos = h->mb_width * 16;
1193 s->v_edge_pos = h->mb_height * 16;
1194
1195 if (ff_h264_alloc_tables(h) < 0) {
1196 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1197 return AVERROR(ENOMEM);
1198 }
1199
1200 return 0;
1201 }
1202
1203 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1204 {
1205 int i;
1206 for (i = 0; i < 2; i++) {
1207 av_buffer_unref(&pic->motion_val_buf[i]);
1208 av_buffer_unref(&pic->ref_index_buf[i]);
1209 }
1210 av_buffer_unref(&pic->mb_type_buf);
1211
1212 av_frame_unref(pic->f);
1213 }
1214
1215 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1216 {
1217 SVQ3Context *s = avctx->priv_data;
1218 H264Context *h = &s->h;
1219 H264SliceContext *sl = &h->slice_ctx[0];
1220 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1221 const int mb_array_size = h->mb_stride * h->mb_height;
1222 const int b4_stride = h->mb_width * 4 + 1;
1223 const int b4_array_size = b4_stride * h->mb_height * 4;
1224 int ret;
1225
1226 if (!pic->motion_val_buf[0]) {
1227 int i;
1228
1229 pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1230 if (!pic->mb_type_buf)
1231 return AVERROR(ENOMEM);
1232 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1233
1234 for (i = 0; i < 2; i++) {
1235 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1236 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1237 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1238 ret = AVERROR(ENOMEM);
1239 goto fail;
1240 }
1241
1242 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1243 pic->ref_index[i] = pic->ref_index_buf[i]->data;
1244 }
1245 }
1246 pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1247
1248 ret = ff_get_buffer(avctx, pic->f,
1249 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1250 if (ret < 0)
1251 goto fail;
1252
1253 if (!sl->edge_emu_buffer) {
1254 sl->edge_emu_buffer = av_mallocz(pic->f->linesize[0] * 17);
1255 if (!sl->edge_emu_buffer)
1256 return AVERROR(ENOMEM);
1257 }
1258
1259 sl->linesize = pic->f->linesize[0];
1260 sl->uvlinesize = pic->f->linesize[1];
1261
1262 return 0;
1263 fail:
1264 free_picture(avctx, pic);
1265 return ret;
1266 }
1267
1268 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1269 int *got_frame, AVPacket *avpkt)
1270 {
1271 const uint8_t *buf = avpkt->data;
1272 SVQ3Context *s = avctx->priv_data;
1273 H264Context *h = &s->h;
1274 H264SliceContext *sl = &h->slice_ctx[0];
1275 int buf_size = avpkt->size;
1276 int ret, m, i;
1277
1278 /* special case for last picture */
1279 if (buf_size == 0) {
1280 if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
1281 ret = av_frame_ref(data, s->next_pic->f);
1282 if (ret < 0)
1283 return ret;
1284 s->last_frame_output = 1;
1285 *got_frame = 1;
1286 }
1287 return 0;
1288 }
1289
1290 ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1291 if (ret < 0)
1292 return ret;
1293
1294 s->mb_x = s->mb_y = s->mb_xy = 0;
1295
1296 if (svq3_decode_slice_header(avctx))
1297 return -1;
1298
1299 h->pict_type = sl->slice_type;
1300
1301 if (h->pict_type != AV_PICTURE_TYPE_B)
1302 FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1303
1304 av_frame_unref(s->cur_pic->f);
1305
1306 /* for skipping the frame */
1307 s->cur_pic->f->pict_type = h->pict_type;
1308 s->cur_pic->f->key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1309
1310 ret = get_buffer(avctx, s->cur_pic);
1311 if (ret < 0)
1312 return ret;
1313
1314 h->cur_pic_ptr = s->cur_pic;
1315 h->cur_pic = *s->cur_pic;
1316
1317 for (i = 0; i < 16; i++) {
1318 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1319 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1320 }
1321 for (i = 0; i < 16; i++) {
1322 h->block_offset[16 + i] =
1323 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1324 h->block_offset[48 + 16 + i] =
1325 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1326 }
1327
1328 if (h->pict_type != AV_PICTURE_TYPE_I) {
1329 if (!s->last_pic->f->data[0]) {
1330 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1331 ret = get_buffer(avctx, s->last_pic);
1332 if (ret < 0)
1333 return ret;
1334 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1335 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1336 s->last_pic->f->linesize[1]);
1337 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1338 s->last_pic->f->linesize[2]);
1339 }
1340
1341 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1342 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1343 ret = get_buffer(avctx, s->next_pic);
1344 if (ret < 0)
1345 return ret;
1346 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1347 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1348 s->next_pic->f->linesize[1]);
1349 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1350 s->next_pic->f->linesize[2]);
1351 }
1352 }
1353
1354 if (avctx->debug & FF_DEBUG_PICT_INFO)
1355 av_log(h->avctx, AV_LOG_DEBUG,
1356 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1357 av_get_picture_type_char(h->pict_type),
1358 s->halfpel_flag, s->thirdpel_flag,
1359 s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
1360
1361 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1362 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1363 avctx->skip_frame >= AVDISCARD_ALL)
1364 return 0;
1365
1366 if (s->next_p_frame_damaged) {
1367 if (h->pict_type == AV_PICTURE_TYPE_B)
1368 return 0;
1369 else
1370 s->next_p_frame_damaged = 0;
1371 }
1372
1373 if (h->pict_type == AV_PICTURE_TYPE_B) {
1374 h->frame_num_offset = sl->slice_num - h->prev_frame_num;
1375
1376 if (h->frame_num_offset < 0)
1377 h->frame_num_offset += 256;
1378 if (h->frame_num_offset == 0 ||
1379 h->frame_num_offset >= h->prev_frame_num_offset) {
1380 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1381 return -1;
1382 }
1383 } else {
1384 h->prev_frame_num = h->frame_num;
1385 h->frame_num = sl->slice_num;
1386 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1387
1388 if (h->prev_frame_num_offset < 0)
1389 h->prev_frame_num_offset += 256;
1390 }
1391
1392 for (m = 0; m < 2; m++) {
1393 int i;
1394 for (i = 0; i < 4; i++) {
1395 int j;
1396 for (j = -1; j < 4; j++)
1397 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1398 if (i < 3)
1399 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1400 }
1401 }
1402
1403 for (s->mb_y = 0; s->mb_y < h->mb_height; s->mb_y++) {
1404 for (s->mb_x = 0; s->mb_x < h->mb_width; s->mb_x++) {
1405 unsigned mb_type;
1406 s->mb_xy = s->mb_x + s->mb_y * h->mb_stride;
1407
1408 if ((get_bits_left(&h->gb)) <= 7) {
1409 if (((get_bits_count(&h->gb) & 7) == 0 ||
1410 show_bits(&h->gb, get_bits_left(&h->gb) & 7) == 0)) {
1411
1412 if (svq3_decode_slice_header(avctx))
1413 return -1;
1414 }
1415 /* TODO: support s->mb_skip_run */
1416 }
1417
1418 mb_type = svq3_get_ue_golomb(&h->gb);
1419
1420 if (h->pict_type == AV_PICTURE_TYPE_I)
1421 mb_type += 8;
1422 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1423 mb_type += 4;
1424 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1425 av_log(h->avctx, AV_LOG_ERROR,
1426 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1427 return -1;
1428 }
1429
1430 if (mb_type != 0)
1431 hl_decode_mb(s, h, &h->slice_ctx[0]);
1432
1433 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1434 h->cur_pic.mb_type[s->mb_x + s->mb_y * h->mb_stride] =
1435 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1436 }
1437
1438 ff_draw_horiz_band(avctx, s->cur_pic->f,
1439 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1440 16 * s->mb_y, 16, h->picture_structure, 0,
1441 h->low_delay);
1442 }
1443
1444 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1445 ret = av_frame_ref(data, s->cur_pic->f);
1446 else if (s->last_pic->f->data[0])
1447 ret = av_frame_ref(data, s->last_pic->f);
1448 if (ret < 0)
1449 return ret;
1450
1451 /* Do not output the last pic after seeking. */
1452 if (s->last_pic->f->data[0] || h->low_delay)
1453 *got_frame = 1;
1454
1455 if (h->pict_type != AV_PICTURE_TYPE_B) {
1456 FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1457 } else {
1458 av_frame_unref(s->cur_pic->f);
1459 }
1460
1461 return buf_size;
1462 }
1463
1464 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1465 {
1466 SVQ3Context *s = avctx->priv_data;
1467 H264Context *h = &s->h;
1468
1469 free_picture(avctx, s->cur_pic);
1470 free_picture(avctx, s->next_pic);
1471 free_picture(avctx, s->last_pic);
1472 av_frame_free(&s->cur_pic->f);
1473 av_frame_free(&s->next_pic->f);
1474 av_frame_free(&s->last_pic->f);
1475 av_freep(&s->cur_pic);
1476 av_freep(&s->next_pic);
1477 av_freep(&s->last_pic);
1478 av_freep(&s->slice_buf);
1479
1480 memset(&h->cur_pic, 0, sizeof(h->cur_pic));
1481
1482 ff_h264_free_context(h);
1483
1484 return 0;
1485 }
1486
1487 AVCodec ff_svq3_decoder = {
1488 .name = "svq3",
1489 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1490 .type = AVMEDIA_TYPE_VIDEO,
1491 .id = AV_CODEC_ID_SVQ3,
1492 .priv_data_size = sizeof(SVQ3Context),
1493 .init = svq3_decode_init,
1494 .close = svq3_decode_end,
1495 .decode = svq3_decode_frame,
1496 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1497 AV_CODEC_CAP_DR1 |
1498 AV_CODEC_CAP_DELAY,
1499 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1500 AV_PIX_FMT_NONE},
1501 };