cmdutils: update copyright year to 2016
[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 */
a0f29460
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
7c6eb0a1 335 if (!(h->flags & AV_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++) {
a0f29460
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
a0f29460
AK
887 s->cur_pic->f = av_frame_alloc();
888 s->last_pic->f = av_frame_alloc();
889 s->next_pic->f = av_frame_alloc();
890 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
891 return AVERROR(ENOMEM);
892
903d58f6 893 if (ff_h264_decode_init(avctx) < 0)
f4cca718
BC
894 return -1;
895
a0f29460
AK
896 // we will overwrite it later during decoding
897 av_frame_free(&h->cur_pic.f);
898
249796e2
AK
899 ff_h264dsp_init(&h->h264dsp, 8, 1);
900 ff_h264chroma_init(&h->h264chroma, 8);
901 ff_h264qpel_init(&h->h264qpel, 8);
902 ff_h264_pred_init(&h->hpc, AV_CODEC_ID_SVQ3, 8, 1);
903 ff_videodsp_init(&h->vdsp, 8);
904
905 memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
906 memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
907
908 h->sps.bit_depth_luma = 8;
909 h->chroma_format_idc = 1;
910
2f6bc5f7 911 ff_hpeldsp_init(&s->hdsp, avctx->flags);
57f09608
DB
912 ff_tpeldsp_init(&s->tdsp);
913
07c5ca55
AK
914 sl = h->slice_ctx;
915
2c541554 916 h->flags = avctx->flags;
07c5ca55 917 sl->is_complex = 1;
2c541554 918 h->picture_structure = PICT_FRAME;
3795ec68
VG
919 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
920 avctx->color_range = AVCOL_RANGE_JPEG;
76de302d 921
d231e84b 922 h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
2c541554 923 h->chroma_x_shift = h->chroma_y_shift = 1;
d9ebb00d 924
2c541554
AK
925 s->halfpel_flag = 1;
926 s->thirdpel_flag = 1;
927 s->unknown_flag = 0;
d9ebb00d
AK
928
929 /* prowl for the "SEQH" marker in the extradata */
930 extradata = (unsigned char *)avctx->extradata;
931 extradata_end = avctx->extradata + avctx->extradata_size;
932 if (extradata) {
933 for (m = 0; m + 8 < avctx->extradata_size; m++) {
934 if (!memcmp(extradata, "SEQH", 4)) {
935 marker_found = 1;
936 break;
9e1db721 937 }
d9ebb00d 938 extradata++;
76de302d 939 }
d9ebb00d 940 }
8b82a956 941
d9ebb00d
AK
942 /* if a match was found, parse the extra data */
943 if (marker_found) {
944 GetBitContext gb;
945 int frame_size_code;
946
947 size = AV_RB32(&extradata[4]);
948 if (size > extradata_end - extradata - 8)
949 return AVERROR_INVALIDDATA;
950 init_get_bits(&gb, extradata + 8, size * 8);
951
952 /* 'frame size code' and optional 'width, height' */
953 frame_size_code = get_bits(&gb, 3);
954 switch (frame_size_code) {
955 case 0:
956 avctx->width = 160;
957 avctx->height = 120;
958 break;
959 case 1:
960 avctx->width = 128;
961 avctx->height = 96;
962 break;
963 case 2:
964 avctx->width = 176;
965 avctx->height = 144;
966 break;
967 case 3:
968 avctx->width = 352;
969 avctx->height = 288;
970 break;
971 case 4:
972 avctx->width = 704;
973 avctx->height = 576;
974 break;
975 case 5:
976 avctx->width = 240;
977 avctx->height = 180;
978 break;
979 case 6:
980 avctx->width = 320;
981 avctx->height = 240;
982 break;
983 case 7:
984 avctx->width = get_bits(&gb, 12);
985 avctx->height = get_bits(&gb, 12);
986 break;
987 }
8b82a956 988
2c541554
AK
989 s->halfpel_flag = get_bits1(&gb);
990 s->thirdpel_flag = get_bits1(&gb);
8b82a956 991
d9ebb00d
AK
992 /* unknown fields */
993 skip_bits1(&gb);
994 skip_bits1(&gb);
995 skip_bits1(&gb);
996 skip_bits1(&gb);
8b82a956 997
2c541554 998 h->low_delay = get_bits1(&gb);
1e002b60 999
d9ebb00d
AK
1000 /* unknown field */
1001 skip_bits1(&gb);
76de302d 1002
d9ebb00d
AK
1003 while (get_bits1(&gb))
1004 skip_bits(&gb, 8);
76de302d 1005
2c541554
AK
1006 s->unknown_flag = get_bits1(&gb);
1007 avctx->has_b_frames = !h->low_delay;
1008 if (s->unknown_flag) {
b250f9c6 1009#if CONFIG_ZLIB
d9ebb00d
AK
1010 unsigned watermark_width = svq3_get_ue_golomb(&gb);
1011 unsigned watermark_height = svq3_get_ue_golomb(&gb);
1012 int u1 = svq3_get_ue_golomb(&gb);
1013 int u2 = get_bits(&gb, 8);
1014 int u3 = get_bits(&gb, 2);
1015 int u4 = svq3_get_ue_golomb(&gb);
1016 unsigned long buf_len = watermark_width *
1017 watermark_height * 4;
1018 int offset = get_bits_count(&gb) + 7 >> 3;
1019 uint8_t *buf;
1020
601c2015
MS
1021 if (watermark_height > 0 &&
1022 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
d9ebb00d 1023 return -1;
76de302d 1024
d9ebb00d 1025 buf = av_malloc(buf_len);
cc8163e1 1026 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
d9ebb00d
AK
1027 watermark_width, watermark_height);
1028 av_log(avctx, AV_LOG_DEBUG,
1029 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1030 u1, u2, u3, u4, offset);
1031 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1032 size - offset) != Z_OK) {
a7d2861d 1033 av_log(avctx, AV_LOG_ERROR,
d9ebb00d
AK
1034 "could not uncompress watermark logo\n");
1035 av_free(buf);
76de302d 1036 return -1;
76de302d 1037 }
2c541554
AK
1038 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1039 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
d9ebb00d 1040 av_log(avctx, AV_LOG_DEBUG,
cc8163e1 1041 "watermark key %#"PRIx32"\n", s->watermark_key);
d9ebb00d
AK
1042 av_free(buf);
1043#else
1044 av_log(avctx, AV_LOG_ERROR,
1045 "this svq3 file contains watermark which need zlib support compiled in\n");
1046 return -1;
1047#endif
76de302d 1048 }
d9ebb00d 1049 }
cdca7c37 1050
2c541554
AK
1051 h->width = avctx->width;
1052 h->height = avctx->height;
1053 h->mb_width = (h->width + 15) / 16;
1054 h->mb_height = (h->height + 15) / 16;
1055 h->mb_stride = h->mb_width + 1;
1056 h->mb_num = h->mb_width * h->mb_height;
1057 h->b_stride = 4 * h->mb_width;
1058 s->h_edge_pos = h->mb_width * 16;
1059 s->v_edge_pos = h->mb_height * 16;
cdca7c37 1060
d9ebb00d
AK
1061 if (ff_h264_alloc_tables(h) < 0) {
1062 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1063 return AVERROR(ENOMEM);
da3b9756 1064 }
76de302d 1065
f4cca718
BC
1066 return 0;
1067}
1068
9b749c82 1069static void free_picture(AVCodecContext *avctx, H264Picture *pic)
759001c5
AK
1070{
1071 int i;
1072 for (i = 0; i < 2; i++) {
1073 av_buffer_unref(&pic->motion_val_buf[i]);
1074 av_buffer_unref(&pic->ref_index_buf[i]);
1075 }
1076 av_buffer_unref(&pic->mb_type_buf);
1077
a0f29460 1078 av_frame_unref(pic->f);
759001c5
AK
1079}
1080
9b749c82 1081static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
2c541554
AK
1082{
1083 SVQ3Context *s = avctx->priv_data;
1084 H264Context *h = &s->h;
36d04801 1085 H264SliceContext *sl = &h->slice_ctx[0];
2c541554
AK
1086 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1087 const int mb_array_size = h->mb_stride * h->mb_height;
1088 const int b4_stride = h->mb_width * 4 + 1;
1089 const int b4_array_size = b4_stride * h->mb_height * 4;
1090 int ret;
1091
759001c5 1092 if (!pic->motion_val_buf[0]) {
2c541554
AK
1093 int i;
1094
759001c5
AK
1095 pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1096 if (!pic->mb_type_buf)
2c541554 1097 return AVERROR(ENOMEM);
759001c5 1098 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
2c541554
AK
1099
1100 for (i = 0; i < 2; i++) {
759001c5
AK
1101 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1102 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1103 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1104 ret = AVERROR(ENOMEM);
1105 goto fail;
1106 }
2c541554 1107
759001c5
AK
1108 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1109 pic->ref_index[i] = pic->ref_index_buf[i]->data;
2c541554
AK
1110 }
1111 }
759001c5
AK
1112 pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1113
a0f29460 1114 ret = ff_get_buffer(avctx, pic->f,
759001c5
AK
1115 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1116 if (ret < 0)
1117 goto fail;
2c541554 1118
36d04801 1119 if (!sl->edge_emu_buffer) {
a0f29460 1120 sl->edge_emu_buffer = av_mallocz(pic->f->linesize[0] * 17);
36d04801 1121 if (!sl->edge_emu_buffer)
fae6fd5b
RB
1122 return AVERROR(ENOMEM);
1123 }
2c541554 1124
a0f29460
AK
1125 sl->linesize = pic->f->linesize[0];
1126 sl->uvlinesize = pic->f->linesize[1];
2c541554 1127
759001c5
AK
1128 return 0;
1129fail:
1130 free_picture(avctx, pic);
2c541554
AK
1131 return ret;
1132}
1133
a7d2861d 1134static int svq3_decode_frame(AVCodecContext *avctx, void *data,
df9b9567 1135 int *got_frame, AVPacket *avpkt)
f4cca718 1136{
7a00bbad 1137 const uint8_t *buf = avpkt->data;
2c541554
AK
1138 SVQ3Context *s = avctx->priv_data;
1139 H264Context *h = &s->h;
e6287f07 1140 H264SliceContext *sl = &h->slice_ctx[0];
a7d2861d 1141 int buf_size = avpkt->size;
2c541554 1142 int ret, m, i;
f4cca718 1143
76de302d
DB
1144 /* special case for last picture */
1145 if (buf_size == 0) {
a0f29460
AK
1146 if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
1147 ret = av_frame_ref(data, s->next_pic->f);
759001c5
AK
1148 if (ret < 0)
1149 return ret;
2c541554 1150 s->last_frame_output = 1;
df9b9567 1151 *got_frame = 1;
76de302d
DB
1152 }
1153 return 0;
da3b9756 1154 }
8b82a956 1155
2c541554 1156 init_get_bits(&h->gb, buf, 8 * buf_size);
8b82a956 1157
d4d9068c 1158 sl->mb_x = sl->mb_y = sl->mb_xy = 0;
8b82a956 1159
8dfc6d1f 1160 if (svq3_decode_slice_header(avctx))
76de302d 1161 return -1;
8b82a956 1162
56febc99 1163 h->pict_type = sl->slice_type;
8b82a956 1164
2c541554 1165 if (h->pict_type != AV_PICTURE_TYPE_B)
9b749c82 1166 FFSWAP(H264Picture*, s->next_pic, s->last_pic);
2c541554 1167
a0f29460 1168 av_frame_unref(s->cur_pic->f);
8b82a956 1169
8ed2ae09 1170 /* for skipping the frame */
a0f29460
AK
1171 s->cur_pic->f->pict_type = h->pict_type;
1172 s->cur_pic->f->key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
76de302d 1173
2c541554
AK
1174 ret = get_buffer(avctx, s->cur_pic);
1175 if (ret < 0)
1176 return ret;
1177
1178 h->cur_pic_ptr = s->cur_pic;
1179 h->cur_pic = *s->cur_pic;
1180
1181 for (i = 0; i < 16; i++) {
c28ed1d7
AK
1182 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1183 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1184 }
1185 for (i = 0; i < 16; i++) {
1186 h->block_offset[16 + i] =
c28ed1d7 1187 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554 1188 h->block_offset[48 + 16 + i] =
c28ed1d7 1189 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1190 }
1191
1192 if (h->pict_type != AV_PICTURE_TYPE_I) {
a0f29460 1193 if (!s->last_pic->f->data[0]) {
2c541554
AK
1194 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1195 ret = get_buffer(avctx, s->last_pic);
1196 if (ret < 0)
1197 return ret;
a0f29460
AK
1198 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1199 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1200 s->last_pic->f->linesize[1]);
1201 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1202 s->last_pic->f->linesize[2]);
2c541554
AK
1203 }
1204
a0f29460 1205 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
2c541554
AK
1206 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1207 ret = get_buffer(avctx, s->next_pic);
1208 if (ret < 0)
1209 return ret;
a0f29460
AK
1210 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1211 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1212 s->next_pic->f->linesize[1]);
1213 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1214 s->next_pic->f->linesize[2]);
2c541554
AK
1215 }
1216 }
1217
1218 if (avctx->debug & FF_DEBUG_PICT_INFO)
1219 av_log(h->avctx, AV_LOG_DEBUG,
1220 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1221 av_get_picture_type_char(h->pict_type),
1222 s->halfpel_flag, s->thirdpel_flag,
56febc99 1223 s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
2c541554
AK
1224
1225 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1226 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
af1ede06 1227 avctx->skip_frame >= AVDISCARD_ALL)
76de302d
DB
1228 return 0;
1229
1230 if (s->next_p_frame_damaged) {
2c541554 1231 if (h->pict_type == AV_PICTURE_TYPE_B)
76de302d
DB
1232 return 0;
1233 else
1234 s->next_p_frame_damaged = 0;
1235 }
da3b9756 1236
2c541554 1237 if (h->pict_type == AV_PICTURE_TYPE_B) {
56febc99 1238 h->frame_num_offset = sl->slice_num - h->prev_frame_num;
8b82a956 1239
a7d2861d 1240 if (h->frame_num_offset < 0)
76de302d 1241 h->frame_num_offset += 256;
a7d2861d
DB
1242 if (h->frame_num_offset == 0 ||
1243 h->frame_num_offset >= h->prev_frame_num_offset) {
2c541554 1244 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
76de302d
DB
1245 return -1;
1246 }
1247 } else {
a7d2861d 1248 h->prev_frame_num = h->frame_num;
56febc99 1249 h->frame_num = sl->slice_num;
af1ede06 1250 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
da3b9756 1251
a7d2861d 1252 if (h->prev_frame_num_offset < 0)
76de302d 1253 h->prev_frame_num_offset += 256;
da3b9756 1254 }
da3b9756 1255
a7d2861d 1256 for (m = 0; m < 2; m++) {
76de302d 1257 int i;
a7d2861d 1258 for (i = 0; i < 4; i++) {
76de302d
DB
1259 int j;
1260 for (j = -1; j < 4; j++)
e6287f07 1261 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
76de302d 1262 if (i < 3)
e6287f07 1263 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
76de302d 1264 }
da3b9756 1265 }
da3b9756 1266
d4d9068c
AK
1267 for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
1268 for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
9a2e7911 1269 unsigned mb_type;
d4d9068c 1270 sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
da3b9756 1271
2c541554
AK
1272 if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1273 ((get_bits_count(&h->gb) & 7) == 0 ||
1274 show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1275 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1276 h->gb.size_in_bits = 8 * buf_size;
da3b9756 1277
8dfc6d1f 1278 if (svq3_decode_slice_header(avctx))
76de302d 1279 return -1;
da3b9756 1280
76de302d
DB
1281 /* TODO: support s->mb_skip_run */
1282 }
da3b9756 1283
2c541554 1284 mb_type = svq3_get_ue_golomb(&h->gb);
da3b9756 1285
2c541554 1286 if (h->pict_type == AV_PICTURE_TYPE_I)
76de302d 1287 mb_type += 8;
2c541554 1288 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
76de302d 1289 mb_type += 4;
2c541554
AK
1290 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1291 av_log(h->avctx, AV_LOG_ERROR,
d4d9068c 1292 "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
76de302d
DB
1293 return -1;
1294 }
8b82a956 1295
a7d2861d 1296 if (mb_type != 0)
92c6c2a6 1297 ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
8b82a956 1298
2c541554 1299 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
d4d9068c 1300 h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
2c541554 1301 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
76de302d 1302 }
2e26c8d2 1303
a0f29460
AK
1304 ff_draw_horiz_band(avctx, s->cur_pic->f,
1305 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
d4d9068c 1306 16 * sl->mb_y, 16, h->picture_structure, 0,
54b2ce74 1307 h->low_delay);
8b82a956 1308 }
4c701ac8 1309
2c541554 1310 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
a0f29460
AK
1311 ret = av_frame_ref(data, s->cur_pic->f);
1312 else if (s->last_pic->f->data[0])
1313 ret = av_frame_ref(data, s->last_pic->f);
759001c5
AK
1314 if (ret < 0)
1315 return ret;
da3b9756 1316
76de302d 1317 /* Do not output the last pic after seeking. */
a0f29460 1318 if (s->last_pic->f->data[0] || h->low_delay)
df9b9567 1319 *got_frame = 1;
da3b9756 1320
2c541554 1321 if (h->pict_type != AV_PICTURE_TYPE_B) {
9b749c82 1322 FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
759001c5 1323 } else {
a0f29460 1324 av_frame_unref(s->cur_pic->f);
2c541554
AK
1325 }
1326
76de302d 1327 return buf_size;
8b82a956
MN
1328}
1329
bd8ac882 1330static av_cold int svq3_decode_end(AVCodecContext *avctx)
8dfc6d1f 1331{
2c541554
AK
1332 SVQ3Context *s = avctx->priv_data;
1333 H264Context *h = &s->h;
8dfc6d1f 1334
2c541554
AK
1335 free_picture(avctx, s->cur_pic);
1336 free_picture(avctx, s->next_pic);
1337 free_picture(avctx, s->last_pic);
a0f29460
AK
1338 av_frame_free(&s->cur_pic->f);
1339 av_frame_free(&s->next_pic->f);
1340 av_frame_free(&s->last_pic->f);
759001c5
AK
1341 av_freep(&s->cur_pic);
1342 av_freep(&s->next_pic);
1343 av_freep(&s->last_pic);
1344
a0f29460 1345 memset(&h->cur_pic, 0, sizeof(h->cur_pic));
8dfc6d1f 1346
2c541554 1347 ff_h264_free_context(h);
8dfc6d1f
BC
1348
1349 return 0;
1350}
8b82a956 1351
d36beb3f 1352AVCodec ff_svq3_decoder = {
ec6402b7 1353 .name = "svq3",
b2bed932 1354 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
ec6402b7 1355 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 1356 .id = AV_CODEC_ID_SVQ3,
ec6402b7
AK
1357 .priv_data_size = sizeof(SVQ3Context),
1358 .init = svq3_decode_init,
1359 .close = svq3_decode_end,
1360 .decode = svq3_decode_frame,
def97856
VG
1361 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1362 AV_CODEC_CAP_DR1 |
1363 AV_CODEC_CAP_DELAY,
a7d2861d
DB
1364 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1365 AV_PIX_FMT_NONE},
8b82a956 1366};