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