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