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