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