svq3: move mb_{x,y,xy} to SVQ3Context
[libav.git] / libavcodec / svq3.c
CommitLineData
8b82a956 1/*
2912e87a 2 * Copyright (c) 2003 The Libav Project
8b82a956 3 *
2912e87a 4 * This file is part of Libav.
b78e7197 5 *
2912e87a 6 * Libav is free software; you can redistribute it and/or
8b82a956
MN
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
b78e7197 9 * version 2.1 of the License, or (at your option) any later version.
8b82a956 10 *
2912e87a 11 * Libav is distributed in the hope that it will be useful,
8b82a956
MN
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
2912e87a 17 * License along with Libav; if not, write to the Free Software
5509bffa 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
e5a389a1
DB
19 */
20
21/*
8b82a956
MN
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
89a79364
MM
24 * have stsd atoms to describe media trak properties. A stsd atom for a
25 * video trak contains 1 or more ImageDescription atoms. These atoms begin
26 * with the 4-byte length of the atom followed by the codec fourcc. Some
27 * decoders need information in this atom to operate correctly. Such
28 * is the case with SVQ3. In order to get the best use out of this decoder,
29 * the calling app must make the SVQ3 ImageDescription atom available
8b82a956
MN
30 * via the AVCodecContext's extradata[_size] field:
31 *
115329f1 32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
89a79364 33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
115329f1
DB
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
89a79364
MM
36 * from the QT file, minus 4 bytes since the length is missing)
37 *
38 * You will know you have these parameters passed correctly when the decoder
39 * correctly decodes this file:
f0a41afd 40 * http://samples.libav.org/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
8b82a956 41 */
bd8ac882 42
cc8163e1
DB
43#include <inttypes.h>
44
bd8ac882 45#include "libavutil/attributes.h"
903d58f6 46#include "internal.h"
903d58f6 47#include "avcodec.h"
e0c16e4e 48#include "mpegutils.h"
903d58f6 49#include "h264.h"
188d3c51 50#include "h264_mvpred.h"
a7da517f 51#include "h264data.h"
903d58f6 52#include "golomb.h"
2f6bc5f7 53#include "hpeldsp.h"
f4d581cd 54#include "mathops.h"
903d58f6 55#include "rectangle.h"
57f09608 56#include "tpeldsp.h"
903d58f6 57
b250f9c6 58#if CONFIG_ZLIB
c4864924
BC
59#include <zlib.h>
60#endif
61
2be3fe39
DB
62#include "svq1.h"
63
8b82a956 64/**
ba87f080 65 * @file
8b82a956
MN
66 * svq3 decoder.
67 */
68
7f9f771e 69typedef struct SVQ3Context {
8dfc6d1f 70 H264Context h;
c73fb9ef
AK
71
72 H264DSPContext h264dsp;
73 H264PredContext hpc;
2f6bc5f7 74 HpelDSPContext hdsp;
57f09608 75 TpelDSPContext tdsp;
c73fb9ef
AK
76 VideoDSPContext vdsp;
77
9b749c82
VG
78 H264Picture *cur_pic;
79 H264Picture *next_pic;
80 H264Picture *last_pic;
1098f5c0
LB
81 GetBitContext gb;
82 uint8_t *slice_buf;
83 int slice_size;
8dfc6d1f
BC
84 int halfpel_flag;
85 int thirdpel_flag;
86 int unknown_flag;
8dfc6d1f 87 uint32_t watermark_key;
2c541554
AK
88 int adaptive_quant;
89 int next_p_frame_damaged;
90 int h_edge_pos;
91 int v_edge_pos;
92 int last_frame_output;
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) {
7d8154ed 774 ff_h264_check_intra4x4_pred_mode(h, sl);
da3b9756 775
1877712c
AK
776 sl->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
777 sl->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
76de302d 778 } else {
a7d2861d 779 for (i = 0; i < 4; i++)
7d8154ed 780 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
da3b9756 781
64c81b2c
AK
782 sl->top_samples_available = 0x33FF;
783 sl->left_samples_available = 0x5F5F;
76de302d 784 }
da3b9756 785
76de302d
DB
786 mb_type = MB_TYPE_INTRA4x4;
787 } else { /* INTRA16x16 */
a7da517f 788 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
a7d2861d 789 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
8b82a956 790
64c81b2c 791 if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
1115689d 792 av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
4bd5ac20 793 return sl->intra16x16_pred_mode;
76de302d 794 }
8b82a956 795
a7da517f 796 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
76de302d 797 mb_type = MB_TYPE_INTRA16x16;
884182b3 798 }
8b82a956 799
2c541554 800 if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
a7d2861d 801 for (i = 0; i < 4; i++)
759001c5 802 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
a7d2861d 803 0, 4 * 2 * sizeof(int16_t));
2c541554 804 if (h->pict_type == AV_PICTURE_TYPE_B) {
a7d2861d 805 for (i = 0; i < 4; i++)
759001c5 806 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
a7d2861d 807 0, 4 * 2 * sizeof(int16_t));
76de302d 808 }
8b82a956 809 }
76de302d 810 if (!IS_INTRA4x4(mb_type)) {
7d8154ed 811 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
da3b9756 812 }
2c541554 813 if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
f69574cf 814 memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
884182b3 815 }
2e26c8d2 816
a7d2861d 817 if (!IS_INTRA16x16(mb_type) &&
2c541554
AK
818 (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
819 if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48) {
cc8163e1 820 av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
76de302d
DB
821 return -1;
822 }
8b82a956 823
a7da517f
DB
824 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
825 : ff_h264_golomb_to_inter_cbp[vlc];
884182b3 826 }
a7d2861d 827 if (IS_INTRA16x16(mb_type) ||
2c541554 828 (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
d231e84b 829 sl->qscale += svq3_get_se_golomb(&h->gb);
8b82a956 830
d231e84b
AK
831 if (sl->qscale > 31u) {
832 av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
bb270c08 833 return -1;
bb270c08 834 }
8b82a956 835 }
76de302d 836 if (IS_INTRA16x16(mb_type)) {
bf03a878
AK
837 AV_ZERO128(sl->mb_luma_dc[0] + 0);
838 AV_ZERO128(sl->mb_luma_dc[0] + 8);
839 if (svq3_decode_block(&h->gb, sl->mb_luma_dc[0], 0, 1)) {
2c541554 840 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 841 "error while decoding intra luma dc\n");
76de302d 842 return -1;
884182b3 843 }
76de302d 844 }
8b82a956 845
76de302d
DB
846 if (cbp) {
847 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
d231e84b 848 const int type = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
76de302d 849
a7d2861d 850 for (i = 0; i < 4; i++)
76de302d
DB
851 if ((cbp & (1 << i))) {
852 for (j = 0; j < 4; j++) {
a7d2861d
DB
853 k = index ? (1 * (j & 1) + 2 * (i & 1) +
854 2 * (j & 2) + 4 * (i & 2))
855 : (4 * i + j);
f69574cf 856 sl->non_zero_count_cache[scan8[k]] = 1;
a7d2861d 857
bf03a878 858 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
2c541554 859 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 860 "error while decoding block\n");
76de302d
DB
861 return -1;
862 }
863 }
864 }
8b82a956 865
76de302d 866 if ((cbp & 0x30)) {
a7d2861d 867 for (i = 1; i < 3; ++i)
bf03a878 868 if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
2c541554 869 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d
DB
870 "error while decoding chroma dc block\n");
871 return -1;
872 }
76de302d
DB
873
874 if ((cbp & 0x20)) {
11177a4d
JGG
875 for (i = 1; i < 3; i++) {
876 for (j = 0; j < 4; j++) {
a7d2861d 877 k = 16 * i + j;
f69574cf 878 sl->non_zero_count_cache[scan8[k]] = 1;
11177a4d 879
bf03a878 880 if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
2c541554 881 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 882 "error while decoding chroma ac block\n");
11177a4d
JGG
883 return -1;
884 }
76de302d
DB
885 }
886 }
887 }
bb270c08 888 }
8b82a956 889 }
8b82a956 890
e7226984 891 sl->cbp = cbp;
759001c5 892 h->cur_pic.mb_type[mb_xy] = mb_type;
8b82a956 893
a7d2861d 894 if (IS_INTRA(mb_type))
64c81b2c 895 sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, sl, DC_PRED8x8, 1);
8b82a956 896
76de302d 897 return 0;
8b82a956
MN
898}
899
8dfc6d1f 900static int svq3_decode_slice_header(AVCodecContext *avctx)
7f8205da 901{
2c541554
AK
902 SVQ3Context *s = avctx->priv_data;
903 H264Context *h = &s->h;
d231e84b 904 H264SliceContext *sl = &h->slice_ctx[0];
1877712c 905 const int mb_xy = s->mb_xy;
76de302d 906 int i, header;
288bb3da 907 unsigned slice_id;
da3b9756 908
1098f5c0 909 header = get_bits(&s->gb, 8);
da3b9756 910
76de302d
DB
911 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
912 /* TODO: what? */
8dfc6d1f 913 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
76de302d
DB
914 return -1;
915 } else {
1098f5c0 916 int slice_bits, slice_bytes, slice_length;
af1ede06 917 int length = header >> 5 & 3;
da3b9756 918
1098f5c0
LB
919 slice_length = show_bits(&s->gb, 8 * length);
920 slice_bits = slice_length * 8;
921 slice_bytes = slice_length + length - 1;
da3b9756 922
1098f5c0 923 if (slice_bytes > get_bits_left(&s->gb)) {
8dfc6d1f 924 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
76de302d 925 return -1;
a7d2861d 926 }
da3b9756 927
1098f5c0
LB
928 skip_bits(&s->gb, 8);
929
930 av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
931 if (!s->slice_buf)
932 return AVERROR(ENOMEM);
933
934 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
935
936 init_get_bits(&h->gb, s->slice_buf, slice_bits);
da3b9756 937
2c541554 938 if (s->watermark_key) {
1098f5c0
LB
939 uint32_t header = AV_RL32(&h->gb.buffer[1]);
940 AV_WL32(&h->gb.buffer[1], header ^ s->watermark_key);
76de302d
DB
941 }
942 if (length > 0) {
1098f5c0 943 memcpy(s->slice_buf, &s->slice_buf[slice_length], length - 1);
76de302d 944 }
1098f5c0 945 skip_bits_long(&s->gb, slice_bytes * 8);
da3b9756 946 }
da3b9756 947
2c541554 948 if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
cc8163e1 949 av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
76de302d
DB
950 return -1;
951 }
da3b9756 952
a7da517f 953 sl->slice_type = ff_h264_golomb_to_pict_type[slice_id];
da3b9756 954
76de302d 955 if ((header & 0x9F) == 2) {
2c541554 956 i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
47a0d393 957 sl->mb_skip_run = get_bits(&h->gb, i) -
1877712c 958 (s->mb_y * h->mb_width + s->mb_x);
76de302d 959 } else {
2c541554 960 skip_bits1(&h->gb);
47a0d393 961 sl->mb_skip_run = 0;
76de302d 962 }
da3b9756 963
56febc99
AK
964 sl->slice_num = get_bits(&h->gb, 8);
965 sl->qscale = get_bits(&h->gb, 5);
2c541554 966 s->adaptive_quant = get_bits1(&h->gb);
da3b9756 967
76de302d 968 /* unknown fields */
2c541554 969 skip_bits1(&h->gb);
da3b9756 970
2c541554
AK
971 if (s->unknown_flag)
972 skip_bits1(&h->gb);
da3b9756 973
2c541554
AK
974 skip_bits1(&h->gb);
975 skip_bits(&h->gb, 2);
da3b9756 976
2c541554
AK
977 while (get_bits1(&h->gb))
978 skip_bits(&h->gb, 8);
da3b9756 979
76de302d 980 /* reset intra predictors and invalidate motion vector references */
1877712c 981 if (s->mb_x > 0) {
7d8154ed 982 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
a7d2861d 983 -1, 4 * sizeof(int8_t));
1877712c
AK
984 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
985 -1, 8 * sizeof(int8_t) * s->mb_x);
76de302d 986 }
1877712c 987 if (s->mb_y > 0) {
7d8154ed 988 memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
1877712c 989 -1, 8 * sizeof(int8_t) * (h->mb_width - s->mb_x));
76de302d 990
1877712c 991 if (s->mb_x > 0)
7d8154ed 992 sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
da3b9756 993 }
da3b9756 994
76de302d 995 return 0;
da3b9756
MM
996}
997
5ef251e5 998static av_cold int svq3_decode_init(AVCodecContext *avctx)
7f8205da 999{
2c541554
AK
1000 SVQ3Context *s = avctx->priv_data;
1001 H264Context *h = &s->h;
07c5ca55 1002 H264SliceContext *sl;
f4cca718 1003 int m;
76de302d 1004 unsigned char *extradata;
9e1db721 1005 unsigned char *extradata_end;
76de302d 1006 unsigned int size;
9e1db721 1007 int marker_found = 0;
76de302d 1008
2c541554
AK
1009 s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1010 s->last_pic = av_mallocz(sizeof(*s->last_pic));
1011 s->next_pic = av_mallocz(sizeof(*s->next_pic));
1012 if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1013 av_freep(&s->cur_pic);
1014 av_freep(&s->last_pic);
1015 av_freep(&s->next_pic);
1016 return AVERROR(ENOMEM);
1017 }
1018
a0f29460
AK
1019 s->cur_pic->f = av_frame_alloc();
1020 s->last_pic->f = av_frame_alloc();
1021 s->next_pic->f = av_frame_alloc();
1022 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1023 return AVERROR(ENOMEM);
1024
903d58f6 1025 if (ff_h264_decode_init(avctx) < 0)
f4cca718
BC
1026 return -1;
1027
a0f29460
AK
1028 // we will overwrite it later during decoding
1029 av_frame_free(&h->cur_pic.f);
1030
c73fb9ef
AK
1031 ff_h264dsp_init(&s->h264dsp, 8, 1);
1032 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1033 ff_videodsp_init(&s->vdsp, 8);
249796e2
AK
1034
1035 memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
1036 memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
1037
1038 h->sps.bit_depth_luma = 8;
1039 h->chroma_format_idc = 1;
1040
2f6bc5f7 1041 ff_hpeldsp_init(&s->hdsp, avctx->flags);
57f09608
DB
1042 ff_tpeldsp_init(&s->tdsp);
1043
07c5ca55
AK
1044 sl = h->slice_ctx;
1045
2c541554 1046 h->flags = avctx->flags;
07c5ca55 1047 sl->is_complex = 1;
2c541554 1048 h->picture_structure = PICT_FRAME;
3795ec68
VG
1049 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1050 avctx->color_range = AVCOL_RANGE_JPEG;
76de302d 1051
d231e84b 1052 h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
2c541554 1053 h->chroma_x_shift = h->chroma_y_shift = 1;
d9ebb00d 1054
2c541554
AK
1055 s->halfpel_flag = 1;
1056 s->thirdpel_flag = 1;
1057 s->unknown_flag = 0;
d9ebb00d
AK
1058
1059 /* prowl for the "SEQH" marker in the extradata */
1060 extradata = (unsigned char *)avctx->extradata;
1061 extradata_end = avctx->extradata + avctx->extradata_size;
1062 if (extradata) {
1063 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1064 if (!memcmp(extradata, "SEQH", 4)) {
1065 marker_found = 1;
1066 break;
9e1db721 1067 }
d9ebb00d 1068 extradata++;
76de302d 1069 }
d9ebb00d 1070 }
8b82a956 1071
d9ebb00d
AK
1072 /* if a match was found, parse the extra data */
1073 if (marker_found) {
1074 GetBitContext gb;
1075 int frame_size_code;
1076
1077 size = AV_RB32(&extradata[4]);
1078 if (size > extradata_end - extradata - 8)
1079 return AVERROR_INVALIDDATA;
1080 init_get_bits(&gb, extradata + 8, size * 8);
1081
1082 /* 'frame size code' and optional 'width, height' */
1083 frame_size_code = get_bits(&gb, 3);
1084 switch (frame_size_code) {
1085 case 0:
1086 avctx->width = 160;
1087 avctx->height = 120;
1088 break;
1089 case 1:
1090 avctx->width = 128;
1091 avctx->height = 96;
1092 break;
1093 case 2:
1094 avctx->width = 176;
1095 avctx->height = 144;
1096 break;
1097 case 3:
1098 avctx->width = 352;
1099 avctx->height = 288;
1100 break;
1101 case 4:
1102 avctx->width = 704;
1103 avctx->height = 576;
1104 break;
1105 case 5:
1106 avctx->width = 240;
1107 avctx->height = 180;
1108 break;
1109 case 6:
1110 avctx->width = 320;
1111 avctx->height = 240;
1112 break;
1113 case 7:
1114 avctx->width = get_bits(&gb, 12);
1115 avctx->height = get_bits(&gb, 12);
1116 break;
1117 }
8b82a956 1118
2c541554
AK
1119 s->halfpel_flag = get_bits1(&gb);
1120 s->thirdpel_flag = get_bits1(&gb);
8b82a956 1121
d9ebb00d
AK
1122 /* unknown fields */
1123 skip_bits1(&gb);
1124 skip_bits1(&gb);
1125 skip_bits1(&gb);
1126 skip_bits1(&gb);
8b82a956 1127
2c541554 1128 h->low_delay = get_bits1(&gb);
1e002b60 1129
d9ebb00d
AK
1130 /* unknown field */
1131 skip_bits1(&gb);
76de302d 1132
d9ebb00d
AK
1133 while (get_bits1(&gb))
1134 skip_bits(&gb, 8);
76de302d 1135
2c541554
AK
1136 s->unknown_flag = get_bits1(&gb);
1137 avctx->has_b_frames = !h->low_delay;
1138 if (s->unknown_flag) {
b250f9c6 1139#if CONFIG_ZLIB
d9ebb00d
AK
1140 unsigned watermark_width = svq3_get_ue_golomb(&gb);
1141 unsigned watermark_height = svq3_get_ue_golomb(&gb);
1142 int u1 = svq3_get_ue_golomb(&gb);
1143 int u2 = get_bits(&gb, 8);
1144 int u3 = get_bits(&gb, 2);
1145 int u4 = svq3_get_ue_golomb(&gb);
1146 unsigned long buf_len = watermark_width *
1147 watermark_height * 4;
1148 int offset = get_bits_count(&gb) + 7 >> 3;
1149 uint8_t *buf;
1150
601c2015
MS
1151 if (watermark_height > 0 &&
1152 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
d9ebb00d 1153 return -1;
76de302d 1154
d9ebb00d 1155 buf = av_malloc(buf_len);
cc8163e1 1156 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
d9ebb00d
AK
1157 watermark_width, watermark_height);
1158 av_log(avctx, AV_LOG_DEBUG,
1159 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1160 u1, u2, u3, u4, offset);
1161 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1162 size - offset) != Z_OK) {
a7d2861d 1163 av_log(avctx, AV_LOG_ERROR,
d9ebb00d
AK
1164 "could not uncompress watermark logo\n");
1165 av_free(buf);
76de302d 1166 return -1;
76de302d 1167 }
2c541554
AK
1168 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1169 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
d9ebb00d 1170 av_log(avctx, AV_LOG_DEBUG,
cc8163e1 1171 "watermark key %#"PRIx32"\n", s->watermark_key);
d9ebb00d
AK
1172 av_free(buf);
1173#else
1174 av_log(avctx, AV_LOG_ERROR,
1175 "this svq3 file contains watermark which need zlib support compiled in\n");
1176 return -1;
1177#endif
76de302d 1178 }
d9ebb00d 1179 }
cdca7c37 1180
2c541554
AK
1181 h->width = avctx->width;
1182 h->height = avctx->height;
1183 h->mb_width = (h->width + 15) / 16;
1184 h->mb_height = (h->height + 15) / 16;
1185 h->mb_stride = h->mb_width + 1;
1186 h->mb_num = h->mb_width * h->mb_height;
1187 h->b_stride = 4 * h->mb_width;
1188 s->h_edge_pos = h->mb_width * 16;
1189 s->v_edge_pos = h->mb_height * 16;
cdca7c37 1190
d9ebb00d
AK
1191 if (ff_h264_alloc_tables(h) < 0) {
1192 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1193 return AVERROR(ENOMEM);
da3b9756 1194 }
76de302d 1195
f4cca718
BC
1196 return 0;
1197}
1198
9b749c82 1199static void free_picture(AVCodecContext *avctx, H264Picture *pic)
759001c5
AK
1200{
1201 int i;
1202 for (i = 0; i < 2; i++) {
1203 av_buffer_unref(&pic->motion_val_buf[i]);
1204 av_buffer_unref(&pic->ref_index_buf[i]);
1205 }
1206 av_buffer_unref(&pic->mb_type_buf);
1207
a0f29460 1208 av_frame_unref(pic->f);
759001c5
AK
1209}
1210
9b749c82 1211static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
2c541554
AK
1212{
1213 SVQ3Context *s = avctx->priv_data;
1214 H264Context *h = &s->h;
36d04801 1215 H264SliceContext *sl = &h->slice_ctx[0];
2c541554
AK
1216 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1217 const int mb_array_size = h->mb_stride * h->mb_height;
1218 const int b4_stride = h->mb_width * 4 + 1;
1219 const int b4_array_size = b4_stride * h->mb_height * 4;
1220 int ret;
1221
759001c5 1222 if (!pic->motion_val_buf[0]) {
2c541554
AK
1223 int i;
1224
759001c5
AK
1225 pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1226 if (!pic->mb_type_buf)
2c541554 1227 return AVERROR(ENOMEM);
759001c5 1228 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
2c541554
AK
1229
1230 for (i = 0; i < 2; i++) {
759001c5
AK
1231 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1232 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1233 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1234 ret = AVERROR(ENOMEM);
1235 goto fail;
1236 }
2c541554 1237
759001c5
AK
1238 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1239 pic->ref_index[i] = pic->ref_index_buf[i]->data;
2c541554
AK
1240 }
1241 }
759001c5
AK
1242 pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1243
a0f29460 1244 ret = ff_get_buffer(avctx, pic->f,
759001c5
AK
1245 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1246 if (ret < 0)
1247 goto fail;
2c541554 1248
36d04801 1249 if (!sl->edge_emu_buffer) {
a0f29460 1250 sl->edge_emu_buffer = av_mallocz(pic->f->linesize[0] * 17);
36d04801 1251 if (!sl->edge_emu_buffer)
fae6fd5b
RB
1252 return AVERROR(ENOMEM);
1253 }
2c541554 1254
a0f29460
AK
1255 sl->linesize = pic->f->linesize[0];
1256 sl->uvlinesize = pic->f->linesize[1];
2c541554 1257
759001c5
AK
1258 return 0;
1259fail:
1260 free_picture(avctx, pic);
2c541554
AK
1261 return ret;
1262}
1263
a7d2861d 1264static int svq3_decode_frame(AVCodecContext *avctx, void *data,
df9b9567 1265 int *got_frame, AVPacket *avpkt)
f4cca718 1266{
7a00bbad 1267 const uint8_t *buf = avpkt->data;
2c541554
AK
1268 SVQ3Context *s = avctx->priv_data;
1269 H264Context *h = &s->h;
e6287f07 1270 H264SliceContext *sl = &h->slice_ctx[0];
a7d2861d 1271 int buf_size = avpkt->size;
2c541554 1272 int ret, m, i;
f4cca718 1273
76de302d
DB
1274 /* special case for last picture */
1275 if (buf_size == 0) {
a0f29460
AK
1276 if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
1277 ret = av_frame_ref(data, s->next_pic->f);
759001c5
AK
1278 if (ret < 0)
1279 return ret;
2c541554 1280 s->last_frame_output = 1;
df9b9567 1281 *got_frame = 1;
76de302d
DB
1282 }
1283 return 0;
da3b9756 1284 }
8b82a956 1285
1098f5c0
LB
1286 ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1287 if (ret < 0)
1288 return ret;
8b82a956 1289
1877712c 1290 s->mb_x = s->mb_y = s->mb_xy = 0;
8b82a956 1291
8dfc6d1f 1292 if (svq3_decode_slice_header(avctx))
76de302d 1293 return -1;
8b82a956 1294
56febc99 1295 h->pict_type = sl->slice_type;
8b82a956 1296
2c541554 1297 if (h->pict_type != AV_PICTURE_TYPE_B)
9b749c82 1298 FFSWAP(H264Picture*, s->next_pic, s->last_pic);
2c541554 1299
a0f29460 1300 av_frame_unref(s->cur_pic->f);
8b82a956 1301
8ed2ae09 1302 /* for skipping the frame */
a0f29460
AK
1303 s->cur_pic->f->pict_type = h->pict_type;
1304 s->cur_pic->f->key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
76de302d 1305
2c541554
AK
1306 ret = get_buffer(avctx, s->cur_pic);
1307 if (ret < 0)
1308 return ret;
1309
1310 h->cur_pic_ptr = s->cur_pic;
1311 h->cur_pic = *s->cur_pic;
1312
1313 for (i = 0; i < 16; i++) {
c28ed1d7
AK
1314 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1315 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1316 }
1317 for (i = 0; i < 16; i++) {
1318 h->block_offset[16 + i] =
c28ed1d7 1319 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554 1320 h->block_offset[48 + 16 + i] =
c28ed1d7 1321 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
2c541554
AK
1322 }
1323
1324 if (h->pict_type != AV_PICTURE_TYPE_I) {
a0f29460 1325 if (!s->last_pic->f->data[0]) {
2c541554
AK
1326 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1327 ret = get_buffer(avctx, s->last_pic);
1328 if (ret < 0)
1329 return ret;
a0f29460
AK
1330 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1331 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1332 s->last_pic->f->linesize[1]);
1333 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1334 s->last_pic->f->linesize[2]);
2c541554
AK
1335 }
1336
a0f29460 1337 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
2c541554
AK
1338 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1339 ret = get_buffer(avctx, s->next_pic);
1340 if (ret < 0)
1341 return ret;
a0f29460
AK
1342 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1343 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1344 s->next_pic->f->linesize[1]);
1345 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1346 s->next_pic->f->linesize[2]);
2c541554
AK
1347 }
1348 }
1349
1350 if (avctx->debug & FF_DEBUG_PICT_INFO)
1351 av_log(h->avctx, AV_LOG_DEBUG,
1352 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1353 av_get_picture_type_char(h->pict_type),
1354 s->halfpel_flag, s->thirdpel_flag,
56febc99 1355 s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
2c541554
AK
1356
1357 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1358 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
af1ede06 1359 avctx->skip_frame >= AVDISCARD_ALL)
76de302d
DB
1360 return 0;
1361
1362 if (s->next_p_frame_damaged) {
2c541554 1363 if (h->pict_type == AV_PICTURE_TYPE_B)
76de302d
DB
1364 return 0;
1365 else
1366 s->next_p_frame_damaged = 0;
1367 }
da3b9756 1368
2c541554 1369 if (h->pict_type == AV_PICTURE_TYPE_B) {
56febc99 1370 h->frame_num_offset = sl->slice_num - h->prev_frame_num;
8b82a956 1371
a7d2861d 1372 if (h->frame_num_offset < 0)
76de302d 1373 h->frame_num_offset += 256;
a7d2861d
DB
1374 if (h->frame_num_offset == 0 ||
1375 h->frame_num_offset >= h->prev_frame_num_offset) {
2c541554 1376 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
76de302d
DB
1377 return -1;
1378 }
1379 } else {
a7d2861d 1380 h->prev_frame_num = h->frame_num;
56febc99 1381 h->frame_num = sl->slice_num;
af1ede06 1382 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
da3b9756 1383
a7d2861d 1384 if (h->prev_frame_num_offset < 0)
76de302d 1385 h->prev_frame_num_offset += 256;
da3b9756 1386 }
da3b9756 1387
a7d2861d 1388 for (m = 0; m < 2; m++) {
76de302d 1389 int i;
a7d2861d 1390 for (i = 0; i < 4; i++) {
76de302d
DB
1391 int j;
1392 for (j = -1; j < 4; j++)
e6287f07 1393 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
76de302d 1394 if (i < 3)
e6287f07 1395 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
76de302d 1396 }
da3b9756 1397 }
da3b9756 1398
1877712c
AK
1399 for (s->mb_y = 0; s->mb_y < h->mb_height; s->mb_y++) {
1400 for (s->mb_x = 0; s->mb_x < h->mb_width; s->mb_x++) {
9a2e7911 1401 unsigned mb_type;
1877712c 1402 s->mb_xy = s->mb_x + s->mb_y * h->mb_stride;
da3b9756 1403
1098f5c0
LB
1404 if ((get_bits_left(&h->gb)) <= 7) {
1405 if (((get_bits_count(&h->gb) & 7) == 0 ||
1406 show_bits(&h->gb, get_bits_left(&h->gb) & 7) == 0)) {
da3b9756 1407
1098f5c0
LB
1408 if (svq3_decode_slice_header(avctx))
1409 return -1;
1410 }
76de302d
DB
1411 /* TODO: support s->mb_skip_run */
1412 }
da3b9756 1413
2c541554 1414 mb_type = svq3_get_ue_golomb(&h->gb);
da3b9756 1415
2c541554 1416 if (h->pict_type == AV_PICTURE_TYPE_I)
76de302d 1417 mb_type += 8;
2c541554 1418 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
76de302d 1419 mb_type += 4;
2c541554
AK
1420 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1421 av_log(h->avctx, AV_LOG_ERROR,
1877712c 1422 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
76de302d
DB
1423 return -1;
1424 }
8b82a956 1425
a7d2861d 1426 if (mb_type != 0)
c73fb9ef 1427 hl_decode_mb(s, h, &h->slice_ctx[0]);
8b82a956 1428
2c541554 1429 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1877712c 1430 h->cur_pic.mb_type[s->mb_x + s->mb_y * h->mb_stride] =
2c541554 1431 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
76de302d 1432 }
2e26c8d2 1433
a0f29460
AK
1434 ff_draw_horiz_band(avctx, s->cur_pic->f,
1435 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1877712c 1436 16 * s->mb_y, 16, h->picture_structure, 0,
54b2ce74 1437 h->low_delay);
8b82a956 1438 }
4c701ac8 1439
2c541554 1440 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
a0f29460
AK
1441 ret = av_frame_ref(data, s->cur_pic->f);
1442 else if (s->last_pic->f->data[0])
1443 ret = av_frame_ref(data, s->last_pic->f);
759001c5
AK
1444 if (ret < 0)
1445 return ret;
da3b9756 1446
76de302d 1447 /* Do not output the last pic after seeking. */
a0f29460 1448 if (s->last_pic->f->data[0] || h->low_delay)
df9b9567 1449 *got_frame = 1;
da3b9756 1450
2c541554 1451 if (h->pict_type != AV_PICTURE_TYPE_B) {
9b749c82 1452 FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
759001c5 1453 } else {
a0f29460 1454 av_frame_unref(s->cur_pic->f);
2c541554
AK
1455 }
1456
76de302d 1457 return buf_size;
8b82a956
MN
1458}
1459
bd8ac882 1460static av_cold int svq3_decode_end(AVCodecContext *avctx)
8dfc6d1f 1461{
2c541554
AK
1462 SVQ3Context *s = avctx->priv_data;
1463 H264Context *h = &s->h;
8dfc6d1f 1464
2c541554
AK
1465 free_picture(avctx, s->cur_pic);
1466 free_picture(avctx, s->next_pic);
1467 free_picture(avctx, s->last_pic);
a0f29460
AK
1468 av_frame_free(&s->cur_pic->f);
1469 av_frame_free(&s->next_pic->f);
1470 av_frame_free(&s->last_pic->f);
759001c5
AK
1471 av_freep(&s->cur_pic);
1472 av_freep(&s->next_pic);
1473 av_freep(&s->last_pic);
1098f5c0 1474 av_freep(&s->slice_buf);
759001c5 1475
a0f29460 1476 memset(&h->cur_pic, 0, sizeof(h->cur_pic));
8dfc6d1f 1477
2c541554 1478 ff_h264_free_context(h);
8dfc6d1f
BC
1479
1480 return 0;
1481}
8b82a956 1482
d36beb3f 1483AVCodec ff_svq3_decoder = {
ec6402b7 1484 .name = "svq3",
b2bed932 1485 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
ec6402b7 1486 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 1487 .id = AV_CODEC_ID_SVQ3,
ec6402b7
AK
1488 .priv_data_size = sizeof(SVQ3Context),
1489 .init = svq3_decode_init,
1490 .close = svq3_decode_end,
1491 .decode = svq3_decode_frame,
def97856
VG
1492 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1493 AV_CODEC_CAP_DR1 |
1494 AV_CODEC_CAP_DELAY,
a7d2861d
DB
1495 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1496 AV_PIX_FMT_NONE},
8b82a956 1497};