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