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