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