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