svq3: rip out the svq3-relevant parts of pred_motion() out of h264
[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;
8dfc6d1f
BC
108} SVQ3Context;
109
115329f1
DB
110#define FULLPEL_MODE 1
111#define HALFPEL_MODE 2
94d44f45 112#define THIRDPEL_MODE 3
2e26c8d2 113#define PREDICT_MODE 4
115329f1 114
f7a8c179 115/* dual scan (from some older h264 draft)
a7d2861d
DB
116 * o-->o-->o o
117 * | /|
118 * o o o / o
119 * | / | |/ |
120 * o o o o
121 * /
122 * o-->o-->o-->o
123 */
76de302d 124static const uint8_t svq3_scan[16] = {
a7d2861d
DB
125 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
126 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
127 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
128 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
8b82a956
MN
129};
130
c4e43560
DB
131static const uint8_t luma_dc_zigzag_scan[16] = {
132 0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
133 3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
134 1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
135 3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
136};
137
8b82a956 138static const uint8_t svq3_pred_0[25][2] = {
76de302d
DB
139 { 0, 0 },
140 { 1, 0 }, { 0, 1 },
141 { 0, 2 }, { 1, 1 }, { 2, 0 },
142 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
143 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
144 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
145 { 2, 4 }, { 3, 3 }, { 4, 2 },
146 { 4, 3 }, { 3, 4 },
147 { 4, 4 }
8b82a956
MN
148};
149
150static const int8_t svq3_pred_1[6][6][5] = {
a7d2861d
DB
151 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
152 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
153 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
154 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
155 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
156 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
157 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
158 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
159 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
160 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
161 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
162 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
8b82a956
MN
163};
164
a7d2861d
DB
165static const struct {
166 uint8_t run;
167 uint8_t level;
168} svq3_dct_tables[2][16] = {
76de302d
DB
169 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
170 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
171 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
172 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
8b82a956
MN
173};
174
175static const uint32_t svq3_dequant_coeff[32] = {
a7d2861d
DB
176 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
177 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
178 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
179 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
8b82a956
MN
180};
181
15b0517d 182static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
a7d2861d 183{
76de302d 184 const int qmul = svq3_dequant_coeff[qp];
8b82a956
MN
185#define stride 16
186 int i;
187 int temp[16];
a7d2861d
DB
188 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
189
190 for (i = 0; i < 4; i++) {
191 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
192 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
193 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
194 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
195
196 temp[4 * i + 0] = z0 + z3;
197 temp[4 * i + 1] = z1 + z2;
198 temp[4 * i + 2] = z1 - z2;
199 temp[4 * i + 3] = z0 - z3;
8b82a956
MN
200 }
201
a7d2861d
DB
202 for (i = 0; i < 4; i++) {
203 const int offset = x_offset[i];
204 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
205 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
206 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
207 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
208
af1ede06
DB
209 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
210 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
211 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
212 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
8b82a956
MN
213 }
214}
215#undef stride
216
15b0517d
AK
217static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
218 int stride, int qp, int dc)
7f8205da 219{
76de302d 220 const int qmul = svq3_dequant_coeff[qp];
8b82a956 221 int i;
8b82a956
MN
222
223 if (dc) {
af1ede06
DB
224 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
225 : qmul * (block[0] >> 3) / 2);
8b82a956
MN
226 block[0] = 0;
227 }
228
76de302d 229 for (i = 0; i < 4; i++) {
a7d2861d
DB
230 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
231 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
232 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
233 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
234
235 block[0 + 4 * i] = z0 + z3;
236 block[1 + 4 * i] = z1 + z2;
237 block[2 + 4 * i] = z1 - z2;
238 block[3 + 4 * i] = z0 - z3;
8b82a956
MN
239 }
240
76de302d 241 for (i = 0; i < 4; i++) {
a7d2861d
DB
242 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
243 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
244 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
245 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
76de302d
DB
246 const int rr = (dc + 0x80000);
247
af1ede06
DB
248 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
249 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
250 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
251 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
8b82a956 252 }
62844c3f
RB
253
254 memset(block, 0, 16 * sizeof(int16_t));
8b82a956
MN
255}
256
88bd7fdc 257static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
7f8205da
DB
258 int index, const int type)
259{
f4d581cd 260 static const uint8_t *const scan_patterns[4] = {
a7da517f 261 luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
f4d581cd 262 };
8b82a956 263
9a2e7911
JG
264 int run, level, limit;
265 unsigned vlc;
af1ede06 266 const int intra = 3 * type >> 2;
76de302d 267 const uint8_t *const scan = scan_patterns[type];
8b82a956 268
76de302d
DB
269 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
270 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
9a2e7911
JG
271 int sign = (vlc & 1) ? 0 : -1;
272 vlc = vlc + 1 >> 1;
a7d2861d
DB
273
274 if (type == 3) {
275 if (vlc < 3) {
276 run = 0;
277 level = vlc;
278 } else if (vlc < 4) {
279 run = 1;
280 level = 1;
281 } else {
af1ede06
DB
282 run = vlc & 0x3;
283 level = (vlc + 9 >> 2) - run;
a7d2861d
DB
284 }
285 } else {
286 if (vlc < 16) {
287 run = svq3_dct_tables[intra][vlc].run;
288 level = svq3_dct_tables[intra][vlc].level;
289 } else if (intra) {
af1ede06 290 run = vlc & 0x7;
a7d2861d
DB
291 level = (vlc >> 3) +
292 ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
293 } else {
af1ede06 294 run = vlc & 0xF;
a7d2861d
DB
295 level = (vlc >> 4) +
296 ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
297 }
298 }
8b82a956 299
a7d2861d
DB
300 if ((index += run) >= limit)
301 return -1;
302
303 block[scan[index]] = (level ^ sign) - sign;
76de302d 304 }
8b82a956 305
76de302d
DB
306 if (type != 2) {
307 break;
308 }
8b82a956 309 }
8b82a956 310
76de302d 311 return 0;
8b82a956
MN
312}
313
89a13998
AK
314static av_always_inline int
315svq3_fetch_diagonal_mv(const H264Context *h, H264SliceContext *sl,
316 const int16_t **C,
317 int i, int list, int part_width)
318{
319 const int topright_ref = sl->ref_cache[list][i - 8 + part_width];
320
321 if (topright_ref != PART_NOT_AVAILABLE) {
322 *C = sl->mv_cache[list][i - 8 + part_width];
323 return topright_ref;
324 } else {
325 *C = sl->mv_cache[list][i - 8 - 1];
326 return sl->ref_cache[list][i - 8 - 1];
327 }
328}
329
330/**
331 * Get the predicted MV.
332 * @param n the block index
333 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
334 * @param mx the x component of the predicted motion vector
335 * @param my the y component of the predicted motion vector
336 */
337static av_always_inline void svq3_pred_motion(const H264Context *const h,
338 H264SliceContext *sl, int n,
339 int part_width, int list,
340 int ref, int *const mx, int *const my)
341{
342 const int index8 = scan8[n];
343 const int top_ref = sl->ref_cache[list][index8 - 8];
344 const int left_ref = sl->ref_cache[list][index8 - 1];
345 const int16_t *const A = sl->mv_cache[list][index8 - 1];
346 const int16_t *const B = sl->mv_cache[list][index8 - 8];
347 const int16_t *C;
348 int diagonal_ref, match_count;
349
350/* mv_cache
351 * B . . A T T T T
352 * U . . L . . , .
353 * U . . L . . . .
354 * U . . L . . , .
355 * . . . L . . . .
356 */
357
358 diagonal_ref = svq3_fetch_diagonal_mv(h, sl, &C, index8, list, part_width);
359 match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
360 if (match_count > 1) { //most common
361 *mx = mid_pred(A[0], B[0], C[0]);
362 *my = mid_pred(A[1], B[1], C[1]);
363 } else if (match_count == 1) {
364 if (left_ref == ref) {
365 *mx = A[0];
366 *my = A[1];
367 } else if (top_ref == ref) {
368 *mx = B[0];
369 *my = B[1];
370 } else {
371 *mx = C[0];
372 *my = C[1];
373 }
374 } else {
375 if (top_ref == PART_NOT_AVAILABLE &&
376 diagonal_ref == PART_NOT_AVAILABLE &&
377 left_ref != PART_NOT_AVAILABLE) {
378 *mx = A[0];
379 *my = A[1];
380 } else {
381 *mx = mid_pred(A[0], B[0], C[0]);
382 *my = mid_pred(A[1], B[1], C[1]);
383 }
384 }
385}
386
2c541554 387static inline void svq3_mc_dir_part(SVQ3Context *s,
7f8205da
DB
388 int x, int y, int width, int height,
389 int mx, int my, int dxy,
390 int thirdpel, int dir, int avg)
391{
9b749c82 392 H264Context *h = &s->h;
36d04801 393 H264SliceContext *sl = &h->slice_ctx[0];
9b749c82 394 const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
76de302d
DB
395 uint8_t *src, *dest;
396 int i, emu = 0;
a7d2861d 397 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
76de302d
DB
398
399 mx += x;
400 my += y;
8b82a956 401
af1ede06
DB
402 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
403 my < 0 || my >= s->v_edge_pos - height - 1) {
fae6fd5b 404 emu = 1;
af1ede06
DB
405 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
406 my = av_clip(my, -16, s->v_edge_pos - height + 15);
8b82a956
MN
407 }
408
76de302d 409 /* form component predictions */
a0f29460
AK
410 dest = h->cur_pic.f->data[0] + x + y * sl->linesize;
411 src = pic->f->data[0] + mx + my * sl->linesize;
76de302d
DB
412
413 if (emu) {
8eecae77 414 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
c28ed1d7 415 sl->linesize, sl->linesize,
8c53d39e
RB
416 width + 1, height + 1,
417 mx, my, s->h_edge_pos, s->v_edge_pos);
8eecae77 418 src = s->edge_emu_buffer;
8b82a956 419 }
76de302d 420 if (thirdpel)
57f09608 421 (avg ? s->tdsp.avg_tpel_pixels_tab
c28ed1d7 422 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, sl->linesize,
57f09608 423 width, height);
76de302d 424 else
2f6bc5f7 425 (avg ? s->hdsp.avg_pixels_tab
c28ed1d7 426 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, sl->linesize,
2f6bc5f7 427 height);
76de302d 428
7c6eb0a1 429 if (!(h->flags & AV_CODEC_FLAG_GRAY)) {
af1ede06
DB
430 mx = mx + (mx < (int) x) >> 1;
431 my = my + (my < (int) y) >> 1;
432 width = width >> 1;
433 height = height >> 1;
76de302d
DB
434 blocksize++;
435
436 for (i = 1; i < 3; i++) {
a0f29460
AK
437 dest = h->cur_pic.f->data[i] + (x >> 1) + (y >> 1) * sl->uvlinesize;
438 src = pic->f->data[i] + mx + my * sl->uvlinesize;
76de302d
DB
439
440 if (emu) {
8eecae77 441 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
c28ed1d7 442 sl->uvlinesize, sl->uvlinesize,
8c53d39e
RB
443 width + 1, height + 1,
444 mx, my, (s->h_edge_pos >> 1),
445 s->v_edge_pos >> 1);
8eecae77 446 src = s->edge_emu_buffer;
76de302d
DB
447 }
448 if (thirdpel)
57f09608
DB
449 (avg ? s->tdsp.avg_tpel_pixels_tab
450 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
c28ed1d7 451 sl->uvlinesize,
57f09608 452 width, height);
76de302d 453 else
2f6bc5f7
RB
454 (avg ? s->hdsp.avg_pixels_tab
455 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
c28ed1d7 456 sl->uvlinesize,
2f6bc5f7 457 height);
76de302d
DB
458 }
459 }
8b82a956
MN
460}
461
2c541554 462static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
a7d2861d 463 int dir, int avg)
7f8205da 464{
76de302d 465 int i, j, k, mx, my, dx, dy, x, y;
2c541554 466 H264Context *h = &s->h;
8b00f4df 467 H264SliceContext *sl = &h->slice_ctx[0];
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) {
89a13998 485 svq3_pred_motion(h, sl, 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) {
e6287f07 557 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 * 8], mv);
76de302d 558
a7d2861d 559 if (part_width == 8 && j < 8)
e6287f07 560 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
76de302d 561 }
a7d2861d 562 if (part_width == 8 && j < 8)
e6287f07 563 AV_WN32A(sl->mv_cache[dir][scan8[k] + 1], mv);
a7d2861d 564 if (part_width == 4 || part_height == 4)
e6287f07 565 AV_WN32A(sl->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++)
e6287f07 744 AV_COPY32(sl->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++)
e6287f07 748 AV_ZERO32(sl->mv_cache[m][scan8[0] - 1 + i * 8]);
76de302d 749 }
1877712c 750 if (s->mb_y > 0) {
e6287f07 751 memcpy(sl->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));
e6287f07 754 memset(&sl->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) {
e6287f07 758 AV_COPY32(sl->mv_cache[m][scan8[0] + 4 - 1 * 8],
759001c5 759 h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
e6287f07 760 sl->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
e6287f07 764 sl->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
1877712c 765 if (s->mb_x > 0) {
e6287f07 766 AV_COPY32(sl->mv_cache[m][scan8[0] - 1 - 1 * 8],
759001c5 767 h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
e6287f07 768 sl->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
e6287f07 771 sl->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
a7d2861d 772 } else
e6287f07 773 memset(&sl->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++)
e6287f07 1486 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
76de302d 1487 if (i < 3)
e6287f07 1488 sl->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};