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