svq3: eliminate write_back_intra_pred_mode() usage
[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 */
c2a4ca94
AK
717 int8_t *i4x4 = sl->intra4x4_pred_mode + h->mb2br_xy[sl->mb_xy];
718 int8_t *i4x4_cache = sl->intra4x4_pred_mode_cache;
719
7d8154ed 720 memset(sl->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
76de302d
DB
721
722 if (mb_type == 8) {
d4d9068c 723 if (sl->mb_x > 0) {
a7d2861d 724 for (i = 0; i < 4; i++)
7d8154ed
AK
725 sl->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
726 if (sl->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
64c81b2c 727 sl->left_samples_available = 0x5F5F;
76de302d 728 }
d4d9068c 729 if (sl->mb_y > 0) {
7d8154ed
AK
730 sl->intra4x4_pred_mode_cache[4 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
731 sl->intra4x4_pred_mode_cache[5 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
732 sl->intra4x4_pred_mode_cache[6 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
733 sl->intra4x4_pred_mode_cache[7 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
76de302d 734
7d8154ed 735 if (sl->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
64c81b2c 736 sl->top_samples_available = 0x33FF;
76de302d
DB
737 }
738
739 /* decode prediction codes for luma blocks */
a7d2861d 740 for (i = 0; i < 16; i += 2) {
2c541554 741 vlc = svq3_get_ue_golomb(&h->gb);
76de302d 742
a7d2861d 743 if (vlc >= 25) {
cc8163e1
DB
744 av_log(h->avctx, AV_LOG_ERROR,
745 "luma prediction:%"PRIu32"\n", vlc);
76de302d
DB
746 return -1;
747 }
748
7d8154ed
AK
749 left = &sl->intra4x4_pred_mode_cache[scan8[i] - 1];
750 top = &sl->intra4x4_pred_mode_cache[scan8[i] - 8];
76de302d
DB
751
752 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
753 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
754
a7d2861d 755 if (left[1] == -1 || left[2] == -1) {
2c541554 756 av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
76de302d
DB
757 return -1;
758 }
759 }
760 } else { /* mb_type == 33, DC_128_PRED block type */
a7d2861d 761 for (i = 0; i < 4; i++)
7d8154ed 762 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
884182b3 763 }
8b82a956 764
c2a4ca94
AK
765 AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
766 i4x4[4] = i4x4_cache[7 + 8 * 3];
767 i4x4[5] = i4x4_cache[7 + 8 * 2];
768 i4x4[6] = i4x4_cache[7 + 8 * 1];
8b82a956 769
76de302d 770 if (mb_type == 8) {
7d8154ed 771 ff_h264_check_intra4x4_pred_mode(h, sl);
da3b9756 772
d4d9068c
AK
773 sl->top_samples_available = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
774 sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
76de302d 775 } else {
a7d2861d 776 for (i = 0; i < 4; i++)
7d8154ed 777 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
da3b9756 778
64c81b2c
AK
779 sl->top_samples_available = 0x33FF;
780 sl->left_samples_available = 0x5F5F;
76de302d 781 }
da3b9756 782
76de302d
DB
783 mb_type = MB_TYPE_INTRA4x4;
784 } else { /* INTRA16x16 */
a7da517f 785 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
a7d2861d 786 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
8b82a956 787
64c81b2c 788 if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
1115689d 789 av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
4bd5ac20 790 return sl->intra16x16_pred_mode;
76de302d 791 }
8b82a956 792
a7da517f 793 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
76de302d 794 mb_type = MB_TYPE_INTRA16x16;
884182b3 795 }
8b82a956 796
2c541554 797 if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
a7d2861d 798 for (i = 0; i < 4; i++)
759001c5 799 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
a7d2861d 800 0, 4 * 2 * sizeof(int16_t));
2c541554 801 if (h->pict_type == AV_PICTURE_TYPE_B) {
a7d2861d 802 for (i = 0; i < 4; i++)
759001c5 803 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
a7d2861d 804 0, 4 * 2 * sizeof(int16_t));
76de302d 805 }
8b82a956 806 }
76de302d 807 if (!IS_INTRA4x4(mb_type)) {
7d8154ed 808 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
da3b9756 809 }
2c541554 810 if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
f69574cf 811 memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
884182b3 812 }
2e26c8d2 813
a7d2861d 814 if (!IS_INTRA16x16(mb_type) &&
2c541554
AK
815 (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
816 if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48) {
cc8163e1 817 av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
76de302d
DB
818 return -1;
819 }
8b82a956 820
a7da517f
DB
821 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
822 : ff_h264_golomb_to_inter_cbp[vlc];
884182b3 823 }
a7d2861d 824 if (IS_INTRA16x16(mb_type) ||
2c541554 825 (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
d231e84b 826 sl->qscale += svq3_get_se_golomb(&h->gb);
8b82a956 827
d231e84b
AK
828 if (sl->qscale > 31u) {
829 av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
bb270c08 830 return -1;
bb270c08 831 }
8b82a956 832 }
76de302d 833 if (IS_INTRA16x16(mb_type)) {
bf03a878
AK
834 AV_ZERO128(sl->mb_luma_dc[0] + 0);
835 AV_ZERO128(sl->mb_luma_dc[0] + 8);
836 if (svq3_decode_block(&h->gb, sl->mb_luma_dc[0], 0, 1)) {
2c541554 837 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 838 "error while decoding intra luma dc\n");
76de302d 839 return -1;
884182b3 840 }
76de302d 841 }
8b82a956 842
76de302d
DB
843 if (cbp) {
844 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
d231e84b 845 const int type = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
76de302d 846
a7d2861d 847 for (i = 0; i < 4; i++)
76de302d
DB
848 if ((cbp & (1 << i))) {
849 for (j = 0; j < 4; j++) {
a7d2861d
DB
850 k = index ? (1 * (j & 1) + 2 * (i & 1) +
851 2 * (j & 2) + 4 * (i & 2))
852 : (4 * i + j);
f69574cf 853 sl->non_zero_count_cache[scan8[k]] = 1;
a7d2861d 854
bf03a878 855 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
2c541554 856 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 857 "error while decoding block\n");
76de302d
DB
858 return -1;
859 }
860 }
861 }
8b82a956 862
76de302d 863 if ((cbp & 0x30)) {
a7d2861d 864 for (i = 1; i < 3; ++i)
bf03a878 865 if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
2c541554 866 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d
DB
867 "error while decoding chroma dc block\n");
868 return -1;
869 }
76de302d
DB
870
871 if ((cbp & 0x20)) {
11177a4d
JGG
872 for (i = 1; i < 3; i++) {
873 for (j = 0; j < 4; j++) {
a7d2861d 874 k = 16 * i + j;
f69574cf 875 sl->non_zero_count_cache[scan8[k]] = 1;
11177a4d 876
bf03a878 877 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
2c541554 878 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 879 "error while decoding chroma ac block\n");
11177a4d
JGG
880 return -1;
881 }
76de302d
DB
882 }
883 }
884 }
bb270c08 885 }
8b82a956 886 }
8b82a956 887
e7226984 888 sl->cbp = cbp;
759001c5 889 h->cur_pic.mb_type[mb_xy] = mb_type;
8b82a956 890
a7d2861d 891 if (IS_INTRA(mb_type))
64c81b2c 892 sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, sl, DC_PRED8x8, 1);
8b82a956 893
76de302d 894 return 0;
8b82a956
MN
895}
896
8dfc6d1f 897static int svq3_decode_slice_header(AVCodecContext *avctx)
7f8205da 898{
2c541554
AK
899 SVQ3Context *s = avctx->priv_data;
900 H264Context *h = &s->h;
d231e84b 901 H264SliceContext *sl = &h->slice_ctx[0];
0edbe6fa 902 const int mb_xy = sl->mb_xy;
76de302d 903 int i, header;
288bb3da 904 unsigned slice_id;
da3b9756 905
1098f5c0 906 header = get_bits(&s->gb, 8);
da3b9756 907
76de302d
DB
908 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
909 /* TODO: what? */
8dfc6d1f 910 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
76de302d
DB
911 return -1;
912 } else {
1098f5c0 913 int slice_bits, slice_bytes, slice_length;
af1ede06 914 int length = header >> 5 & 3;
da3b9756 915
1098f5c0
LB
916 slice_length = show_bits(&s->gb, 8 * length);
917 slice_bits = slice_length * 8;
918 slice_bytes = slice_length + length - 1;
da3b9756 919
1098f5c0 920 if (slice_bytes > get_bits_left(&s->gb)) {
8dfc6d1f 921 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
76de302d 922 return -1;
a7d2861d 923 }
da3b9756 924
1098f5c0
LB
925 skip_bits(&s->gb, 8);
926
927 av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
928 if (!s->slice_buf)
929 return AVERROR(ENOMEM);
930
931 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
932
933 init_get_bits(&h->gb, s->slice_buf, slice_bits);
da3b9756 934
2c541554 935 if (s->watermark_key) {
1098f5c0
LB
936 uint32_t header = AV_RL32(&h->gb.buffer[1]);
937 AV_WL32(&h->gb.buffer[1], header ^ s->watermark_key);
76de302d
DB
938 }
939 if (length > 0) {
1098f5c0 940 memcpy(s->slice_buf, &s->slice_buf[slice_length], length - 1);
76de302d 941 }
1098f5c0 942 skip_bits_long(&s->gb, slice_bytes * 8);
da3b9756 943 }
da3b9756 944
2c541554 945 if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
cc8163e1 946 av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
76de302d
DB
947 return -1;
948 }
da3b9756 949
a7da517f 950 sl->slice_type = ff_h264_golomb_to_pict_type[slice_id];
da3b9756 951
76de302d 952 if ((header & 0x9F) == 2) {
2c541554 953 i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
47a0d393 954 sl->mb_skip_run = get_bits(&h->gb, i) -
d4d9068c 955 (sl->mb_y * h->mb_width + sl->mb_x);
76de302d 956 } else {
2c541554 957 skip_bits1(&h->gb);
47a0d393 958 sl->mb_skip_run = 0;
76de302d 959 }
da3b9756 960
56febc99
AK
961 sl->slice_num = get_bits(&h->gb, 8);
962 sl->qscale = get_bits(&h->gb, 5);
2c541554 963 s->adaptive_quant = get_bits1(&h->gb);
da3b9756 964
76de302d 965 /* unknown fields */
2c541554 966 skip_bits1(&h->gb);
da3b9756 967
2c541554
AK
968 if (s->unknown_flag)
969 skip_bits1(&h->gb);
da3b9756 970
2c541554
AK
971 skip_bits1(&h->gb);
972 skip_bits(&h->gb, 2);
da3b9756 973
2c541554
AK
974 while (get_bits1(&h->gb))
975 skip_bits(&h->gb, 8);
da3b9756 976
76de302d 977 /* reset intra predictors and invalidate motion vector references */
d4d9068c 978 if (sl->mb_x > 0) {
7d8154ed 979 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
a7d2861d 980 -1, 4 * sizeof(int8_t));
d4d9068c
AK
981 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - sl->mb_x],
982 -1, 8 * sizeof(int8_t) * sl->mb_x);
76de302d 983 }
d4d9068c 984 if (sl->mb_y > 0) {
7d8154ed 985 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
d4d9068c 986 -1, 8 * sizeof(int8_t) * (h->mb_width - sl->mb_x));
76de302d 987
d4d9068c 988 if (sl->mb_x > 0)
7d8154ed 989 sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
da3b9756 990 }
da3b9756 991
76de302d 992 return 0;
da3b9756
MM
993}
994
5ef251e5 995static av_cold int svq3_decode_init(AVCodecContext *avctx)
7f8205da 996{
2c541554
AK
997 SVQ3Context *s = avctx->priv_data;
998 H264Context *h = &s->h;
07c5ca55 999 H264SliceContext *sl;
f4cca718 1000 int m;
76de302d 1001 unsigned char *extradata;
9e1db721 1002 unsigned char *extradata_end;
76de302d 1003 unsigned int size;
9e1db721 1004 int marker_found = 0;
76de302d 1005
2c541554
AK
1006 s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1007 s->last_pic = av_mallocz(sizeof(*s->last_pic));
1008 s->next_pic = av_mallocz(sizeof(*s->next_pic));
1009 if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1010 av_freep(&s->cur_pic);
1011 av_freep(&s->last_pic);
1012 av_freep(&s->next_pic);
1013 return AVERROR(ENOMEM);
1014 }
1015
a0f29460
AK
1016 s->cur_pic->f = av_frame_alloc();
1017 s->last_pic->f = av_frame_alloc();
1018 s->next_pic->f = av_frame_alloc();
1019 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1020 return AVERROR(ENOMEM);
1021
903d58f6 1022 if (ff_h264_decode_init(avctx) < 0)
f4cca718
BC
1023 return -1;
1024
a0f29460
AK
1025 // we will overwrite it later during decoding
1026 av_frame_free(&h->cur_pic.f);
1027
c73fb9ef
AK
1028 ff_h264dsp_init(&s->h264dsp, 8, 1);
1029 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1030 ff_videodsp_init(&s->vdsp, 8);
249796e2
AK
1031
1032 memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
1033 memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
1034
1035 h->sps.bit_depth_luma = 8;
1036 h->chroma_format_idc = 1;
1037
2f6bc5f7 1038 ff_hpeldsp_init(&s->hdsp, avctx->flags);
57f09608
DB
1039 ff_tpeldsp_init(&s->tdsp);
1040
07c5ca55
AK
1041 sl = h->slice_ctx;
1042
2c541554 1043 h->flags = avctx->flags;
07c5ca55 1044 sl->is_complex = 1;
2c541554 1045 h->picture_structure = PICT_FRAME;
3795ec68
VG
1046 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1047 avctx->color_range = AVCOL_RANGE_JPEG;
76de302d 1048
d231e84b 1049 h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
2c541554 1050 h->chroma_x_shift = h->chroma_y_shift = 1;
d9ebb00d 1051
2c541554
AK
1052 s->halfpel_flag = 1;
1053 s->thirdpel_flag = 1;
1054 s->unknown_flag = 0;
d9ebb00d
AK
1055
1056 /* prowl for the "SEQH" marker in the extradata */
1057 extradata = (unsigned char *)avctx->extradata;
1058 extradata_end = avctx->extradata + avctx->extradata_size;
1059 if (extradata) {
1060 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1061 if (!memcmp(extradata, "SEQH", 4)) {
1062 marker_found = 1;
1063 break;
9e1db721 1064 }
d9ebb00d 1065 extradata++;
76de302d 1066 }
d9ebb00d 1067 }
8b82a956 1068
d9ebb00d
AK
1069 /* if a match was found, parse the extra data */
1070 if (marker_found) {
1071 GetBitContext gb;
1072 int frame_size_code;
1073
1074 size = AV_RB32(&extradata[4]);
1075 if (size > extradata_end - extradata - 8)
1076 return AVERROR_INVALIDDATA;
1077 init_get_bits(&gb, extradata + 8, size * 8);
1078
1079 /* 'frame size code' and optional 'width, height' */
1080 frame_size_code = get_bits(&gb, 3);
1081 switch (frame_size_code) {
1082 case 0:
1083 avctx->width = 160;
1084 avctx->height = 120;
1085 break;
1086 case 1:
1087 avctx->width = 128;
1088 avctx->height = 96;
1089 break;
1090 case 2:
1091 avctx->width = 176;
1092 avctx->height = 144;
1093 break;
1094 case 3:
1095 avctx->width = 352;
1096 avctx->height = 288;
1097 break;
1098 case 4:
1099 avctx->width = 704;
1100 avctx->height = 576;
1101 break;
1102 case 5:
1103 avctx->width = 240;
1104 avctx->height = 180;
1105 break;
1106 case 6:
1107 avctx->width = 320;
1108 avctx->height = 240;
1109 break;
1110 case 7:
1111 avctx->width = get_bits(&gb, 12);
1112 avctx->height = get_bits(&gb, 12);
1113 break;
1114 }
8b82a956 1115
2c541554
AK
1116 s->halfpel_flag = get_bits1(&gb);
1117 s->thirdpel_flag = get_bits1(&gb);
8b82a956 1118
d9ebb00d
AK
1119 /* unknown fields */
1120 skip_bits1(&gb);
1121 skip_bits1(&gb);
1122 skip_bits1(&gb);
1123 skip_bits1(&gb);
8b82a956 1124
2c541554 1125 h->low_delay = get_bits1(&gb);
1e002b60 1126
d9ebb00d
AK
1127 /* unknown field */
1128 skip_bits1(&gb);
76de302d 1129
d9ebb00d
AK
1130 while (get_bits1(&gb))
1131 skip_bits(&gb, 8);
76de302d 1132
2c541554
AK
1133 s->unknown_flag = get_bits1(&gb);
1134 avctx->has_b_frames = !h->low_delay;
1135 if (s->unknown_flag) {
b250f9c6 1136#if CONFIG_ZLIB
d9ebb00d
AK
1137 unsigned watermark_width = svq3_get_ue_golomb(&gb);
1138 unsigned watermark_height = svq3_get_ue_golomb(&gb);
1139 int u1 = svq3_get_ue_golomb(&gb);
1140 int u2 = get_bits(&gb, 8);
1141 int u3 = get_bits(&gb, 2);
1142 int u4 = svq3_get_ue_golomb(&gb);
1143 unsigned long buf_len = watermark_width *
1144 watermark_height * 4;
1145 int offset = get_bits_count(&gb) + 7 >> 3;
1146 uint8_t *buf;
1147
601c2015
MS
1148 if (watermark_height > 0 &&
1149 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
d9ebb00d 1150 return -1;
76de302d 1151
d9ebb00d 1152 buf = av_malloc(buf_len);
cc8163e1 1153 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
d9ebb00d
AK
1154 watermark_width, watermark_height);
1155 av_log(avctx, AV_LOG_DEBUG,
1156 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1157 u1, u2, u3, u4, offset);
1158 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1159 size - offset) != Z_OK) {
a7d2861d 1160 av_log(avctx, AV_LOG_ERROR,
d9ebb00d
AK
1161 "could not uncompress watermark logo\n");
1162 av_free(buf);
76de302d 1163 return -1;
76de302d 1164 }
2c541554
AK
1165 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1166 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
d9ebb00d 1167 av_log(avctx, AV_LOG_DEBUG,
cc8163e1 1168 "watermark key %#"PRIx32"\n", s->watermark_key);
d9ebb00d
AK
1169 av_free(buf);
1170#else
1171 av_log(avctx, AV_LOG_ERROR,
1172 "this svq3 file contains watermark which need zlib support compiled in\n");
1173 return -1;
1174#endif
76de302d 1175 }
d9ebb00d 1176 }
cdca7c37 1177
2c541554
AK
1178 h->width = avctx->width;
1179 h->height = avctx->height;
1180 h->mb_width = (h->width + 15) / 16;
1181 h->mb_height = (h->height + 15) / 16;
1182 h->mb_stride = h->mb_width + 1;
1183 h->mb_num = h->mb_width * h->mb_height;
1184 h->b_stride = 4 * h->mb_width;
1185 s->h_edge_pos = h->mb_width * 16;
1186 s->v_edge_pos = h->mb_height * 16;
cdca7c37 1187
d9ebb00d
AK
1188 if (ff_h264_alloc_tables(h) < 0) {
1189 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1190 return AVERROR(ENOMEM);
da3b9756 1191 }
76de302d 1192
f4cca718
BC
1193 return 0;
1194}
1195
9b749c82 1196static void free_picture(AVCodecContext *avctx, H264Picture *pic)
759001c5
AK
1197{
1198 int i;
1199 for (i = 0; i < 2; i++) {
1200 av_buffer_unref(&pic->motion_val_buf[i]);
1201 av_buffer_unref(&pic->ref_index_buf[i]);
1202 }
1203 av_buffer_unref(&pic->mb_type_buf);
1204
a0f29460 1205 av_frame_unref(pic->f);
759001c5
AK
1206}
1207
9b749c82 1208static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
2c541554
AK
1209{
1210 SVQ3Context *s = avctx->priv_data;
1211 H264Context *h = &s->h;
36d04801 1212 H264SliceContext *sl = &h->slice_ctx[0];
2c541554
AK
1213 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1214 const int mb_array_size = h->mb_stride * h->mb_height;
1215 const int b4_stride = h->mb_width * 4 + 1;
1216 const int b4_array_size = b4_stride * h->mb_height * 4;
1217 int ret;
1218
759001c5 1219 if (!pic->motion_val_buf[0]) {
2c541554
AK
1220 int i;
1221
759001c5
AK
1222 pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1223 if (!pic->mb_type_buf)
2c541554 1224 return AVERROR(ENOMEM);
759001c5 1225 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
2c541554
AK
1226
1227 for (i = 0; i < 2; i++) {
759001c5
AK
1228 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1229 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1230 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1231 ret = AVERROR(ENOMEM);
1232 goto fail;
1233 }
2c541554 1234
759001c5
AK
1235 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1236 pic->ref_index[i] = pic->ref_index_buf[i]->data;
2c541554
AK
1237 }
1238 }
759001c5
AK
1239 pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1240
a0f29460 1241 ret = ff_get_buffer(avctx, pic->f,
759001c5
AK
1242 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1243 if (ret < 0)
1244 goto fail;
2c541554 1245
36d04801 1246 if (!sl->edge_emu_buffer) {
a0f29460 1247 sl->edge_emu_buffer = av_mallocz(pic->f->linesize[0] * 17);
36d04801 1248 if (!sl->edge_emu_buffer)
fae6fd5b
RB
1249 return AVERROR(ENOMEM);
1250 }
2c541554 1251
a0f29460
AK
1252 sl->linesize = pic->f->linesize[0];
1253 sl->uvlinesize = pic->f->linesize[1];
2c541554 1254
759001c5
AK
1255 return 0;
1256fail:
1257 free_picture(avctx, pic);
2c541554
AK
1258 return ret;
1259}
1260
a7d2861d 1261static int svq3_decode_frame(AVCodecContext *avctx, void *data,
df9b9567 1262 int *got_frame, AVPacket *avpkt)
f4cca718 1263{
7a00bbad 1264 const uint8_t *buf = avpkt->data;
2c541554
AK
1265 SVQ3Context *s = avctx->priv_data;
1266 H264Context *h = &s->h;
e6287f07 1267 H264SliceContext *sl = &h->slice_ctx[0];
a7d2861d 1268 int buf_size = avpkt->size;
2c541554 1269 int ret, m, i;
f4cca718 1270
76de302d
DB
1271 /* special case for last picture */
1272 if (buf_size == 0) {
a0f29460
AK
1273 if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
1274 ret = av_frame_ref(data, s->next_pic->f);
759001c5
AK
1275 if (ret < 0)
1276 return ret;
2c541554 1277 s->last_frame_output = 1;
df9b9567 1278 *got_frame = 1;
76de302d
DB
1279 }
1280 return 0;
da3b9756 1281 }
8b82a956 1282
1098f5c0
LB
1283 ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1284 if (ret < 0)
1285 return ret;
8b82a956 1286
d4d9068c 1287 sl->mb_x = sl->mb_y = sl->mb_xy = 0;
8b82a956 1288
8dfc6d1f 1289 if (svq3_decode_slice_header(avctx))
76de302d 1290 return -1;
8b82a956 1291
56febc99 1292 h->pict_type = sl->slice_type;
8b82a956 1293
2c541554 1294 if (h->pict_type != AV_PICTURE_TYPE_B)
9b749c82 1295 FFSWAP(H264Picture*, s->next_pic, s->last_pic);
2c541554 1296
a0f29460 1297 av_frame_unref(s->cur_pic->f);
8b82a956 1298
8ed2ae09 1299 /* for skipping the frame */
a0f29460
AK
1300 s->cur_pic->f->pict_type = h->pict_type;
1301 s->cur_pic->f->key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
76de302d 1302
2c541554
AK
1303 ret = get_buffer(avctx, s->cur_pic);
1304 if (ret < 0)
1305 return ret;
1306
1307 h->cur_pic_ptr = s->cur_pic;
1308 h->cur_pic = *s->cur_pic;
1309
1310 for (i = 0; i < 16; i++) {
c28ed1d7
AK
1311 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1312 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1313 }
1314 for (i = 0; i < 16; i++) {
1315 h->block_offset[16 + i] =
c28ed1d7 1316 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554 1317 h->block_offset[48 + 16 + i] =
c28ed1d7 1318 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1319 }
1320
1321 if (h->pict_type != AV_PICTURE_TYPE_I) {
a0f29460 1322 if (!s->last_pic->f->data[0]) {
2c541554
AK
1323 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1324 ret = get_buffer(avctx, s->last_pic);
1325 if (ret < 0)
1326 return ret;
a0f29460
AK
1327 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1328 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1329 s->last_pic->f->linesize[1]);
1330 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1331 s->last_pic->f->linesize[2]);
2c541554
AK
1332 }
1333
a0f29460 1334 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
2c541554
AK
1335 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1336 ret = get_buffer(avctx, s->next_pic);
1337 if (ret < 0)
1338 return ret;
a0f29460
AK
1339 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1340 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1341 s->next_pic->f->linesize[1]);
1342 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1343 s->next_pic->f->linesize[2]);
2c541554
AK
1344 }
1345 }
1346
1347 if (avctx->debug & FF_DEBUG_PICT_INFO)
1348 av_log(h->avctx, AV_LOG_DEBUG,
1349 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1350 av_get_picture_type_char(h->pict_type),
1351 s->halfpel_flag, s->thirdpel_flag,
56febc99 1352 s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
2c541554
AK
1353
1354 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1355 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
af1ede06 1356 avctx->skip_frame >= AVDISCARD_ALL)
76de302d
DB
1357 return 0;
1358
1359 if (s->next_p_frame_damaged) {
2c541554 1360 if (h->pict_type == AV_PICTURE_TYPE_B)
76de302d
DB
1361 return 0;
1362 else
1363 s->next_p_frame_damaged = 0;
1364 }
da3b9756 1365
2c541554 1366 if (h->pict_type == AV_PICTURE_TYPE_B) {
56febc99 1367 h->frame_num_offset = sl->slice_num - h->prev_frame_num;
8b82a956 1368
a7d2861d 1369 if (h->frame_num_offset < 0)
76de302d 1370 h->frame_num_offset += 256;
a7d2861d
DB
1371 if (h->frame_num_offset == 0 ||
1372 h->frame_num_offset >= h->prev_frame_num_offset) {
2c541554 1373 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
76de302d
DB
1374 return -1;
1375 }
1376 } else {
a7d2861d 1377 h->prev_frame_num = h->frame_num;
56febc99 1378 h->frame_num = sl->slice_num;
af1ede06 1379 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
da3b9756 1380
a7d2861d 1381 if (h->prev_frame_num_offset < 0)
76de302d 1382 h->prev_frame_num_offset += 256;
da3b9756 1383 }
da3b9756 1384
a7d2861d 1385 for (m = 0; m < 2; m++) {
76de302d 1386 int i;
a7d2861d 1387 for (i = 0; i < 4; i++) {
76de302d
DB
1388 int j;
1389 for (j = -1; j < 4; j++)
e6287f07 1390 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
76de302d 1391 if (i < 3)
e6287f07 1392 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
76de302d 1393 }
da3b9756 1394 }
da3b9756 1395
d4d9068c
AK
1396 for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
1397 for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
9a2e7911 1398 unsigned mb_type;
d4d9068c 1399 sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
da3b9756 1400
1098f5c0
LB
1401 if ((get_bits_left(&h->gb)) <= 7) {
1402 if (((get_bits_count(&h->gb) & 7) == 0 ||
1403 show_bits(&h->gb, get_bits_left(&h->gb) & 7) == 0)) {
da3b9756 1404
1098f5c0
LB
1405 if (svq3_decode_slice_header(avctx))
1406 return -1;
1407 }
76de302d
DB
1408 /* TODO: support s->mb_skip_run */
1409 }
da3b9756 1410
2c541554 1411 mb_type = svq3_get_ue_golomb(&h->gb);
da3b9756 1412
2c541554 1413 if (h->pict_type == AV_PICTURE_TYPE_I)
76de302d 1414 mb_type += 8;
2c541554 1415 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
76de302d 1416 mb_type += 4;
2c541554
AK
1417 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1418 av_log(h->avctx, AV_LOG_ERROR,
d4d9068c 1419 "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
76de302d
DB
1420 return -1;
1421 }
8b82a956 1422
a7d2861d 1423 if (mb_type != 0)
c73fb9ef 1424 hl_decode_mb(s, h, &h->slice_ctx[0]);
8b82a956 1425
2c541554 1426 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
d4d9068c 1427 h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
2c541554 1428 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
76de302d 1429 }
2e26c8d2 1430
a0f29460
AK
1431 ff_draw_horiz_band(avctx, s->cur_pic->f,
1432 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
d4d9068c 1433 16 * sl->mb_y, 16, h->picture_structure, 0,
54b2ce74 1434 h->low_delay);
8b82a956 1435 }
4c701ac8 1436
2c541554 1437 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
a0f29460
AK
1438 ret = av_frame_ref(data, s->cur_pic->f);
1439 else if (s->last_pic->f->data[0])
1440 ret = av_frame_ref(data, s->last_pic->f);
759001c5
AK
1441 if (ret < 0)
1442 return ret;
da3b9756 1443
76de302d 1444 /* Do not output the last pic after seeking. */
a0f29460 1445 if (s->last_pic->f->data[0] || h->low_delay)
df9b9567 1446 *got_frame = 1;
da3b9756 1447
2c541554 1448 if (h->pict_type != AV_PICTURE_TYPE_B) {
9b749c82 1449 FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
759001c5 1450 } else {
a0f29460 1451 av_frame_unref(s->cur_pic->f);
2c541554
AK
1452 }
1453
76de302d 1454 return buf_size;
8b82a956
MN
1455}
1456
bd8ac882 1457static av_cold int svq3_decode_end(AVCodecContext *avctx)
8dfc6d1f 1458{
2c541554
AK
1459 SVQ3Context *s = avctx->priv_data;
1460 H264Context *h = &s->h;
8dfc6d1f 1461
2c541554
AK
1462 free_picture(avctx, s->cur_pic);
1463 free_picture(avctx, s->next_pic);
1464 free_picture(avctx, s->last_pic);
a0f29460
AK
1465 av_frame_free(&s->cur_pic->f);
1466 av_frame_free(&s->next_pic->f);
1467 av_frame_free(&s->last_pic->f);
759001c5
AK
1468 av_freep(&s->cur_pic);
1469 av_freep(&s->next_pic);
1470 av_freep(&s->last_pic);
1098f5c0 1471 av_freep(&s->slice_buf);
759001c5 1472
a0f29460 1473 memset(&h->cur_pic, 0, sizeof(h->cur_pic));
8dfc6d1f 1474
2c541554 1475 ff_h264_free_context(h);
8dfc6d1f
BC
1476
1477 return 0;
1478}
8b82a956 1479
d36beb3f 1480AVCodec ff_svq3_decoder = {
ec6402b7 1481 .name = "svq3",
b2bed932 1482 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
ec6402b7 1483 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 1484 .id = AV_CODEC_ID_SVQ3,
ec6402b7
AK
1485 .priv_data_size = sizeof(SVQ3Context),
1486 .init = svq3_decode_init,
1487 .close = svq3_decode_end,
1488 .decode = svq3_decode_frame,
def97856
VG
1489 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1490 AV_CODEC_CAP_DR1 |
1491 AV_CODEC_CAP_DELAY,
a7d2861d
DB
1492 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1493 AV_PIX_FMT_NONE},
8b82a956 1494};