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