mpegvideo: directly use frames in ff_draw_horiz_band()
[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
DB
42
43#include "libavutil/attributes.h"
903d58f6 44#include "internal.h"
903d58f6
MN
45#include "avcodec.h"
46#include "mpegvideo.h"
47#include "h264.h"
48
a7d2861d 49#include "h264data.h" // FIXME FIXME FIXME
903d58f6 50
188d3c51 51#include "h264_mvpred.h"
903d58f6 52#include "golomb.h"
2f6bc5f7 53#include "hpeldsp.h"
903d58f6 54#include "rectangle.h"
903d58f6 55
b250f9c6 56#if CONFIG_ZLIB
c4864924
BC
57#include <zlib.h>
58#endif
59
2be3fe39 60#include "svq1.h"
75d5156a 61#include "svq3.h"
2be3fe39 62
8b82a956 63/**
ba87f080 64 * @file
8b82a956
MN
65 * svq3 decoder.
66 */
67
8dfc6d1f
BC
68typedef struct {
69 H264Context h;
2f6bc5f7 70 HpelDSPContext hdsp;
2c541554
AK
71 Picture *cur_pic;
72 Picture *next_pic;
73 Picture *last_pic;
8dfc6d1f
BC
74 int halfpel_flag;
75 int thirdpel_flag;
76 int unknown_flag;
77 int next_slice_index;
78 uint32_t watermark_key;
2c541554
AK
79 int adaptive_quant;
80 int next_p_frame_damaged;
81 int h_edge_pos;
82 int v_edge_pos;
83 int last_frame_output;
8dfc6d1f
BC
84} SVQ3Context;
85
115329f1
DB
86#define FULLPEL_MODE 1
87#define HALFPEL_MODE 2
94d44f45 88#define THIRDPEL_MODE 3
2e26c8d2 89#define PREDICT_MODE 4
115329f1 90
f7a8c179 91/* dual scan (from some older h264 draft)
a7d2861d
DB
92 * o-->o-->o o
93 * | /|
94 * o o o / o
95 * | / | |/ |
96 * o o o o
97 * /
98 * o-->o-->o-->o
99 */
76de302d 100static const uint8_t svq3_scan[16] = {
a7d2861d
DB
101 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
102 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
103 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
104 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
8b82a956
MN
105};
106
c4e43560
DB
107static const uint8_t luma_dc_zigzag_scan[16] = {
108 0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
109 3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
110 1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
111 3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
112};
113
8b82a956 114static const uint8_t svq3_pred_0[25][2] = {
76de302d
DB
115 { 0, 0 },
116 { 1, 0 }, { 0, 1 },
117 { 0, 2 }, { 1, 1 }, { 2, 0 },
118 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
119 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
120 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
121 { 2, 4 }, { 3, 3 }, { 4, 2 },
122 { 4, 3 }, { 3, 4 },
123 { 4, 4 }
8b82a956
MN
124};
125
126static const int8_t svq3_pred_1[6][6][5] = {
a7d2861d
DB
127 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
128 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
129 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
130 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
131 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
132 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
133 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
134 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
135 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
136 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
137 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
138 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
8b82a956
MN
139};
140
a7d2861d
DB
141static const struct {
142 uint8_t run;
143 uint8_t level;
144} svq3_dct_tables[2][16] = {
76de302d
DB
145 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
146 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
147 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
148 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
8b82a956
MN
149};
150
151static const uint32_t svq3_dequant_coeff[32] = {
a7d2861d
DB
152 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
153 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
154 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
155 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
8b82a956
MN
156};
157
88bd7fdc 158void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
a7d2861d 159{
76de302d 160 const int qmul = svq3_dequant_coeff[qp];
8b82a956
MN
161#define stride 16
162 int i;
163 int temp[16];
a7d2861d
DB
164 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
165
166 for (i = 0; i < 4; i++) {
167 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
168 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
169 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
170 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
171
172 temp[4 * i + 0] = z0 + z3;
173 temp[4 * i + 1] = z1 + z2;
174 temp[4 * i + 2] = z1 - z2;
175 temp[4 * i + 3] = z0 - z3;
8b82a956
MN
176 }
177
a7d2861d
DB
178 for (i = 0; i < 4; i++) {
179 const int offset = x_offset[i];
180 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
181 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
182 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
183 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
184
af1ede06
DB
185 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
186 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
187 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
188 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
8b82a956
MN
189 }
190}
191#undef stride
192
88bd7fdc 193void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
a7d2861d 194 int stride, int qp, int dc)
7f8205da 195{
76de302d 196 const int qmul = svq3_dequant_coeff[qp];
8b82a956 197 int i;
8b82a956
MN
198
199 if (dc) {
af1ede06
DB
200 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
201 : qmul * (block[0] >> 3) / 2);
8b82a956
MN
202 block[0] = 0;
203 }
204
76de302d 205 for (i = 0; i < 4; i++) {
a7d2861d
DB
206 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
207 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
208 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
209 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
210
211 block[0 + 4 * i] = z0 + z3;
212 block[1 + 4 * i] = z1 + z2;
213 block[2 + 4 * i] = z1 - z2;
214 block[3 + 4 * i] = z0 - z3;
8b82a956
MN
215 }
216
76de302d 217 for (i = 0; i < 4; i++) {
a7d2861d
DB
218 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
219 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
220 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
221 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
76de302d
DB
222 const int rr = (dc + 0x80000);
223
af1ede06
DB
224 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
225 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
226 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
227 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
8b82a956 228 }
62844c3f
RB
229
230 memset(block, 0, 16 * sizeof(int16_t));
8b82a956
MN
231}
232
88bd7fdc 233static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
7f8205da
DB
234 int index, const int type)
235{
76de302d
DB
236 static const uint8_t *const scan_patterns[4] =
237 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
8b82a956 238
9a2e7911
JG
239 int run, level, limit;
240 unsigned vlc;
af1ede06 241 const int intra = 3 * type >> 2;
76de302d 242 const uint8_t *const scan = scan_patterns[type];
8b82a956 243
76de302d
DB
244 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
245 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
9a2e7911
JG
246 int sign = (vlc & 1) ? 0 : -1;
247 vlc = vlc + 1 >> 1;
a7d2861d
DB
248
249 if (type == 3) {
250 if (vlc < 3) {
251 run = 0;
252 level = vlc;
253 } else if (vlc < 4) {
254 run = 1;
255 level = 1;
256 } else {
af1ede06
DB
257 run = vlc & 0x3;
258 level = (vlc + 9 >> 2) - run;
a7d2861d
DB
259 }
260 } else {
261 if (vlc < 16) {
262 run = svq3_dct_tables[intra][vlc].run;
263 level = svq3_dct_tables[intra][vlc].level;
264 } else if (intra) {
af1ede06 265 run = vlc & 0x7;
a7d2861d
DB
266 level = (vlc >> 3) +
267 ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
268 } else {
af1ede06 269 run = vlc & 0xF;
a7d2861d
DB
270 level = (vlc >> 4) +
271 ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
272 }
273 }
8b82a956 274
a7d2861d
DB
275 if ((index += run) >= limit)
276 return -1;
277
278 block[scan[index]] = (level ^ sign) - sign;
76de302d 279 }
8b82a956 280
76de302d
DB
281 if (type != 2) {
282 break;
283 }
8b82a956 284 }
8b82a956 285
76de302d 286 return 0;
8b82a956
MN
287}
288
2c541554 289static inline void svq3_mc_dir_part(SVQ3Context *s,
7f8205da
DB
290 int x, int y, int width, int height,
291 int mx, int my, int dxy,
292 int thirdpel, int dir, int avg)
293{
2c541554
AK
294 H264Context *h = &s->h;
295 const Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
76de302d
DB
296 uint8_t *src, *dest;
297 int i, emu = 0;
a7d2861d 298 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
76de302d
DB
299
300 mx += x;
301 my += y;
8b82a956 302
af1ede06
DB
303 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
304 my < 0 || my >= s->v_edge_pos - height - 1) {
fae6fd5b 305 emu = 1;
af1ede06
DB
306 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
307 my = av_clip(my, -16, s->v_edge_pos - height + 15);
8b82a956
MN
308 }
309
76de302d 310 /* form component predictions */
2c541554
AK
311 dest = h->cur_pic.f.data[0] + x + y * h->linesize;
312 src = pic->f.data[0] + mx + my * h->linesize;
76de302d
DB
313
314 if (emu) {
458446ac
RB
315 h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src,
316 h->linesize, h->linesize,
8c53d39e
RB
317 width + 1, height + 1,
318 mx, my, s->h_edge_pos, s->v_edge_pos);
2c541554 319 src = h->edge_emu_buffer;
8b82a956 320 }
76de302d 321 if (thirdpel)
2c541554
AK
322 (avg ? h->dsp.avg_tpel_pixels_tab
323 : h->dsp.put_tpel_pixels_tab)[dxy](dest, src, h->linesize,
a7d2861d 324 width, height);
76de302d 325 else
2f6bc5f7
RB
326 (avg ? s->hdsp.avg_pixels_tab
327 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, h->linesize,
328 height);
76de302d 329
2c541554 330 if (!(h->flags & CODEC_FLAG_GRAY)) {
af1ede06
DB
331 mx = mx + (mx < (int) x) >> 1;
332 my = my + (my < (int) y) >> 1;
333 width = width >> 1;
334 height = height >> 1;
76de302d
DB
335 blocksize++;
336
337 for (i = 1; i < 3; i++) {
2c541554
AK
338 dest = h->cur_pic.f.data[i] + (x >> 1) + (y >> 1) * h->uvlinesize;
339 src = pic->f.data[i] + mx + my * h->uvlinesize;
76de302d
DB
340
341 if (emu) {
458446ac
RB
342 h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src,
343 h->uvlinesize, h->uvlinesize,
8c53d39e
RB
344 width + 1, height + 1,
345 mx, my, (s->h_edge_pos >> 1),
346 s->v_edge_pos >> 1);
2c541554 347 src = h->edge_emu_buffer;
76de302d
DB
348 }
349 if (thirdpel)
2c541554
AK
350 (avg ? h->dsp.avg_tpel_pixels_tab
351 : h->dsp.put_tpel_pixels_tab)[dxy](dest, src,
352 h->uvlinesize,
a7d2861d 353 width, height);
76de302d 354 else
2f6bc5f7
RB
355 (avg ? s->hdsp.avg_pixels_tab
356 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
357 h->uvlinesize,
358 height);
76de302d
DB
359 }
360 }
8b82a956
MN
361}
362
2c541554 363static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
a7d2861d 364 int dir, int avg)
7f8205da 365{
76de302d 366 int i, j, k, mx, my, dx, dy, x, y;
2c541554 367 H264Context *h = &s->h;
a7d2861d
DB
368 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
369 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
370 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
371 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
372 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
373
374 for (i = 0; i < 16; i += part_height)
76de302d 375 for (j = 0; j < 16; j += part_width) {
2c541554
AK
376 const int b_xy = (4 * h->mb_x + (j >> 2)) +
377 (4 * h->mb_y + (i >> 2)) * h->b_stride;
76de302d 378 int dxy;
2c541554
AK
379 x = 16 * h->mb_x + j;
380 y = 16 * h->mb_y + i;
af1ede06
DB
381 k = (j >> 2 & 1) + (i >> 1 & 2) +
382 (j >> 1 & 4) + (i & 8);
76de302d
DB
383
384 if (mode != PREDICT_MODE) {
af1ede06 385 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
76de302d 386 } else {
759001c5
AK
387 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
388 my = s->next_pic->motion_val[0][b_xy][1] << 1;
76de302d
DB
389
390 if (dir == 0) {
af1ede06
DB
391 mx = mx * h->frame_num_offset /
392 h->prev_frame_num_offset + 1 >> 1;
393 my = my * h->frame_num_offset /
394 h->prev_frame_num_offset + 1 >> 1;
76de302d 395 } else {
af1ede06
DB
396 mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
397 h->prev_frame_num_offset + 1 >> 1;
398 my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
399 h->prev_frame_num_offset + 1 >> 1;
76de302d
DB
400 }
401 }
402
403 /* clip motion vector prediction to frame border */
a7d2861d
DB
404 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
405 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
76de302d
DB
406
407 /* get (optional) motion vector differential */
408 if (mode == PREDICT_MODE) {
409 dx = dy = 0;
410 } else {
2c541554
AK
411 dy = svq3_get_se_golomb(&h->gb);
412 dx = svq3_get_se_golomb(&h->gb);
76de302d
DB
413
414 if (dx == INVALID_VLC || dy == INVALID_VLC) {
2c541554 415 av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
76de302d
DB
416 return -1;
417 }
418 }
419
420 /* compute motion vector */
421 if (mode == THIRDPEL_MODE) {
422 int fx, fy;
af1ede06
DB
423 mx = (mx + 1 >> 1) + dx;
424 my = (my + 1 >> 1) + dy;
425 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
426 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
a7d2861d
DB
427 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
428
429 svq3_mc_dir_part(s, x, y, part_width, part_height,
430 fx, fy, dxy, 1, dir, avg);
76de302d
DB
431 mx += mx;
432 my += my;
433 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
af1ede06
DB
434 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
435 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
a7d2861d 436 dxy = (mx & 1) + 2 * (my & 1);
76de302d 437
a7d2861d
DB
438 svq3_mc_dir_part(s, x, y, part_width, part_height,
439 mx >> 1, my >> 1, dxy, 0, dir, avg);
76de302d
DB
440 mx *= 3;
441 my *= 3;
442 } else {
af1ede06
DB
443 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
444 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
76de302d 445
a7d2861d
DB
446 svq3_mc_dir_part(s, x, y, part_width, part_height,
447 mx, my, 0, 0, dir, avg);
76de302d
DB
448 mx *= 6;
449 my *= 6;
450 }
451
452 /* update mv_cache */
453 if (mode != PREDICT_MODE) {
a7d2861d 454 int32_t mv = pack16to32(mx, my);
76de302d
DB
455
456 if (part_height == 8 && i < 8) {
a7d2861d 457 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
76de302d 458
a7d2861d
DB
459 if (part_width == 8 && j < 8)
460 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
76de302d 461 }
a7d2861d 462 if (part_width == 8 && j < 8)
366b72f1 463 AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
a7d2861d 464 if (part_width == 4 || part_height == 4)
366b72f1 465 AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
76de302d
DB
466 }
467
468 /* write back motion vectors */
759001c5 469 fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
657ccb5a
DB
470 part_width >> 2, part_height >> 2, h->b_stride,
471 pack16to32(mx, my), 4);
bb270c08 472 }
2e26c8d2 473
76de302d 474 return 0;
2e26c8d2
MM
475}
476
2c541554 477static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
7f8205da 478{
2c541554 479 H264Context *h = &s->h;
76de302d
DB
480 int i, j, k, m, dir, mode;
481 int cbp = 0;
482 uint32_t vlc;
483 int8_t *top, *left;
a7d2861d 484 const int mb_xy = h->mb_xy;
2c541554 485 const int b_xy = 4 * h->mb_x + 4 * h->mb_y * h->b_stride;
76de302d 486
2c541554
AK
487 h->top_samples_available = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
488 h->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
76de302d
DB
489 h->topright_samples_available = 0xFFFF;
490
491 if (mb_type == 0) { /* SKIP */
2c541554 492 if (h->pict_type == AV_PICTURE_TYPE_P ||
759001c5 493 s->next_pic->mb_type[mb_xy] == -1) {
2c541554 494 svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
a7d2861d 495 0, 0, 0, 0, 0, 0);
76de302d 496
2c541554
AK
497 if (h->pict_type == AV_PICTURE_TYPE_B)
498 svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
a7d2861d 499 0, 0, 0, 0, 1, 1);
76de302d
DB
500
501 mb_type = MB_TYPE_SKIP;
502 } else {
759001c5 503 mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
2c541554 504 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
76de302d 505 return -1;
2c541554 506 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
76de302d 507 return -1;
8b82a956 508
76de302d 509 mb_type = MB_TYPE_16x16;
bb270c08 510 }
76de302d 511 } else if (mb_type < 8) { /* INTER */
2c541554 512 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
76de302d 513 mode = THIRDPEL_MODE;
2c541554
AK
514 else if (s->halfpel_flag &&
515 s->thirdpel_flag == !get_bits1(&h->gb))
76de302d 516 mode = HALFPEL_MODE;
a7d2861d 517 else
76de302d 518 mode = FULLPEL_MODE;
8b82a956 519
76de302d
DB
520 /* fill caches */
521 /* note ref_cache should contain here:
a7d2861d
DB
522 * ????????
523 * ???11111
524 * N??11111
525 * N??11111
526 * N??11111
527 */
76de302d
DB
528
529 for (m = 0; m < 2; m++) {
2c541554 530 if (h->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
a7d2861d
DB
531 for (i = 0; i < 4; i++)
532 AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
759001c5 533 h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
76de302d 534 } else {
a7d2861d
DB
535 for (i = 0; i < 4; i++)
536 AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
76de302d 537 }
2c541554 538 if (h->mb_y > 0) {
a7d2861d 539 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
759001c5 540 h->cur_pic.motion_val[m][b_xy - h->b_stride],
a7d2861d
DB
541 4 * 2 * sizeof(int16_t));
542 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
2c541554 543 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
76de302d 544
2c541554 545 if (h->mb_x < h->mb_width - 1) {
a7d2861d 546 AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
759001c5 547 h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
a7d2861d 548 h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
2c541554
AK
549 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
550 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
a7d2861d
DB
551 } else
552 h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
2c541554 553 if (h->mb_x > 0) {
a7d2861d 554 AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
759001c5 555 h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
a7d2861d 556 h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
2c541554 557 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
a7d2861d
DB
558 } else
559 h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
560 } else
561 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
562 PART_NOT_AVAILABLE, 8);
76de302d 563
2c541554 564 if (h->pict_type != AV_PICTURE_TYPE_B)
76de302d 565 break;
bb270c08 566 }
8b82a956 567
76de302d 568 /* decode motion vector(s) and form prediction(s) */
2c541554
AK
569 if (h->pict_type == AV_PICTURE_TYPE_P) {
570 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
76de302d 571 return -1;
975a1447 572 } else { /* AV_PICTURE_TYPE_B */
7f3624dc 573 if (mb_type != 2) {
2c541554 574 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
76de302d 575 return -1;
7f3624dc 576 } else {
a7d2861d 577 for (i = 0; i < 4; i++)
759001c5 578 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
a7d2861d 579 0, 4 * 2 * sizeof(int16_t));
7f3624dc
MH
580 }
581 if (mb_type != 1) {
2c541554 582 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
76de302d 583 return -1;
7f3624dc 584 } else {
a7d2861d 585 for (i = 0; i < 4; i++)
759001c5 586 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
a7d2861d 587 0, 4 * 2 * sizeof(int16_t));
7f3624dc 588 }
bb270c08 589 }
8b82a956 590
76de302d
DB
591 mb_type = MB_TYPE_16x16;
592 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
a7d2861d 593 memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
76de302d
DB
594
595 if (mb_type == 8) {
2c541554 596 if (h->mb_x > 0) {
a7d2861d
DB
597 for (i = 0; i < 4; i++)
598 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
599 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
76de302d 600 h->left_samples_available = 0x5F5F;
76de302d 601 }
2c541554
AK
602 if (h->mb_y > 0) {
603 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
604 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
605 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
606 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
76de302d 607
a7d2861d 608 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
76de302d 609 h->top_samples_available = 0x33FF;
76de302d
DB
610 }
611
612 /* decode prediction codes for luma blocks */
a7d2861d 613 for (i = 0; i < 16; i += 2) {
2c541554 614 vlc = svq3_get_ue_golomb(&h->gb);
76de302d 615
a7d2861d 616 if (vlc >= 25) {
2c541554 617 av_log(h->avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
76de302d
DB
618 return -1;
619 }
620
a7d2861d
DB
621 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
622 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
76de302d
DB
623
624 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
625 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
626
a7d2861d 627 if (left[1] == -1 || left[2] == -1) {
2c541554 628 av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
76de302d
DB
629 return -1;
630 }
631 }
632 } else { /* mb_type == 33, DC_128_PRED block type */
a7d2861d
DB
633 for (i = 0; i < 4; i++)
634 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
884182b3 635 }
8b82a956 636
3b7ebeb4 637 write_back_intra_pred_mode(h);
8b82a956 638
76de302d 639 if (mb_type == 8) {
2bedc0e8 640 ff_h264_check_intra4x4_pred_mode(h);
da3b9756 641
2c541554
AK
642 h->top_samples_available = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
643 h->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
76de302d 644 } else {
a7d2861d
DB
645 for (i = 0; i < 4; i++)
646 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
da3b9756 647
76de302d
DB
648 h->top_samples_available = 0x33FF;
649 h->left_samples_available = 0x5F5F;
650 }
da3b9756 651
76de302d
DB
652 mb_type = MB_TYPE_INTRA4x4;
653 } else { /* INTRA16x16 */
654 dir = i_mb_type_info[mb_type - 8].pred_mode;
a7d2861d 655 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
8b82a956 656
1115689d
MS
657 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) < 0) {
658 av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
659 return h->intra16x16_pred_mode;
76de302d 660 }
8b82a956 661
a7d2861d 662 cbp = i_mb_type_info[mb_type - 8].cbp;
76de302d 663 mb_type = MB_TYPE_INTRA16x16;
884182b3 664 }
8b82a956 665
2c541554 666 if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
a7d2861d 667 for (i = 0; i < 4; i++)
759001c5 668 memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
a7d2861d 669 0, 4 * 2 * sizeof(int16_t));
2c541554 670 if (h->pict_type == AV_PICTURE_TYPE_B) {
a7d2861d 671 for (i = 0; i < 4; i++)
759001c5 672 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
a7d2861d 673 0, 4 * 2 * sizeof(int16_t));
76de302d 674 }
8b82a956 675 }
76de302d 676 if (!IS_INTRA4x4(mb_type)) {
a7d2861d 677 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
da3b9756 678 }
2c541554 679 if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
a7d2861d 680 memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
884182b3 681 }
2e26c8d2 682
a7d2861d 683 if (!IS_INTRA16x16(mb_type) &&
2c541554
AK
684 (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
685 if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48) {
686 av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
76de302d
DB
687 return -1;
688 }
8b82a956 689
a7d2861d
DB
690 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
691 : golomb_to_inter_cbp[vlc];
884182b3 692 }
a7d2861d 693 if (IS_INTRA16x16(mb_type) ||
2c541554
AK
694 (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
695 h->qscale += svq3_get_se_golomb(&h->gb);
8b82a956 696
2c541554
AK
697 if (h->qscale > 31u) {
698 av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", h->qscale);
bb270c08 699 return -1;
bb270c08 700 }
8b82a956 701 }
76de302d 702 if (IS_INTRA16x16(mb_type)) {
a7d2861d
DB
703 AV_ZERO128(h->mb_luma_dc[0] + 0);
704 AV_ZERO128(h->mb_luma_dc[0] + 8);
2c541554
AK
705 if (svq3_decode_block(&h->gb, h->mb_luma_dc[0], 0, 1)) {
706 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 707 "error while decoding intra luma dc\n");
76de302d 708 return -1;
884182b3 709 }
76de302d 710 }
8b82a956 711
76de302d
DB
712 if (cbp) {
713 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
2c541554 714 const int type = ((h->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
76de302d 715
a7d2861d 716 for (i = 0; i < 4; i++)
76de302d
DB
717 if ((cbp & (1 << i))) {
718 for (j = 0; j < 4; j++) {
a7d2861d
DB
719 k = index ? (1 * (j & 1) + 2 * (i & 1) +
720 2 * (j & 2) + 4 * (i & 2))
721 : (4 * i + j);
722 h->non_zero_count_cache[scan8[k]] = 1;
723
2c541554
AK
724 if (svq3_decode_block(&h->gb, &h->mb[16 * k], index, type)) {
725 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 726 "error while decoding block\n");
76de302d
DB
727 return -1;
728 }
729 }
730 }
8b82a956 731
76de302d 732 if ((cbp & 0x30)) {
a7d2861d 733 for (i = 1; i < 3; ++i)
2c541554
AK
734 if (svq3_decode_block(&h->gb, &h->mb[16 * 16 * i], 0, 3)) {
735 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d
DB
736 "error while decoding chroma dc block\n");
737 return -1;
738 }
76de302d
DB
739
740 if ((cbp & 0x20)) {
11177a4d
JGG
741 for (i = 1; i < 3; i++) {
742 for (j = 0; j < 4; j++) {
a7d2861d
DB
743 k = 16 * i + j;
744 h->non_zero_count_cache[scan8[k]] = 1;
11177a4d 745
2c541554
AK
746 if (svq3_decode_block(&h->gb, &h->mb[16 * k], 1, 1)) {
747 av_log(h->avctx, AV_LOG_ERROR,
a7d2861d 748 "error while decoding chroma ac block\n");
11177a4d
JGG
749 return -1;
750 }
76de302d
DB
751 }
752 }
753 }
bb270c08 754 }
8b82a956 755 }
8b82a956 756
a7d2861d 757 h->cbp = cbp;
759001c5 758 h->cur_pic.mb_type[mb_xy] = mb_type;
8b82a956 759
a7d2861d 760 if (IS_INTRA(mb_type))
45b7bd7c 761 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
8b82a956 762
76de302d 763 return 0;
8b82a956
MN
764}
765
8dfc6d1f 766static int svq3_decode_slice_header(AVCodecContext *avctx)
7f8205da 767{
2c541554
AK
768 SVQ3Context *s = avctx->priv_data;
769 H264Context *h = &s->h;
a7d2861d 770 const int mb_xy = h->mb_xy;
76de302d 771 int i, header;
288bb3da 772 unsigned slice_id;
da3b9756 773
2c541554 774 header = get_bits(&h->gb, 8);
da3b9756 775
76de302d
DB
776 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
777 /* TODO: what? */
8dfc6d1f 778 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
76de302d
DB
779 return -1;
780 } else {
af1ede06 781 int length = header >> 5 & 3;
da3b9756 782
2c541554
AK
783 s->next_slice_index = get_bits_count(&h->gb) +
784 8 * show_bits(&h->gb, 8 * length) +
785 8 * length;
da3b9756 786
2c541554 787 if (s->next_slice_index > h->gb.size_in_bits) {
8dfc6d1f 788 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
76de302d 789 return -1;
a7d2861d 790 }
da3b9756 791
2c541554
AK
792 h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
793 skip_bits(&h->gb, 8);
da3b9756 794
2c541554
AK
795 if (s->watermark_key) {
796 uint32_t header = AV_RL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1]);
797 AV_WL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1],
798 header ^ s->watermark_key);
76de302d
DB
799 }
800 if (length > 0) {
2c541554
AK
801 memcpy((uint8_t *) &h->gb.buffer[get_bits_count(&h->gb) >> 3],
802 &h->gb.buffer[h->gb.size_in_bits >> 3], length - 1);
76de302d 803 }
2c541554 804 skip_bits_long(&h->gb, 0);
da3b9756 805 }
da3b9756 806
2c541554
AK
807 if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
808 av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %d \n", slice_id);
76de302d
DB
809 return -1;
810 }
da3b9756 811
288bb3da 812 h->slice_type = golomb_to_pict_type[slice_id];
da3b9756 813
76de302d 814 if ((header & 0x9F) == 2) {
2c541554
AK
815 i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
816 h->mb_skip_run = get_bits(&h->gb, i) -
817 (h->mb_y * h->mb_width + h->mb_x);
76de302d 818 } else {
2c541554
AK
819 skip_bits1(&h->gb);
820 h->mb_skip_run = 0;
76de302d 821 }
da3b9756 822
2c541554
AK
823 h->slice_num = get_bits(&h->gb, 8);
824 h->qscale = get_bits(&h->gb, 5);
825 s->adaptive_quant = get_bits1(&h->gb);
da3b9756 826
76de302d 827 /* unknown fields */
2c541554 828 skip_bits1(&h->gb);
da3b9756 829
2c541554
AK
830 if (s->unknown_flag)
831 skip_bits1(&h->gb);
da3b9756 832
2c541554
AK
833 skip_bits1(&h->gb);
834 skip_bits(&h->gb, 2);
da3b9756 835
2c541554
AK
836 while (get_bits1(&h->gb))
837 skip_bits(&h->gb, 8);
da3b9756 838
76de302d 839 /* reset intra predictors and invalidate motion vector references */
2c541554 840 if (h->mb_x > 0) {
a7d2861d
DB
841 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
842 -1, 4 * sizeof(int8_t));
2c541554
AK
843 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_x],
844 -1, 8 * sizeof(int8_t) * h->mb_x);
76de302d 845 }
2c541554
AK
846 if (h->mb_y > 0) {
847 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
848 -1, 8 * sizeof(int8_t) * (h->mb_width - h->mb_x));
76de302d 849
2c541554
AK
850 if (h->mb_x > 0)
851 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
da3b9756 852 }
da3b9756 853
76de302d 854 return 0;
da3b9756
MM
855}
856
5ef251e5 857static av_cold int svq3_decode_init(AVCodecContext *avctx)
7f8205da 858{
2c541554
AK
859 SVQ3Context *s = avctx->priv_data;
860 H264Context *h = &s->h;
f4cca718 861 int m;
76de302d 862 unsigned char *extradata;
9e1db721 863 unsigned char *extradata_end;
76de302d 864 unsigned int size;
9e1db721 865 int marker_found = 0;
76de302d 866
2c541554
AK
867 s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
868 s->last_pic = av_mallocz(sizeof(*s->last_pic));
869 s->next_pic = av_mallocz(sizeof(*s->next_pic));
870 if (!s->next_pic || !s->last_pic || !s->cur_pic) {
871 av_freep(&s->cur_pic);
872 av_freep(&s->last_pic);
873 av_freep(&s->next_pic);
874 return AVERROR(ENOMEM);
875 }
876
903d58f6 877 if (ff_h264_decode_init(avctx) < 0)
f4cca718
BC
878 return -1;
879
2f6bc5f7 880 ff_hpeldsp_init(&s->hdsp, avctx->flags);
2c541554 881 h->flags = avctx->flags;
a7d2861d 882 h->is_complex = 1;
2c541554 883 h->picture_structure = PICT_FRAME;
a7d2861d 884 avctx->pix_fmt = avctx->codec->pix_fmts[0];
76de302d 885
d9ebb00d 886 h->chroma_qp[0] = h->chroma_qp[1] = 4;
2c541554 887 h->chroma_x_shift = h->chroma_y_shift = 1;
d9ebb00d 888
2c541554
AK
889 s->halfpel_flag = 1;
890 s->thirdpel_flag = 1;
891 s->unknown_flag = 0;
d9ebb00d
AK
892
893 /* prowl for the "SEQH" marker in the extradata */
894 extradata = (unsigned char *)avctx->extradata;
895 extradata_end = avctx->extradata + avctx->extradata_size;
896 if (extradata) {
897 for (m = 0; m + 8 < avctx->extradata_size; m++) {
898 if (!memcmp(extradata, "SEQH", 4)) {
899 marker_found = 1;
900 break;
9e1db721 901 }
d9ebb00d 902 extradata++;
76de302d 903 }
d9ebb00d 904 }
8b82a956 905
d9ebb00d
AK
906 /* if a match was found, parse the extra data */
907 if (marker_found) {
908 GetBitContext gb;
909 int frame_size_code;
910
911 size = AV_RB32(&extradata[4]);
912 if (size > extradata_end - extradata - 8)
913 return AVERROR_INVALIDDATA;
914 init_get_bits(&gb, extradata + 8, size * 8);
915
916 /* 'frame size code' and optional 'width, height' */
917 frame_size_code = get_bits(&gb, 3);
918 switch (frame_size_code) {
919 case 0:
920 avctx->width = 160;
921 avctx->height = 120;
922 break;
923 case 1:
924 avctx->width = 128;
925 avctx->height = 96;
926 break;
927 case 2:
928 avctx->width = 176;
929 avctx->height = 144;
930 break;
931 case 3:
932 avctx->width = 352;
933 avctx->height = 288;
934 break;
935 case 4:
936 avctx->width = 704;
937 avctx->height = 576;
938 break;
939 case 5:
940 avctx->width = 240;
941 avctx->height = 180;
942 break;
943 case 6:
944 avctx->width = 320;
945 avctx->height = 240;
946 break;
947 case 7:
948 avctx->width = get_bits(&gb, 12);
949 avctx->height = get_bits(&gb, 12);
950 break;
951 }
8b82a956 952
2c541554
AK
953 s->halfpel_flag = get_bits1(&gb);
954 s->thirdpel_flag = get_bits1(&gb);
8b82a956 955
d9ebb00d
AK
956 /* unknown fields */
957 skip_bits1(&gb);
958 skip_bits1(&gb);
959 skip_bits1(&gb);
960 skip_bits1(&gb);
8b82a956 961
2c541554 962 h->low_delay = get_bits1(&gb);
1e002b60 963
d9ebb00d
AK
964 /* unknown field */
965 skip_bits1(&gb);
76de302d 966
d9ebb00d
AK
967 while (get_bits1(&gb))
968 skip_bits(&gb, 8);
76de302d 969
2c541554
AK
970 s->unknown_flag = get_bits1(&gb);
971 avctx->has_b_frames = !h->low_delay;
972 if (s->unknown_flag) {
b250f9c6 973#if CONFIG_ZLIB
d9ebb00d
AK
974 unsigned watermark_width = svq3_get_ue_golomb(&gb);
975 unsigned watermark_height = svq3_get_ue_golomb(&gb);
976 int u1 = svq3_get_ue_golomb(&gb);
977 int u2 = get_bits(&gb, 8);
978 int u3 = get_bits(&gb, 2);
979 int u4 = svq3_get_ue_golomb(&gb);
980 unsigned long buf_len = watermark_width *
981 watermark_height * 4;
982 int offset = get_bits_count(&gb) + 7 >> 3;
983 uint8_t *buf;
984
601c2015
MS
985 if (watermark_height > 0 &&
986 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
d9ebb00d 987 return -1;
76de302d 988
d9ebb00d
AK
989 buf = av_malloc(buf_len);
990 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
991 watermark_width, watermark_height);
992 av_log(avctx, AV_LOG_DEBUG,
993 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
994 u1, u2, u3, u4, offset);
995 if (uncompress(buf, &buf_len, extradata + 8 + offset,
996 size - offset) != Z_OK) {
a7d2861d 997 av_log(avctx, AV_LOG_ERROR,
d9ebb00d
AK
998 "could not uncompress watermark logo\n");
999 av_free(buf);
76de302d 1000 return -1;
76de302d 1001 }
2c541554
AK
1002 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1003 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
d9ebb00d 1004 av_log(avctx, AV_LOG_DEBUG,
2c541554 1005 "watermark key %#x\n", s->watermark_key);
d9ebb00d
AK
1006 av_free(buf);
1007#else
1008 av_log(avctx, AV_LOG_ERROR,
1009 "this svq3 file contains watermark which need zlib support compiled in\n");
1010 return -1;
1011#endif
76de302d 1012 }
d9ebb00d 1013 }
cdca7c37 1014
2c541554
AK
1015 h->width = avctx->width;
1016 h->height = avctx->height;
1017 h->mb_width = (h->width + 15) / 16;
1018 h->mb_height = (h->height + 15) / 16;
1019 h->mb_stride = h->mb_width + 1;
1020 h->mb_num = h->mb_width * h->mb_height;
1021 h->b_stride = 4 * h->mb_width;
1022 s->h_edge_pos = h->mb_width * 16;
1023 s->v_edge_pos = h->mb_height * 16;
cdca7c37 1024
d9ebb00d
AK
1025 if (ff_h264_alloc_tables(h) < 0) {
1026 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1027 return AVERROR(ENOMEM);
da3b9756 1028 }
76de302d 1029
f4cca718
BC
1030 return 0;
1031}
1032
759001c5
AK
1033static void free_picture(AVCodecContext *avctx, Picture *pic)
1034{
1035 int i;
1036 for (i = 0; i < 2; i++) {
1037 av_buffer_unref(&pic->motion_val_buf[i]);
1038 av_buffer_unref(&pic->ref_index_buf[i]);
1039 }
1040 av_buffer_unref(&pic->mb_type_buf);
1041
1042 av_frame_unref(&pic->f);
1043}
1044
2c541554
AK
1045static int get_buffer(AVCodecContext *avctx, Picture *pic)
1046{
1047 SVQ3Context *s = avctx->priv_data;
1048 H264Context *h = &s->h;
1049 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1050 const int mb_array_size = h->mb_stride * h->mb_height;
1051 const int b4_stride = h->mb_width * 4 + 1;
1052 const int b4_array_size = b4_stride * h->mb_height * 4;
1053 int ret;
1054
759001c5 1055 if (!pic->motion_val_buf[0]) {
2c541554
AK
1056 int i;
1057
759001c5
AK
1058 pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1059 if (!pic->mb_type_buf)
2c541554 1060 return AVERROR(ENOMEM);
759001c5 1061 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
2c541554
AK
1062
1063 for (i = 0; i < 2; i++) {
759001c5
AK
1064 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1065 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1066 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1067 ret = AVERROR(ENOMEM);
1068 goto fail;
1069 }
2c541554 1070
759001c5
AK
1071 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1072 pic->ref_index[i] = pic->ref_index_buf[i]->data;
2c541554
AK
1073 }
1074 }
759001c5
AK
1075 pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1076
1077 ret = ff_get_buffer(avctx, &pic->f,
1078 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1079 if (ret < 0)
1080 goto fail;
2c541554 1081
fae6fd5b
RB
1082 if (!h->edge_emu_buffer) {
1083 h->edge_emu_buffer = av_mallocz(pic->f.linesize[0] * 17);
1084 if (!h->edge_emu_buffer)
1085 return AVERROR(ENOMEM);
1086 }
2c541554
AK
1087
1088 h->linesize = pic->f.linesize[0];
1089 h->uvlinesize = pic->f.linesize[1];
1090
759001c5
AK
1091 return 0;
1092fail:
1093 free_picture(avctx, pic);
2c541554
AK
1094 return ret;
1095}
1096
a7d2861d 1097static int svq3_decode_frame(AVCodecContext *avctx, void *data,
df9b9567 1098 int *got_frame, AVPacket *avpkt)
f4cca718 1099{
7a00bbad 1100 const uint8_t *buf = avpkt->data;
2c541554
AK
1101 SVQ3Context *s = avctx->priv_data;
1102 H264Context *h = &s->h;
a7d2861d 1103 int buf_size = avpkt->size;
2c541554 1104 int ret, m, i;
f4cca718 1105
76de302d
DB
1106 /* special case for last picture */
1107 if (buf_size == 0) {
2c541554 1108 if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
759001c5
AK
1109 ret = av_frame_ref(data, &s->next_pic->f);
1110 if (ret < 0)
1111 return ret;
2c541554 1112 s->last_frame_output = 1;
df9b9567 1113 *got_frame = 1;
76de302d
DB
1114 }
1115 return 0;
da3b9756 1116 }
8b82a956 1117
2c541554 1118 init_get_bits(&h->gb, buf, 8 * buf_size);
8b82a956 1119
2c541554 1120 h->mb_x = h->mb_y = h->mb_xy = 0;
8b82a956 1121
8dfc6d1f 1122 if (svq3_decode_slice_header(avctx))
76de302d 1123 return -1;
8b82a956 1124
2c541554 1125 h->pict_type = h->slice_type;
8b82a956 1126
2c541554
AK
1127 if (h->pict_type != AV_PICTURE_TYPE_B)
1128 FFSWAP(Picture*, s->next_pic, s->last_pic);
1129
759001c5 1130 av_frame_unref(&s->cur_pic->f);
8b82a956 1131
8ed2ae09 1132 /* for skipping the frame */
2c541554
AK
1133 s->cur_pic->f.pict_type = h->pict_type;
1134 s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
76de302d 1135
2c541554
AK
1136 ret = get_buffer(avctx, s->cur_pic);
1137 if (ret < 0)
1138 return ret;
1139
1140 h->cur_pic_ptr = s->cur_pic;
759001c5 1141 av_frame_unref(&h->cur_pic.f);
2c541554 1142 h->cur_pic = *s->cur_pic;
759001c5
AK
1143 ret = av_frame_ref(&h->cur_pic.f, &s->cur_pic->f);
1144 if (ret < 0)
1145 return ret;
2c541554
AK
1146
1147 for (i = 0; i < 16; i++) {
1148 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1149 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1150 }
1151 for (i = 0; i < 16; i++) {
1152 h->block_offset[16 + i] =
1153 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1154 h->block_offset[48 + 16 + i] =
1155 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1156 }
1157
1158 if (h->pict_type != AV_PICTURE_TYPE_I) {
1159 if (!s->last_pic->f.data[0]) {
1160 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1161 ret = get_buffer(avctx, s->last_pic);
1162 if (ret < 0)
1163 return ret;
1164 memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1165 memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1166 s->last_pic->f.linesize[1]);
1167 memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1168 s->last_pic->f.linesize[2]);
1169 }
1170
1171 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1172 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1173 ret = get_buffer(avctx, s->next_pic);
1174 if (ret < 0)
1175 return ret;
1176 memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1177 memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1178 s->next_pic->f.linesize[1]);
1179 memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1180 s->next_pic->f.linesize[2]);
1181 }
1182 }
1183
1184 if (avctx->debug & FF_DEBUG_PICT_INFO)
1185 av_log(h->avctx, AV_LOG_DEBUG,
1186 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1187 av_get_picture_type_char(h->pict_type),
1188 s->halfpel_flag, s->thirdpel_flag,
1189 s->adaptive_quant, h->qscale, h->slice_num);
1190
1191 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1192 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
af1ede06 1193 avctx->skip_frame >= AVDISCARD_ALL)
76de302d
DB
1194 return 0;
1195
1196 if (s->next_p_frame_damaged) {
2c541554 1197 if (h->pict_type == AV_PICTURE_TYPE_B)
76de302d
DB
1198 return 0;
1199 else
1200 s->next_p_frame_damaged = 0;
1201 }
da3b9756 1202
2c541554 1203 if (h->pict_type == AV_PICTURE_TYPE_B) {
af1ede06 1204 h->frame_num_offset = h->slice_num - h->prev_frame_num;
8b82a956 1205
a7d2861d 1206 if (h->frame_num_offset < 0)
76de302d 1207 h->frame_num_offset += 256;
a7d2861d
DB
1208 if (h->frame_num_offset == 0 ||
1209 h->frame_num_offset >= h->prev_frame_num_offset) {
2c541554 1210 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
76de302d
DB
1211 return -1;
1212 }
1213 } else {
a7d2861d
DB
1214 h->prev_frame_num = h->frame_num;
1215 h->frame_num = h->slice_num;
af1ede06 1216 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
da3b9756 1217
a7d2861d 1218 if (h->prev_frame_num_offset < 0)
76de302d 1219 h->prev_frame_num_offset += 256;
da3b9756 1220 }
da3b9756 1221
a7d2861d 1222 for (m = 0; m < 2; m++) {
76de302d 1223 int i;
a7d2861d 1224 for (i = 0; i < 4; i++) {
76de302d
DB
1225 int j;
1226 for (j = -1; j < 4; j++)
a7d2861d 1227 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
76de302d 1228 if (i < 3)
a7d2861d 1229 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
76de302d 1230 }
da3b9756 1231 }
da3b9756 1232
2c541554
AK
1233 for (h->mb_y = 0; h->mb_y < h->mb_height; h->mb_y++) {
1234 for (h->mb_x = 0; h->mb_x < h->mb_width; h->mb_x++) {
9a2e7911 1235 unsigned mb_type;
2c541554 1236 h->mb_xy = h->mb_x + h->mb_y * h->mb_stride;
da3b9756 1237
2c541554
AK
1238 if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1239 ((get_bits_count(&h->gb) & 7) == 0 ||
1240 show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1241 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1242 h->gb.size_in_bits = 8 * buf_size;
da3b9756 1243
8dfc6d1f 1244 if (svq3_decode_slice_header(avctx))
76de302d 1245 return -1;
da3b9756 1246
76de302d
DB
1247 /* TODO: support s->mb_skip_run */
1248 }
da3b9756 1249
2c541554 1250 mb_type = svq3_get_ue_golomb(&h->gb);
da3b9756 1251
2c541554 1252 if (h->pict_type == AV_PICTURE_TYPE_I)
76de302d 1253 mb_type += 8;
2c541554 1254 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
76de302d 1255 mb_type += 4;
2c541554
AK
1256 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1257 av_log(h->avctx, AV_LOG_ERROR,
1258 "error while decoding MB %d %d\n", h->mb_x, h->mb_y);
76de302d
DB
1259 return -1;
1260 }
8b82a956 1261
a7d2861d
DB
1262 if (mb_type != 0)
1263 ff_h264_hl_decode_mb(h);
8b82a956 1264
2c541554 1265 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
759001c5 1266 h->cur_pic.mb_type[h->mb_x + h->mb_y * h->mb_stride] =
2c541554 1267 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
76de302d 1268 }
2e26c8d2 1269
75af13a0
VG
1270 ff_draw_horiz_band(avctx, &s->cur_pic->f,
1271 s->last_pic->f.data[0] ? &s->last_pic->f : NULL,
ebfe622b 1272 16 * h->mb_y, 16, h->picture_structure, 0,
54b2ce74 1273 h->low_delay);
8b82a956 1274 }
4c701ac8 1275
2c541554 1276 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
759001c5
AK
1277 ret = av_frame_ref(data, &s->cur_pic->f);
1278 else if (s->last_pic->f.data[0])
1279 ret = av_frame_ref(data, &s->last_pic->f);
1280 if (ret < 0)
1281 return ret;
da3b9756 1282
76de302d 1283 /* Do not output the last pic after seeking. */
2c541554 1284 if (s->last_pic->f.data[0] || h->low_delay)
df9b9567 1285 *got_frame = 1;
da3b9756 1286
2c541554
AK
1287 if (h->pict_type != AV_PICTURE_TYPE_B) {
1288 FFSWAP(Picture*, s->cur_pic, s->next_pic);
759001c5
AK
1289 } else {
1290 av_frame_unref(&s->cur_pic->f);
2c541554
AK
1291 }
1292
76de302d 1293 return buf_size;
8b82a956
MN
1294}
1295
bd8ac882 1296static av_cold int svq3_decode_end(AVCodecContext *avctx)
8dfc6d1f 1297{
2c541554
AK
1298 SVQ3Context *s = avctx->priv_data;
1299 H264Context *h = &s->h;
8dfc6d1f 1300
2c541554
AK
1301 free_picture(avctx, s->cur_pic);
1302 free_picture(avctx, s->next_pic);
1303 free_picture(avctx, s->last_pic);
759001c5
AK
1304 av_freep(&s->cur_pic);
1305 av_freep(&s->next_pic);
1306 av_freep(&s->last_pic);
1307
1308 av_frame_unref(&h->cur_pic.f);
8dfc6d1f 1309
2c541554 1310 ff_h264_free_context(h);
8dfc6d1f
BC
1311
1312 return 0;
1313}
8b82a956 1314
d36beb3f 1315AVCodec ff_svq3_decoder = {
ec6402b7 1316 .name = "svq3",
b2bed932 1317 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
ec6402b7 1318 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 1319 .id = AV_CODEC_ID_SVQ3,
ec6402b7
AK
1320 .priv_data_size = sizeof(SVQ3Context),
1321 .init = svq3_decode_init,
1322 .close = svq3_decode_end,
1323 .decode = svq3_decode_frame,
a7d2861d
DB
1324 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND |
1325 CODEC_CAP_DR1 |
00c3b67b 1326 CODEC_CAP_DELAY,
a7d2861d
DB
1327 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1328 AV_PIX_FMT_NONE},
8b82a956 1329};