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