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