h264: embed the DPB in the context
[libav.git] / libavcodec / svq3.c
CommitLineData
8b82a956 1/*
2912e87a 2 * Copyright (c) 2003 The Libav Project
8b82a956 3 *
2912e87a 4 * This file is part of Libav.
b78e7197 5 *
2912e87a 6 * Libav is free software; you can redistribute it and/or
8b82a956
MN
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
b78e7197 9 * version 2.1 of the License, or (at your option) any later version.
8b82a956 10 *
2912e87a 11 * Libav is distributed in the hope that it will be useful,
8b82a956
MN
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
2912e87a 17 * License along with Libav; if not, write to the Free Software
5509bffa 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
e5a389a1
DB
19 */
20
21/*
8b82a956
MN
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
89a79364
MM
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
8b82a956
MN
30 * via the AVCodecContext's extradata[_size] field:
31 *
115329f1 32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
89a79364 33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
115329f1
DB
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
89a79364
MM
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:
f0a41afd 40 * http://samples.libav.org/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
8b82a956 41 */
bd8ac882 42
cc8163e1
DB
43#include <inttypes.h>
44
bd8ac882 45#include "libavutil/attributes.h"
903d58f6 46#include "internal.h"
903d58f6 47#include "avcodec.h"
e0c16e4e 48#include "mpegutils.h"
903d58f6
MN
49#include "h264.h"
50
a7d2861d 51#include "h264data.h" // FIXME FIXME FIXME
903d58f6 52
188d3c51 53#include "h264_mvpred.h"
903d58f6 54#include "golomb.h"
2f6bc5f7 55#include "hpeldsp.h"
903d58f6 56#include "rectangle.h"
57f09608 57#include "tpeldsp.h"
903d58f6 58
b250f9c6 59#if CONFIG_ZLIB
c4864924
BC
60#include <zlib.h>
61#endif
62
2be3fe39 63#include "svq1.h"
75d5156a 64#include "svq3.h"
2be3fe39 65
8b82a956 66/**
ba87f080 67 * @file
8b82a956
MN
68 * svq3 decoder.
69 */
70
7f9f771e 71typedef struct SVQ3Context {
8dfc6d1f 72 H264Context h;
2f6bc5f7 73 HpelDSPContext hdsp;
57f09608 74 TpelDSPContext tdsp;
9b749c82
VG
75 H264Picture *cur_pic;
76 H264Picture *next_pic;
77 H264Picture *last_pic;
8dfc6d1f
BC
78 int halfpel_flag;
79 int thirdpel_flag;
80 int unknown_flag;
81 int next_slice_index;
82 uint32_t watermark_key;
2c541554
AK
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;
8dfc6d1f
BC
88} SVQ3Context;
89
115329f1
DB
90#define FULLPEL_MODE 1
91#define HALFPEL_MODE 2
94d44f45 92#define THIRDPEL_MODE 3
2e26c8d2 93#define PREDICT_MODE 4
115329f1 94
f7a8c179 95/* dual scan (from some older h264 draft)
a7d2861d
DB
96 * o-->o-->o o
97 * | /|
98 * o o o / o
99 * | / | |/ |
100 * o o o o
101 * /
102 * o-->o-->o-->o
103 */
76de302d 104static const uint8_t svq3_scan[16] = {
a7d2861d
DB
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,
8b82a956
MN
109};
110
c4e43560
DB
111static 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
8b82a956 118static const uint8_t svq3_pred_0[25][2] = {
76de302d
DB
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 }
8b82a956
MN
128};
129
130static const int8_t svq3_pred_1[6][6][5] = {
a7d2861d
DB
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 } },
8b82a956
MN
143};
144
a7d2861d
DB
145static const struct {
146 uint8_t run;
147 uint8_t level;
148} svq3_dct_tables[2][16] = {
76de302d
DB
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 } }
8b82a956
MN
153};
154
155static const uint32_t svq3_dequant_coeff[32] = {
a7d2861d
DB
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
8b82a956
MN
160};
161
88bd7fdc 162void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
a7d2861d 163{
76de302d 164 const int qmul = svq3_dequant_coeff[qp];
8b82a956
MN
165#define stride 16
166 int i;
167 int temp[16];
a7d2861d
DB
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;
8b82a956
MN
180 }
181
a7d2861d
DB
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
af1ede06
DB
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;
8b82a956
MN
193 }
194}
195#undef stride
196
88bd7fdc 197void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
a7d2861d 198 int stride, int qp, int dc)
7f8205da 199{
76de302d 200 const int qmul = svq3_dequant_coeff[qp];
8b82a956 201 int i;
8b82a956
MN
202
203 if (dc) {
af1ede06
DB
204 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
205 : qmul * (block[0] >> 3) / 2);
8b82a956
MN
206 block[0] = 0;
207 }
208
76de302d 209 for (i = 0; i < 4; i++) {
a7d2861d
DB
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;
8b82a956
MN
219 }
220
76de302d 221 for (i = 0; i < 4; i++) {
a7d2861d
DB
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];
76de302d
DB
226 const int rr = (dc + 0x80000);
227
af1ede06
DB
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));
8b82a956 232 }
62844c3f
RB
233
234 memset(block, 0, 16 * sizeof(int16_t));
8b82a956
MN
235}
236
88bd7fdc 237static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
7f8205da
DB
238 int index, const int type)
239{
76de302d
DB
240 static const uint8_t *const scan_patterns[4] =
241 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
8b82a956 242
9a2e7911
JG
243 int run, level, limit;
244 unsigned vlc;
af1ede06 245 const int intra = 3 * type >> 2;
76de302d 246 const uint8_t *const scan = scan_patterns[type];
8b82a956 247
76de302d
DB
248 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
249 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
9a2e7911
JG
250 int sign = (vlc & 1) ? 0 : -1;
251 vlc = vlc + 1 >> 1;
a7d2861d
DB
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 {
af1ede06
DB
261 run = vlc & 0x3;
262 level = (vlc + 9 >> 2) - run;
a7d2861d
DB
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) {
af1ede06 269 run = vlc & 0x7;
a7d2861d
DB
270 level = (vlc >> 3) +
271 ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
272 } else {
af1ede06 273 run = vlc & 0xF;
a7d2861d
DB
274 level = (vlc >> 4) +
275 ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
276 }
277 }
8b82a956 278
a7d2861d
DB
279 if ((index += run) >= limit)
280 return -1;
281
282 block[scan[index]] = (level ^ sign) - sign;
76de302d 283 }
8b82a956 284
76de302d
DB
285 if (type != 2) {
286 break;
287 }
8b82a956 288 }
8b82a956 289
76de302d 290 return 0;
8b82a956
MN
291}
292
2c541554 293static inline void svq3_mc_dir_part(SVQ3Context *s,
7f8205da
DB
294 int x, int y, int width, int height,
295 int mx, int my, int dxy,
296 int thirdpel, int dir, int avg)
297{
9b749c82 298 H264Context *h = &s->h;
36d04801 299 H264SliceContext *sl = &h->slice_ctx[0];
9b749c82 300 const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
76de302d
DB
301 uint8_t *src, *dest;
302 int i, emu = 0;
a7d2861d 303 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
76de302d
DB
304
305 mx += x;
306 my += y;
8b82a956 307
af1ede06
DB
308 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
309 my < 0 || my >= s->v_edge_pos - height - 1) {
fae6fd5b 310 emu = 1;
af1ede06
DB
311 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
312 my = av_clip(my, -16, s->v_edge_pos - height + 15);
8b82a956
MN
313 }
314
76de302d 315 /* form component predictions */
c28ed1d7
AK
316 dest = h->cur_pic.f.data[0] + x + y * sl->linesize;
317 src = pic->f.data[0] + mx + my * sl->linesize;
76de302d
DB
318
319 if (emu) {
36d04801 320 h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
c28ed1d7 321 sl->linesize, sl->linesize,
8c53d39e
RB
322 width + 1, height + 1,
323 mx, my, s->h_edge_pos, s->v_edge_pos);
36d04801 324 src = sl->edge_emu_buffer;
8b82a956 325 }
76de302d 326 if (thirdpel)
57f09608 327 (avg ? s->tdsp.avg_tpel_pixels_tab
c28ed1d7 328 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, sl->linesize,
57f09608 329 width, height);
76de302d 330 else
2f6bc5f7 331 (avg ? s->hdsp.avg_pixels_tab
c28ed1d7 332 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, sl->linesize,
2f6bc5f7 333 height);
76de302d 334
2c541554 335 if (!(h->flags & CODEC_FLAG_GRAY)) {
af1ede06
DB
336 mx = mx + (mx < (int) x) >> 1;
337 my = my + (my < (int) y) >> 1;
338 width = width >> 1;
339 height = height >> 1;
76de302d
DB
340 blocksize++;
341
342 for (i = 1; i < 3; i++) {
c28ed1d7
AK
343 dest = h->cur_pic.f.data[i] + (x >> 1) + (y >> 1) * sl->uvlinesize;
344 src = pic->f.data[i] + mx + my * sl->uvlinesize;
76de302d
DB
345
346 if (emu) {
36d04801 347 h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
c28ed1d7 348 sl->uvlinesize, sl->uvlinesize,
8c53d39e
RB
349 width + 1, height + 1,
350 mx, my, (s->h_edge_pos >> 1),
351 s->v_edge_pos >> 1);
36d04801 352 src = sl->edge_emu_buffer;
76de302d
DB
353 }
354 if (thirdpel)
57f09608
DB
355 (avg ? s->tdsp.avg_tpel_pixels_tab
356 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
c28ed1d7 357 sl->uvlinesize,
57f09608 358 width, height);
76de302d 359 else
2f6bc5f7
RB
360 (avg ? s->hdsp.avg_pixels_tab
361 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
c28ed1d7 362 sl->uvlinesize,
2f6bc5f7 363 height);
76de302d
DB
364 }
365 }
8b82a956
MN
366}
367
2c541554 368static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
a7d2861d 369 int dir, int avg)
7f8205da 370{
76de302d 371 int i, j, k, mx, my, dx, dy, x, y;
2c541554 372 H264Context *h = &s->h;
8b00f4df 373 H264SliceContext *sl = &h->slice_ctx[0];
a7d2861d
DB
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)
76de302d 381 for (j = 0; j < 16; j += part_width) {
d4d9068c
AK
382 const int b_xy = (4 * sl->mb_x + (j >> 2)) +
383 (4 * sl->mb_y + (i >> 2)) * h->b_stride;
76de302d 384 int dxy;
d4d9068c
AK
385 x = 16 * sl->mb_x + j;
386 y = 16 * sl->mb_y + i;
af1ede06
DB
387 k = (j >> 2 & 1) + (i >> 1 & 2) +
388 (j >> 1 & 4) + (i & 8);
76de302d
DB
389
390 if (mode != PREDICT_MODE) {
8b00f4df 391 pred_motion(h, sl, k, part_width >> 2, dir, 1, &mx, &my);
76de302d 392 } else {
759001c5
AK
393 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
394 my = s->next_pic->motion_val[0][b_xy][1] << 1;
76de302d
DB
395
396 if (dir == 0) {
af1ede06
DB
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;
76de302d 401 } else {
af1ede06
DB
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;
76de302d
DB
406 }
407 }
408
409 /* clip motion vector prediction to frame border */
a7d2861d
DB
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);
76de302d
DB
412
413 /* get (optional) motion vector differential */
414 if (mode == PREDICT_MODE) {
415 dx = dy = 0;
416 } else {
2c541554
AK
417 dy = svq3_get_se_golomb(&h->gb);
418 dx = svq3_get_se_golomb(&h->gb);
76de302d
DB
419
420 if (dx == INVALID_VLC || dy == INVALID_VLC) {
2c541554 421 av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
76de302d
DB
422 return -1;
423 }
424 }
425
426 /* compute motion vector */
427 if (mode == THIRDPEL_MODE) {
428 int fx, fy;
af1ede06
DB
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;
a7d2861d
DB
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);
76de302d
DB
437 mx += mx;
438 my += my;
439 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
af1ede06
DB
440 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
441 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
a7d2861d 442 dxy = (mx & 1) + 2 * (my & 1);
76de302d 443
a7d2861d
DB
444 svq3_mc_dir_part(s, x, y, part_width, part_height,
445 mx >> 1, my >> 1, dxy, 0, dir, avg);
76de302d
DB
446 mx *= 3;
447 my *= 3;
448 } else {
af1ede06
DB
449 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
450 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
76de302d 451
a7d2861d
DB
452 svq3_mc_dir_part(s, x, y, part_width, part_height,
453 mx, my, 0, 0, dir, avg);
76de302d
DB
454 mx *= 6;
455 my *= 6;
456 }
457
458 /* update mv_cache */
459 if (mode != PREDICT_MODE) {
a7d2861d 460 int32_t mv = pack16to32(mx, my);
76de302d
DB
461
462 if (part_height == 8 && i < 8) {
e6287f07 463 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 * 8], mv);
76de302d 464
a7d2861d 465 if (part_width == 8 && j < 8)
e6287f07 466 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
76de302d 467 }
a7d2861d 468 if (part_width == 8 && j < 8)
e6287f07 469 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1], mv);
a7d2861d 470 if (part_width == 4 || part_height == 4)
e6287f07 471 AV_WN32A(sl->mv_cache[dir][scan8[k]], mv);
76de302d
DB
472 }
473
474 /* write back motion vectors */
759001c5 475 fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
657ccb5a
DB
476 part_width >> 2, part_height >> 2, h->b_stride,
477 pack16to32(mx, my), 4);
bb270c08 478 }
2e26c8d2 479
76de302d 480 return 0;
2e26c8d2
MM
481}
482
2c541554 483static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
7f8205da 484{
2c541554 485 H264Context *h = &s->h;
d231e84b 486 H264SliceContext *sl = &h->slice_ctx[0];
76de302d
DB
487 int i, j, k, m, dir, mode;
488 int cbp = 0;
489 uint32_t vlc;
490 int8_t *top, *left;
0edbe6fa 491 const int mb_xy = sl->mb_xy;
d4d9068c 492 const int b_xy = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride;
76de302d 493
d4d9068c
AK
494 sl->top_samples_available = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
495 sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
64c81b2c 496 sl->topright_samples_available = 0xFFFF;
76de302d
DB
497
498 if (mb_type == 0) { /* SKIP */
2c541554 499 if (h->pict_type == AV_PICTURE_TYPE_P ||
759001c5 500 s->next_pic->mb_type[mb_xy] == -1) {
d4d9068c 501 svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
a7d2861d 502 0, 0, 0, 0, 0, 0);
76de302d 503
2c541554 504 if (h->pict_type == AV_PICTURE_TYPE_B)
d4d9068c 505 svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
a7d2861d 506 0, 0, 0, 0, 1, 1);
76de302d
DB
507
508 mb_type = MB_TYPE_SKIP;
509 } else {
759001c5 510 mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
2c541554 511 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
76de302d 512 return -1;
2c541554 513 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
76de302d 514 return -1;
8b82a956 515
76de302d 516 mb_type = MB_TYPE_16x16;
bb270c08 517 }
76de302d 518 } else if (mb_type < 8) { /* INTER */
2c541554 519 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
76de302d 520 mode = THIRDPEL_MODE;
2c541554
AK
521 else if (s->halfpel_flag &&
522 s->thirdpel_flag == !get_bits1(&h->gb))
76de302d 523 mode = HALFPEL_MODE;
a7d2861d 524 else
76de302d 525 mode = FULLPEL_MODE;
8b82a956 526
76de302d
DB
527 /* fill caches */
528 /* note ref_cache should contain here:
a7d2861d
DB
529 * ????????
530 * ???11111
531 * N??11111
532 * N??11111
533 * N??11111
534 */
76de302d
DB
535
536 for (m = 0; m < 2; m++) {
d4d9068c 537 if (sl->mb_x > 0 && sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
a7d2861d 538 for (i = 0; i < 4; i++)
e6287f07 539 AV_COPY32(sl->mv_cache[m][scan8[0] - 1 + i * 8],
759001c5 540 h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
76de302d 541 } else {
a7d2861d 542 for (i = 0; i < 4; i++)
e6287f07 543 AV_ZERO32(sl->mv_cache[m][scan8[0] - 1 + i * 8]);
76de302d 544 }
d4d9068c 545 if (sl->mb_y > 0) {
e6287f07 546 memcpy(sl->mv_cache[m][scan8[0] - 1 * 8],
759001c5 547 h->cur_pic.motion_val[m][b_xy - h->b_stride],
a7d2861d 548 4 * 2 * sizeof(int16_t));
e6287f07 549 memset(&sl->ref_cache[m][scan8[0] - 1 * 8],
7d8154ed 550 (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
76de302d 551
d4d9068c 552 if (sl->mb_x < h->mb_width - 1) {
e6287f07 553 AV_COPY32(sl->mv_cache[m][scan8[0] + 4 - 1 * 8],
759001c5 554 h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
e6287f07 555 sl->ref_cache[m][scan8[0] + 4 - 1 * 8] =
7d8154ed
AK
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;
a7d2861d 558 } else
e6287f07 559 sl->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
d4d9068c 560 if (sl->mb_x > 0) {
e6287f07 561 AV_COPY32(sl->mv_cache[m][scan8[0] - 1 - 1 * 8],
759001c5 562 h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
e6287f07 563 sl->ref_cache[m][scan8[0] - 1 - 1 * 8] =
7d8154ed 564 (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
a7d2861d 565 } else
e6287f07 566 sl->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
a7d2861d 567 } else
e6287f07 568 memset(&sl->ref_cache[m][scan8[0] - 1 * 8 - 1],
a7d2861d 569 PART_NOT_AVAILABLE, 8);
76de302d 570
2c541554 571 if (h->pict_type != AV_PICTURE_TYPE_B)
76de302d 572 break;
bb270c08 573 }
8b82a956 574
76de302d 575 /* decode motion vector(s) and form prediction(s) */
2c541554
AK
576 if (h->pict_type == AV_PICTURE_TYPE_P) {
577 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
76de302d 578 return -1;
975a1447 579 } else { /* AV_PICTURE_TYPE_B */
7f3624dc 580 if (mb_type != 2) {
2c541554 581 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
76de302d 582 return -1;
7f3624dc 583 } else {
a7d2861d 584 for (i = 0; i < 4; i++)
759001c5 585 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
a7d2861d 586 0, 4 * 2 * sizeof(int16_t));
7f3624dc
MH
587 }
588 if (mb_type != 1) {
2c541554 589 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
76de302d 590 return -1;
7f3624dc 591 } else {
a7d2861d 592 for (i = 0; i < 4; i++)
759001c5 593 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
a7d2861d 594 0, 4 * 2 * sizeof(int16_t));
7f3624dc 595 }
bb270c08 596 }
8b82a956 597
76de302d
DB
598 mb_type = MB_TYPE_16x16;
599 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
7d8154ed 600 memset(sl->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
76de302d
DB
601
602 if (mb_type == 8) {
d4d9068c 603 if (sl->mb_x > 0) {
a7d2861d 604 for (i = 0; i < 4; i++)
7d8154ed
AK
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)
64c81b2c 607 sl->left_samples_available = 0x5F5F;
76de302d 608 }
d4d9068c 609 if (sl->mb_y > 0) {
7d8154ed
AK
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];
76de302d 614
7d8154ed 615 if (sl->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
64c81b2c 616 sl->top_samples_available = 0x33FF;
76de302d
DB
617 }
618
619 /* decode prediction codes for luma blocks */
a7d2861d 620 for (i = 0; i < 16; i += 2) {
2c541554 621 vlc = svq3_get_ue_golomb(&h->gb);
76de302d 622
a7d2861d 623 if (vlc >= 25) {
cc8163e1
DB
624 av_log(h->avctx, AV_LOG_ERROR,
625 "luma prediction:%"PRIu32"\n", vlc);
76de302d
DB
626 return -1;
627 }
628
7d8154ed
AK
629 left = &sl->intra4x4_pred_mode_cache[scan8[i] - 1];
630 top = &sl->intra4x4_pred_mode_cache[scan8[i] - 8];
76de302d
DB
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
a7d2861d 635 if (left[1] == -1 || left[2] == -1) {
2c541554 636 av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
76de302d
DB
637 return -1;
638 }
639 }
640 } else { /* mb_type == 33, DC_128_PRED block type */
a7d2861d 641 for (i = 0; i < 4; i++)
7d8154ed 642 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
884182b3 643 }
8b82a956 644
7d8154ed 645 write_back_intra_pred_mode(h, sl);
8b82a956 646
76de302d 647 if (mb_type == 8) {
7d8154ed 648 ff_h264_check_intra4x4_pred_mode(h, sl);
da3b9756 649
d4d9068c
AK
650 sl->top_samples_available = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
651 sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
76de302d 652 } else {
a7d2861d 653 for (i = 0; i < 4; i++)
7d8154ed 654 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
da3b9756 655
64c81b2c
AK
656 sl->top_samples_available = 0x33FF;
657 sl->left_samples_available = 0x5F5F;
76de302d 658 }
da3b9756 659
76de302d
DB
660 mb_type = MB_TYPE_INTRA4x4;
661 } else { /* INTRA16x16 */
662 dir = i_mb_type_info[mb_type - 8].pred_mode;
a7d2861d 663 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
8b82a956 664
64c81b2c 665 if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
1115689d 666 av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
4bd5ac20 667 return sl->intra16x16_pred_mode;
76de302d 668 }
8b82a956 669
a7d2861d 670 cbp = i_mb_type_info[mb_type - 8].cbp;
76de302d 671 mb_type = MB_TYPE_INTRA16x16;
884182b3 672 }
8b82a956 673
2c541554 674 if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
a7d2861d 675 for (i = 0; i < 4; i++)
759001c5 676 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
a7d2861d 677 0, 4 * 2 * sizeof(int16_t));
2c541554 678 if (h->pict_type == AV_PICTURE_TYPE_B) {
a7d2861d 679 for (i = 0; i < 4; i++)
759001c5 680 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
a7d2861d 681 0, 4 * 2 * sizeof(int16_t));
76de302d 682 }
8b82a956 683 }
76de302d 684 if (!IS_INTRA4x4(mb_type)) {
7d8154ed 685 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
da3b9756 686 }
2c541554 687 if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
f69574cf 688 memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
884182b3 689 }
2e26c8d2 690
a7d2861d 691 if (!IS_INTRA16x16(mb_type) &&
2c541554
AK
692 (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
693 if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48) {
cc8163e1 694 av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
76de302d
DB
695 return -1;
696 }
8b82a956 697
a7d2861d
DB
698 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
699 : golomb_to_inter_cbp[vlc];
884182b3 700 }
a7d2861d 701 if (IS_INTRA16x16(mb_type) ||
2c541554 702 (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
d231e84b 703 sl->qscale += svq3_get_se_golomb(&h->gb);
8b82a956 704
d231e84b
AK
705 if (sl->qscale > 31u) {
706 av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
bb270c08 707 return -1;
bb270c08 708 }
8b82a956 709 }
76de302d 710 if (IS_INTRA16x16(mb_type)) {
bf03a878
AK
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)) {
2c541554 714 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 715 "error while decoding intra luma dc\n");
76de302d 716 return -1;
884182b3 717 }
76de302d 718 }
8b82a956 719
76de302d
DB
720 if (cbp) {
721 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
d231e84b 722 const int type = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
76de302d 723
a7d2861d 724 for (i = 0; i < 4; i++)
76de302d
DB
725 if ((cbp & (1 << i))) {
726 for (j = 0; j < 4; j++) {
a7d2861d
DB
727 k = index ? (1 * (j & 1) + 2 * (i & 1) +
728 2 * (j & 2) + 4 * (i & 2))
729 : (4 * i + j);
f69574cf 730 sl->non_zero_count_cache[scan8[k]] = 1;
a7d2861d 731
bf03a878 732 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
2c541554 733 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 734 "error while decoding block\n");
76de302d
DB
735 return -1;
736 }
737 }
738 }
8b82a956 739
76de302d 740 if ((cbp & 0x30)) {
a7d2861d 741 for (i = 1; i < 3; ++i)
bf03a878 742 if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
2c541554 743 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d
DB
744 "error while decoding chroma dc block\n");
745 return -1;
746 }
76de302d
DB
747
748 if ((cbp & 0x20)) {
11177a4d
JGG
749 for (i = 1; i < 3; i++) {
750 for (j = 0; j < 4; j++) {
a7d2861d 751 k = 16 * i + j;
f69574cf 752 sl->non_zero_count_cache[scan8[k]] = 1;
11177a4d 753
bf03a878 754 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
2c541554 755 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 756 "error while decoding chroma ac block\n");
11177a4d
JGG
757 return -1;
758 }
76de302d
DB
759 }
760 }
761 }
bb270c08 762 }
8b82a956 763 }
8b82a956 764
e7226984 765 sl->cbp = cbp;
759001c5 766 h->cur_pic.mb_type[mb_xy] = mb_type;
8b82a956 767
a7d2861d 768 if (IS_INTRA(mb_type))
64c81b2c 769 sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, sl, DC_PRED8x8, 1);
8b82a956 770
76de302d 771 return 0;
8b82a956
MN
772}
773
8dfc6d1f 774static int svq3_decode_slice_header(AVCodecContext *avctx)
7f8205da 775{
2c541554
AK
776 SVQ3Context *s = avctx->priv_data;
777 H264Context *h = &s->h;
d231e84b 778 H264SliceContext *sl = &h->slice_ctx[0];
0edbe6fa 779 const int mb_xy = sl->mb_xy;
76de302d 780 int i, header;
288bb3da 781 unsigned slice_id;
da3b9756 782
2c541554 783 header = get_bits(&h->gb, 8);
da3b9756 784
76de302d
DB
785 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
786 /* TODO: what? */
8dfc6d1f 787 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
76de302d
DB
788 return -1;
789 } else {
af1ede06 790 int length = header >> 5 & 3;
da3b9756 791
2c541554
AK
792 s->next_slice_index = get_bits_count(&h->gb) +
793 8 * show_bits(&h->gb, 8 * length) +
794 8 * length;
da3b9756 795
2c541554 796 if (s->next_slice_index > h->gb.size_in_bits) {
8dfc6d1f 797 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
76de302d 798 return -1;
a7d2861d 799 }
da3b9756 800
2c541554
AK
801 h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
802 skip_bits(&h->gb, 8);
da3b9756 803
2c541554
AK
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);
76de302d
DB
808 }
809 if (length > 0) {
2c541554
AK
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);
76de302d 812 }
2c541554 813 skip_bits_long(&h->gb, 0);
da3b9756 814 }
da3b9756 815
2c541554 816 if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
cc8163e1 817 av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
76de302d
DB
818 return -1;
819 }
da3b9756 820
56febc99 821 sl->slice_type = golomb_to_pict_type[slice_id];
da3b9756 822
76de302d 823 if ((header & 0x9F) == 2) {
2c541554 824 i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
47a0d393 825 sl->mb_skip_run = get_bits(&h->gb, i) -
d4d9068c 826 (sl->mb_y * h->mb_width + sl->mb_x);
76de302d 827 } else {
2c541554 828 skip_bits1(&h->gb);
47a0d393 829 sl->mb_skip_run = 0;
76de302d 830 }
da3b9756 831
56febc99
AK
832 sl->slice_num = get_bits(&h->gb, 8);
833 sl->qscale = get_bits(&h->gb, 5);
2c541554 834 s->adaptive_quant = get_bits1(&h->gb);
da3b9756 835
76de302d 836 /* unknown fields */
2c541554 837 skip_bits1(&h->gb);
da3b9756 838
2c541554
AK
839 if (s->unknown_flag)
840 skip_bits1(&h->gb);
da3b9756 841
2c541554
AK
842 skip_bits1(&h->gb);
843 skip_bits(&h->gb, 2);
da3b9756 844
2c541554
AK
845 while (get_bits1(&h->gb))
846 skip_bits(&h->gb, 8);
da3b9756 847
76de302d 848 /* reset intra predictors and invalidate motion vector references */
d4d9068c 849 if (sl->mb_x > 0) {
7d8154ed 850 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
a7d2861d 851 -1, 4 * sizeof(int8_t));
d4d9068c
AK
852 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - sl->mb_x],
853 -1, 8 * sizeof(int8_t) * sl->mb_x);
76de302d 854 }
d4d9068c 855 if (sl->mb_y > 0) {
7d8154ed 856 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
d4d9068c 857 -1, 8 * sizeof(int8_t) * (h->mb_width - sl->mb_x));
76de302d 858
d4d9068c 859 if (sl->mb_x > 0)
7d8154ed 860 sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
da3b9756 861 }
da3b9756 862
76de302d 863 return 0;
da3b9756
MM
864}
865
5ef251e5 866static av_cold int svq3_decode_init(AVCodecContext *avctx)
7f8205da 867{
2c541554
AK
868 SVQ3Context *s = avctx->priv_data;
869 H264Context *h = &s->h;
07c5ca55 870 H264SliceContext *sl;
f4cca718 871 int m;
76de302d 872 unsigned char *extradata;
9e1db721 873 unsigned char *extradata_end;
76de302d 874 unsigned int size;
9e1db721 875 int marker_found = 0;
76de302d 876
2c541554
AK
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
903d58f6 887 if (ff_h264_decode_init(avctx) < 0)
f4cca718
BC
888 return -1;
889
249796e2
AK
890 ff_h264dsp_init(&h->h264dsp, 8, 1);
891 ff_h264chroma_init(&h->h264chroma, 8);
892 ff_h264qpel_init(&h->h264qpel, 8);
893 ff_h264_pred_init(&h->hpc, AV_CODEC_ID_SVQ3, 8, 1);
894 ff_videodsp_init(&h->vdsp, 8);
895
896 memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
897 memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
898
899 h->sps.bit_depth_luma = 8;
900 h->chroma_format_idc = 1;
901
2f6bc5f7 902 ff_hpeldsp_init(&s->hdsp, avctx->flags);
57f09608
DB
903 ff_tpeldsp_init(&s->tdsp);
904
07c5ca55
AK
905 sl = h->slice_ctx;
906
2c541554 907 h->flags = avctx->flags;
07c5ca55 908 sl->is_complex = 1;
2c541554 909 h->picture_structure = PICT_FRAME;
3795ec68
VG
910 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
911 avctx->color_range = AVCOL_RANGE_JPEG;
76de302d 912
d231e84b 913 h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
2c541554 914 h->chroma_x_shift = h->chroma_y_shift = 1;
d9ebb00d 915
2c541554
AK
916 s->halfpel_flag = 1;
917 s->thirdpel_flag = 1;
918 s->unknown_flag = 0;
d9ebb00d
AK
919
920 /* prowl for the "SEQH" marker in the extradata */
921 extradata = (unsigned char *)avctx->extradata;
922 extradata_end = avctx->extradata + avctx->extradata_size;
923 if (extradata) {
924 for (m = 0; m + 8 < avctx->extradata_size; m++) {
925 if (!memcmp(extradata, "SEQH", 4)) {
926 marker_found = 1;
927 break;
9e1db721 928 }
d9ebb00d 929 extradata++;
76de302d 930 }
d9ebb00d 931 }
8b82a956 932
d9ebb00d
AK
933 /* if a match was found, parse the extra data */
934 if (marker_found) {
935 GetBitContext gb;
936 int frame_size_code;
937
938 size = AV_RB32(&extradata[4]);
939 if (size > extradata_end - extradata - 8)
940 return AVERROR_INVALIDDATA;
941 init_get_bits(&gb, extradata + 8, size * 8);
942
943 /* 'frame size code' and optional 'width, height' */
944 frame_size_code = get_bits(&gb, 3);
945 switch (frame_size_code) {
946 case 0:
947 avctx->width = 160;
948 avctx->height = 120;
949 break;
950 case 1:
951 avctx->width = 128;
952 avctx->height = 96;
953 break;
954 case 2:
955 avctx->width = 176;
956 avctx->height = 144;
957 break;
958 case 3:
959 avctx->width = 352;
960 avctx->height = 288;
961 break;
962 case 4:
963 avctx->width = 704;
964 avctx->height = 576;
965 break;
966 case 5:
967 avctx->width = 240;
968 avctx->height = 180;
969 break;
970 case 6:
971 avctx->width = 320;
972 avctx->height = 240;
973 break;
974 case 7:
975 avctx->width = get_bits(&gb, 12);
976 avctx->height = get_bits(&gb, 12);
977 break;
978 }
8b82a956 979
2c541554
AK
980 s->halfpel_flag = get_bits1(&gb);
981 s->thirdpel_flag = get_bits1(&gb);
8b82a956 982
d9ebb00d
AK
983 /* unknown fields */
984 skip_bits1(&gb);
985 skip_bits1(&gb);
986 skip_bits1(&gb);
987 skip_bits1(&gb);
8b82a956 988
2c541554 989 h->low_delay = get_bits1(&gb);
1e002b60 990
d9ebb00d
AK
991 /* unknown field */
992 skip_bits1(&gb);
76de302d 993
d9ebb00d
AK
994 while (get_bits1(&gb))
995 skip_bits(&gb, 8);
76de302d 996
2c541554
AK
997 s->unknown_flag = get_bits1(&gb);
998 avctx->has_b_frames = !h->low_delay;
999 if (s->unknown_flag) {
b250f9c6 1000#if CONFIG_ZLIB
d9ebb00d
AK
1001 unsigned watermark_width = svq3_get_ue_golomb(&gb);
1002 unsigned watermark_height = svq3_get_ue_golomb(&gb);
1003 int u1 = svq3_get_ue_golomb(&gb);
1004 int u2 = get_bits(&gb, 8);
1005 int u3 = get_bits(&gb, 2);
1006 int u4 = svq3_get_ue_golomb(&gb);
1007 unsigned long buf_len = watermark_width *
1008 watermark_height * 4;
1009 int offset = get_bits_count(&gb) + 7 >> 3;
1010 uint8_t *buf;
1011
601c2015
MS
1012 if (watermark_height > 0 &&
1013 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
d9ebb00d 1014 return -1;
76de302d 1015
d9ebb00d 1016 buf = av_malloc(buf_len);
cc8163e1 1017 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
d9ebb00d
AK
1018 watermark_width, watermark_height);
1019 av_log(avctx, AV_LOG_DEBUG,
1020 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1021 u1, u2, u3, u4, offset);
1022 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1023 size - offset) != Z_OK) {
a7d2861d 1024 av_log(avctx, AV_LOG_ERROR,
d9ebb00d
AK
1025 "could not uncompress watermark logo\n");
1026 av_free(buf);
76de302d 1027 return -1;
76de302d 1028 }
2c541554
AK
1029 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1030 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
d9ebb00d 1031 av_log(avctx, AV_LOG_DEBUG,
cc8163e1 1032 "watermark key %#"PRIx32"\n", s->watermark_key);
d9ebb00d
AK
1033 av_free(buf);
1034#else
1035 av_log(avctx, AV_LOG_ERROR,
1036 "this svq3 file contains watermark which need zlib support compiled in\n");
1037 return -1;
1038#endif
76de302d 1039 }
d9ebb00d 1040 }
cdca7c37 1041
2c541554
AK
1042 h->width = avctx->width;
1043 h->height = avctx->height;
1044 h->mb_width = (h->width + 15) / 16;
1045 h->mb_height = (h->height + 15) / 16;
1046 h->mb_stride = h->mb_width + 1;
1047 h->mb_num = h->mb_width * h->mb_height;
1048 h->b_stride = 4 * h->mb_width;
1049 s->h_edge_pos = h->mb_width * 16;
1050 s->v_edge_pos = h->mb_height * 16;
cdca7c37 1051
d9ebb00d
AK
1052 if (ff_h264_alloc_tables(h) < 0) {
1053 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1054 return AVERROR(ENOMEM);
da3b9756 1055 }
76de302d 1056
f4cca718
BC
1057 return 0;
1058}
1059
9b749c82 1060static void free_picture(AVCodecContext *avctx, H264Picture *pic)
759001c5
AK
1061{
1062 int i;
1063 for (i = 0; i < 2; i++) {
1064 av_buffer_unref(&pic->motion_val_buf[i]);
1065 av_buffer_unref(&pic->ref_index_buf[i]);
1066 }
1067 av_buffer_unref(&pic->mb_type_buf);
1068
1069 av_frame_unref(&pic->f);
1070}
1071
9b749c82 1072static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
2c541554
AK
1073{
1074 SVQ3Context *s = avctx->priv_data;
1075 H264Context *h = &s->h;
36d04801 1076 H264SliceContext *sl = &h->slice_ctx[0];
2c541554
AK
1077 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1078 const int mb_array_size = h->mb_stride * h->mb_height;
1079 const int b4_stride = h->mb_width * 4 + 1;
1080 const int b4_array_size = b4_stride * h->mb_height * 4;
1081 int ret;
1082
759001c5 1083 if (!pic->motion_val_buf[0]) {
2c541554
AK
1084 int i;
1085
759001c5
AK
1086 pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1087 if (!pic->mb_type_buf)
2c541554 1088 return AVERROR(ENOMEM);
759001c5 1089 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
2c541554
AK
1090
1091 for (i = 0; i < 2; i++) {
759001c5
AK
1092 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1093 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1094 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1095 ret = AVERROR(ENOMEM);
1096 goto fail;
1097 }
2c541554 1098
759001c5
AK
1099 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1100 pic->ref_index[i] = pic->ref_index_buf[i]->data;
2c541554
AK
1101 }
1102 }
759001c5
AK
1103 pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1104
1105 ret = ff_get_buffer(avctx, &pic->f,
1106 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1107 if (ret < 0)
1108 goto fail;
2c541554 1109
36d04801
AK
1110 if (!sl->edge_emu_buffer) {
1111 sl->edge_emu_buffer = av_mallocz(pic->f.linesize[0] * 17);
1112 if (!sl->edge_emu_buffer)
fae6fd5b
RB
1113 return AVERROR(ENOMEM);
1114 }
2c541554 1115
c28ed1d7
AK
1116 sl->linesize = pic->f.linesize[0];
1117 sl->uvlinesize = pic->f.linesize[1];
2c541554 1118
759001c5
AK
1119 return 0;
1120fail:
1121 free_picture(avctx, pic);
2c541554
AK
1122 return ret;
1123}
1124
a7d2861d 1125static int svq3_decode_frame(AVCodecContext *avctx, void *data,
df9b9567 1126 int *got_frame, AVPacket *avpkt)
f4cca718 1127{
7a00bbad 1128 const uint8_t *buf = avpkt->data;
2c541554
AK
1129 SVQ3Context *s = avctx->priv_data;
1130 H264Context *h = &s->h;
e6287f07 1131 H264SliceContext *sl = &h->slice_ctx[0];
a7d2861d 1132 int buf_size = avpkt->size;
2c541554 1133 int ret, m, i;
f4cca718 1134
76de302d
DB
1135 /* special case for last picture */
1136 if (buf_size == 0) {
2c541554 1137 if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
759001c5
AK
1138 ret = av_frame_ref(data, &s->next_pic->f);
1139 if (ret < 0)
1140 return ret;
2c541554 1141 s->last_frame_output = 1;
df9b9567 1142 *got_frame = 1;
76de302d
DB
1143 }
1144 return 0;
da3b9756 1145 }
8b82a956 1146
2c541554 1147 init_get_bits(&h->gb, buf, 8 * buf_size);
8b82a956 1148
d4d9068c 1149 sl->mb_x = sl->mb_y = sl->mb_xy = 0;
8b82a956 1150
8dfc6d1f 1151 if (svq3_decode_slice_header(avctx))
76de302d 1152 return -1;
8b82a956 1153
56febc99 1154 h->pict_type = sl->slice_type;
8b82a956 1155
2c541554 1156 if (h->pict_type != AV_PICTURE_TYPE_B)
9b749c82 1157 FFSWAP(H264Picture*, s->next_pic, s->last_pic);
2c541554 1158
759001c5 1159 av_frame_unref(&s->cur_pic->f);
8b82a956 1160
8ed2ae09 1161 /* for skipping the frame */
2c541554
AK
1162 s->cur_pic->f.pict_type = h->pict_type;
1163 s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
76de302d 1164
2c541554
AK
1165 ret = get_buffer(avctx, s->cur_pic);
1166 if (ret < 0)
1167 return ret;
1168
1169 h->cur_pic_ptr = s->cur_pic;
759001c5 1170 av_frame_unref(&h->cur_pic.f);
2c541554 1171 h->cur_pic = *s->cur_pic;
759001c5
AK
1172 ret = av_frame_ref(&h->cur_pic.f, &s->cur_pic->f);
1173 if (ret < 0)
1174 return ret;
2c541554
AK
1175
1176 for (i = 0; i < 16; i++) {
c28ed1d7
AK
1177 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1178 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1179 }
1180 for (i = 0; i < 16; i++) {
1181 h->block_offset[16 + i] =
c28ed1d7 1182 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554 1183 h->block_offset[48 + 16 + i] =
c28ed1d7 1184 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1185 }
1186
1187 if (h->pict_type != AV_PICTURE_TYPE_I) {
1188 if (!s->last_pic->f.data[0]) {
1189 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1190 ret = get_buffer(avctx, s->last_pic);
1191 if (ret < 0)
1192 return ret;
1193 memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1194 memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1195 s->last_pic->f.linesize[1]);
1196 memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1197 s->last_pic->f.linesize[2]);
1198 }
1199
1200 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1201 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1202 ret = get_buffer(avctx, s->next_pic);
1203 if (ret < 0)
1204 return ret;
1205 memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1206 memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1207 s->next_pic->f.linesize[1]);
1208 memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1209 s->next_pic->f.linesize[2]);
1210 }
1211 }
1212
1213 if (avctx->debug & FF_DEBUG_PICT_INFO)
1214 av_log(h->avctx, AV_LOG_DEBUG,
1215 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1216 av_get_picture_type_char(h->pict_type),
1217 s->halfpel_flag, s->thirdpel_flag,
56febc99 1218 s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
2c541554
AK
1219
1220 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1221 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
af1ede06 1222 avctx->skip_frame >= AVDISCARD_ALL)
76de302d
DB
1223 return 0;
1224
1225 if (s->next_p_frame_damaged) {
2c541554 1226 if (h->pict_type == AV_PICTURE_TYPE_B)
76de302d
DB
1227 return 0;
1228 else
1229 s->next_p_frame_damaged = 0;
1230 }
da3b9756 1231
2c541554 1232 if (h->pict_type == AV_PICTURE_TYPE_B) {
56febc99 1233 h->frame_num_offset = sl->slice_num - h->prev_frame_num;
8b82a956 1234
a7d2861d 1235 if (h->frame_num_offset < 0)
76de302d 1236 h->frame_num_offset += 256;
a7d2861d
DB
1237 if (h->frame_num_offset == 0 ||
1238 h->frame_num_offset >= h->prev_frame_num_offset) {
2c541554 1239 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
76de302d
DB
1240 return -1;
1241 }
1242 } else {
a7d2861d 1243 h->prev_frame_num = h->frame_num;
56febc99 1244 h->frame_num = sl->slice_num;
af1ede06 1245 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
da3b9756 1246
a7d2861d 1247 if (h->prev_frame_num_offset < 0)
76de302d 1248 h->prev_frame_num_offset += 256;
da3b9756 1249 }
da3b9756 1250
a7d2861d 1251 for (m = 0; m < 2; m++) {
76de302d 1252 int i;
a7d2861d 1253 for (i = 0; i < 4; i++) {
76de302d
DB
1254 int j;
1255 for (j = -1; j < 4; j++)
e6287f07 1256 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
76de302d 1257 if (i < 3)
e6287f07 1258 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
76de302d 1259 }
da3b9756 1260 }
da3b9756 1261
d4d9068c
AK
1262 for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
1263 for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
9a2e7911 1264 unsigned mb_type;
d4d9068c 1265 sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
da3b9756 1266
2c541554
AK
1267 if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1268 ((get_bits_count(&h->gb) & 7) == 0 ||
1269 show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1270 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1271 h->gb.size_in_bits = 8 * buf_size;
da3b9756 1272
8dfc6d1f 1273 if (svq3_decode_slice_header(avctx))
76de302d 1274 return -1;
da3b9756 1275
76de302d
DB
1276 /* TODO: support s->mb_skip_run */
1277 }
da3b9756 1278
2c541554 1279 mb_type = svq3_get_ue_golomb(&h->gb);
da3b9756 1280
2c541554 1281 if (h->pict_type == AV_PICTURE_TYPE_I)
76de302d 1282 mb_type += 8;
2c541554 1283 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
76de302d 1284 mb_type += 4;
2c541554
AK
1285 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1286 av_log(h->avctx, AV_LOG_ERROR,
d4d9068c 1287 "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
76de302d
DB
1288 return -1;
1289 }
8b82a956 1290
a7d2861d 1291 if (mb_type != 0)
92c6c2a6 1292 ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
8b82a956 1293
2c541554 1294 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
d4d9068c 1295 h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
2c541554 1296 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
76de302d 1297 }
2e26c8d2 1298
75af13a0
VG
1299 ff_draw_horiz_band(avctx, &s->cur_pic->f,
1300 s->last_pic->f.data[0] ? &s->last_pic->f : NULL,
d4d9068c 1301 16 * sl->mb_y, 16, h->picture_structure, 0,
54b2ce74 1302 h->low_delay);
8b82a956 1303 }
4c701ac8 1304
2c541554 1305 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
759001c5
AK
1306 ret = av_frame_ref(data, &s->cur_pic->f);
1307 else if (s->last_pic->f.data[0])
1308 ret = av_frame_ref(data, &s->last_pic->f);
1309 if (ret < 0)
1310 return ret;
da3b9756 1311
76de302d 1312 /* Do not output the last pic after seeking. */
2c541554 1313 if (s->last_pic->f.data[0] || h->low_delay)
df9b9567 1314 *got_frame = 1;
da3b9756 1315
2c541554 1316 if (h->pict_type != AV_PICTURE_TYPE_B) {
9b749c82 1317 FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
759001c5
AK
1318 } else {
1319 av_frame_unref(&s->cur_pic->f);
2c541554
AK
1320 }
1321
76de302d 1322 return buf_size;
8b82a956
MN
1323}
1324
bd8ac882 1325static av_cold int svq3_decode_end(AVCodecContext *avctx)
8dfc6d1f 1326{
2c541554
AK
1327 SVQ3Context *s = avctx->priv_data;
1328 H264Context *h = &s->h;
8dfc6d1f 1329
2c541554
AK
1330 free_picture(avctx, s->cur_pic);
1331 free_picture(avctx, s->next_pic);
1332 free_picture(avctx, s->last_pic);
759001c5
AK
1333 av_freep(&s->cur_pic);
1334 av_freep(&s->next_pic);
1335 av_freep(&s->last_pic);
1336
1337 av_frame_unref(&h->cur_pic.f);
8dfc6d1f 1338
2c541554 1339 ff_h264_free_context(h);
8dfc6d1f
BC
1340
1341 return 0;
1342}
8b82a956 1343
d36beb3f 1344AVCodec ff_svq3_decoder = {
ec6402b7 1345 .name = "svq3",
b2bed932 1346 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
ec6402b7 1347 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 1348 .id = AV_CODEC_ID_SVQ3,
ec6402b7
AK
1349 .priv_data_size = sizeof(SVQ3Context),
1350 .init = svq3_decode_init,
1351 .close = svq3_decode_end,
1352 .decode = svq3_decode_frame,
a7d2861d
DB
1353 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND |
1354 CODEC_CAP_DR1 |
00c3b67b 1355 CODEC_CAP_DELAY,
a7d2861d
DB
1356 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1357 AV_PIX_FMT_NONE},
8b82a956 1358};