swscale: fix crash with dithering due incorrect offset calculation.
[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
DB
290 /* form component predictions */
291 dest = s->current_picture.data[0] + x + y*s->linesize;
292 src = pic->data[0] + mx + my*s->linesize;
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++) {
312 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
313 src = pic->data[i] + mx + my*s->uvlinesize;
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 {
350 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
351 my = s->next_picture.motion_val[0][b_xy][1]<<1;
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 */
428 fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
bb270c08 429 }
2e26c8d2 430 }
2e26c8d2 431
76de302d 432 return 0;
2e26c8d2
MM
433}
434
8dfc6d1f 435static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
7f8205da 436{
8dfc6d1f 437 H264Context *h = &svq3->h;
76de302d
DB
438 int i, j, k, m, dir, mode;
439 int cbp = 0;
440 uint32_t vlc;
441 int8_t *top, *left;
442 MpegEncContext *const s = (MpegEncContext *) h;
443 const int mb_xy = h->mb_xy;
444 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
445
446 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
447 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
448 h->topright_samples_available = 0xFFFF;
449
450 if (mb_type == 0) { /* SKIP */
975a1447 451 if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.mb_type[mb_xy] == -1) {
76de302d
DB
452 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
453
975a1447 454 if (s->pict_type == AV_PICTURE_TYPE_B) {
76de302d
DB
455 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
456 }
457
458 mb_type = MB_TYPE_SKIP;
459 } else {
460 mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
461 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
462 return -1;
463 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
464 return -1;
8b82a956 465
76de302d 466 mb_type = MB_TYPE_16x16;
bb270c08 467 }
76de302d 468 } else if (mb_type < 8) { /* INTER */
8dfc6d1f 469 if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
76de302d 470 mode = THIRDPEL_MODE;
8dfc6d1f 471 } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
76de302d
DB
472 mode = HALFPEL_MODE;
473 } else {
474 mode = FULLPEL_MODE;
bb270c08 475 }
8b82a956 476
76de302d
DB
477 /* fill caches */
478 /* note ref_cache should contain here:
479 ????????
480 ???11111
481 N??11111
482 N??11111
483 N??11111
484 */
485
486 for (m = 0; m < 2; m++) {
3b606e71 487 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
76de302d
DB
488 for (i = 0; i < 4; i++) {
489 *(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];
490 }
491 } else {
492 for (i = 0; i < 4; i++) {
493 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
494 }
495 }
496 if (s->mb_y > 0) {
497 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 498 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
499
500 if (s->mb_x < (s->mb_width - 1)) {
501 *(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];
502 h->ref_cache[m][scan8[0] + 4 - 1*8] =
3b606e71
MN
503 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
504 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride ] ] == -1) ? PART_NOT_AVAILABLE : 1;
76de302d
DB
505 }else
506 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
507 if (s->mb_x > 0) {
508 *(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 509 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
510 }else
511 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
512 }else
513 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
514
975a1447 515 if (s->pict_type != AV_PICTURE_TYPE_B)
76de302d 516 break;
bb270c08 517 }
8b82a956 518
76de302d 519 /* decode motion vector(s) and form prediction(s) */
975a1447 520 if (s->pict_type == AV_PICTURE_TYPE_P) {
76de302d
DB
521 if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
522 return -1;
975a1447 523 } else { /* AV_PICTURE_TYPE_B */
76de302d
DB
524 if (mb_type != 2) {
525 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
526 return -1;
527 } else {
528 for (i = 0; i < 4; i++) {
529 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
530 }
531 }
532 if (mb_type != 1) {
533 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
534 return -1;
535 } else {
536 for (i = 0; i < 4; i++) {
537 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
538 }
539 }
bb270c08 540 }
8b82a956 541
76de302d
DB
542 mb_type = MB_TYPE_16x16;
543 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
544 memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
545
546 if (mb_type == 8) {
547 if (s->mb_x > 0) {
548 for (i = 0; i < 4; i++) {
3b606e71 549 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
76de302d
DB
550 }
551 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
552 h->left_samples_available = 0x5F5F;
553 }
554 }
555 if (s->mb_y > 0) {
3b606e71
MN
556 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
557 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
558 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
559 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
76de302d
DB
560
561 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
562 h->top_samples_available = 0x33FF;
563 }
564 }
565
566 /* decode prediction codes for luma blocks */
567 for (i = 0; i < 16; i+=2) {
568 vlc = svq3_get_ue_golomb(&s->gb);
569
570 if (vlc >= 25){
571 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
572 return -1;
573 }
574
575 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
576 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
577
578 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
579 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
580
581 if (left[1] == -1 || left[2] == -1){
582 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
583 return -1;
584 }
585 }
586 } else { /* mb_type == 33, DC_128_PRED block type */
587 for (i = 0; i < 4; i++) {
588 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
589 }
884182b3 590 }
8b82a956 591
3b7ebeb4 592 write_back_intra_pred_mode(h);
8b82a956 593
76de302d 594 if (mb_type == 8) {
2bedc0e8 595 ff_h264_check_intra4x4_pred_mode(h);
da3b9756 596
76de302d
DB
597 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
598 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
599 } else {
600 for (i = 0; i < 4; i++) {
601 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
602 }
da3b9756 603
76de302d
DB
604 h->top_samples_available = 0x33FF;
605 h->left_samples_available = 0x5F5F;
606 }
da3b9756 607
76de302d
DB
608 mb_type = MB_TYPE_INTRA4x4;
609 } else { /* INTRA16x16 */
610 dir = i_mb_type_info[mb_type - 8].pred_mode;
611 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
8b82a956 612
903d58f6 613 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
76de302d
DB
614 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
615 return -1;
616 }
8b82a956 617
76de302d
DB
618 cbp = i_mb_type_info[mb_type - 8].cbp;
619 mb_type = MB_TYPE_INTRA16x16;
884182b3 620 }
8b82a956 621
975a1447 622 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
76de302d
DB
623 for (i = 0; i < 4; i++) {
624 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
625 }
975a1447 626 if (s->pict_type == AV_PICTURE_TYPE_B) {
76de302d
DB
627 for (i = 0; i < 4; i++) {
628 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
629 }
630 }
8b82a956 631 }
76de302d 632 if (!IS_INTRA4x4(mb_type)) {
3b606e71 633 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
da3b9756 634 }
975a1447 635 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
11177a4d
JGG
636 memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
637 s->dsp.clear_blocks(h->mb+ 0);
638 s->dsp.clear_blocks(h->mb+384);
884182b3 639 }
2e26c8d2 640
975a1447 641 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
76de302d
DB
642 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
643 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
644 return -1;
645 }
8b82a956 646
76de302d 647 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
884182b3 648 }
975a1447 649 if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
76de302d 650 s->qscale += svq3_get_se_golomb(&s->gb);
8b82a956 651
76de302d
DB
652 if (s->qscale > 31){
653 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
bb270c08 654 return -1;
bb270c08 655 }
8b82a956 656 }
76de302d 657 if (IS_INTRA16x16(mb_type)) {
11177a4d
JGG
658 AV_ZERO128(h->mb_luma_dc[0]+0);
659 AV_ZERO128(h->mb_luma_dc[0]+8);
290fabc6 660 if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
76de302d
DB
661 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
662 return -1;
884182b3 663 }
76de302d 664 }
8b82a956 665
76de302d
DB
666 if (cbp) {
667 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
668 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
669
670 for (i = 0; i < 4; i++) {
671 if ((cbp & (1 << i))) {
672 for (j = 0; j < 4; j++) {
673 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
674 h->non_zero_count_cache[ scan8[k] ] = 1;
675
676 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
677 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
678 return -1;
679 }
680 }
681 }
682 }
8b82a956 683
76de302d 684 if ((cbp & 0x30)) {
11177a4d
JGG
685 for (i = 1; i < 3; ++i) {
686 if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
66c6b5e2
RB
687 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
688 return -1;
689 }
76de302d
DB
690 }
691
692 if ((cbp & 0x20)) {
11177a4d
JGG
693 for (i = 1; i < 3; i++) {
694 for (j = 0; j < 4; j++) {
695 k = 16*i + j;
696 h->non_zero_count_cache[ scan8[k] ] = 1;
697
698 if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
699 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
700 return -1;
701 }
76de302d
DB
702 }
703 }
704 }
bb270c08 705 }
8b82a956 706 }
8b82a956 707
2a5a9c28 708 h->cbp= cbp;
76de302d 709 s->current_picture.mb_type[mb_xy] = mb_type;
8b82a956 710
76de302d 711 if (IS_INTRA(mb_type)) {
903d58f6 712 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
76de302d 713 }
8b82a956 714
76de302d 715 return 0;
8b82a956
MN
716}
717
8dfc6d1f 718static int svq3_decode_slice_header(AVCodecContext *avctx)
7f8205da 719{
8dfc6d1f
BC
720 SVQ3Context *svq3 = avctx->priv_data;
721 H264Context *h = &svq3->h;
722 MpegEncContext *s = &h->s;
76de302d
DB
723 const int mb_xy = h->mb_xy;
724 int i, header;
da3b9756 725
76de302d 726 header = get_bits(&s->gb, 8);
da3b9756 727
76de302d
DB
728 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
729 /* TODO: what? */
8dfc6d1f 730 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
76de302d
DB
731 return -1;
732 } else {
733 int length = (header >> 5) & 3;
da3b9756 734
8dfc6d1f 735 svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
da3b9756 736
8dfc6d1f
BC
737 if (svq3->next_slice_index > s->gb.size_in_bits) {
738 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
76de302d 739 return -1;
303e50e6 740 }
da3b9756 741
8dfc6d1f 742 s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
76de302d 743 skip_bits(&s->gb, 8);
da3b9756 744
8dfc6d1f 745 if (svq3->watermark_key) {
76de302d 746 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
8dfc6d1f 747 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
76de302d
DB
748 }
749 if (length > 0) {
750 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
751 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
752 }
db794291 753 skip_bits_long(&s->gb, 0);
da3b9756 754 }
da3b9756 755
76de302d
DB
756 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
757 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
758 return -1;
759 }
da3b9756 760
76de302d 761 h->slice_type = golomb_to_pict_type[i];
da3b9756 762
76de302d
DB
763 if ((header & 0x9F) == 2) {
764 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
765 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
766 } else {
767 skip_bits1(&s->gb);
768 s->mb_skip_run = 0;
769 }
da3b9756 770
76de302d
DB
771 h->slice_num = get_bits(&s->gb, 8);
772 s->qscale = get_bits(&s->gb, 5);
773 s->adaptive_quant = get_bits1(&s->gb);
da3b9756 774
76de302d
DB
775 /* unknown fields */
776 skip_bits1(&s->gb);
da3b9756 777
8dfc6d1f 778 if (svq3->unknown_flag) {
76de302d
DB
779 skip_bits1(&s->gb);
780 }
da3b9756 781
76de302d
DB
782 skip_bits1(&s->gb);
783 skip_bits(&s->gb, 2);
da3b9756 784
76de302d
DB
785 while (get_bits1(&s->gb)) {
786 skip_bits(&s->gb, 8);
787 }
da3b9756 788
76de302d 789 /* reset intra predictors and invalidate motion vector references */
da3b9756 790 if (s->mb_x > 0) {
3b606e71
MN
791 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t));
792 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x);
76de302d
DB
793 }
794 if (s->mb_y > 0) {
3b606e71 795 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
796
797 if (s->mb_x > 0) {
3b606e71 798 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
76de302d 799 }
da3b9756 800 }
da3b9756 801
76de302d 802 return 0;
da3b9756
MM
803}
804
5ef251e5 805static av_cold int svq3_decode_init(AVCodecContext *avctx)
7f8205da 806{
8dfc6d1f
BC
807 SVQ3Context *svq3 = avctx->priv_data;
808 H264Context *h = &svq3->h;
809 MpegEncContext *s = &h->s;
f4cca718 810 int m;
76de302d
DB
811 unsigned char *extradata;
812 unsigned int size;
813
903d58f6 814 if (ff_h264_decode_init(avctx) < 0)
f4cca718
BC
815 return -1;
816
76de302d
DB
817 s->flags = avctx->flags;
818 s->flags2 = avctx->flags2;
819 s->unrestricted_mv = 1;
54dab661 820 h->is_complex=1;
94621d32 821 avctx->pix_fmt = avctx->codec->pix_fmts[0];
76de302d
DB
822
823 if (!s->context_initialized) {
8dfc6d1f
BC
824 h->chroma_qp[0] = h->chroma_qp[1] = 4;
825
826 svq3->halfpel_flag = 1;
827 svq3->thirdpel_flag = 1;
828 svq3->unknown_flag = 0;
76de302d 829
76de302d
DB
830 /* prowl for the "SEQH" marker in the extradata */
831 extradata = (unsigned char *)avctx->extradata;
832 for (m = 0; m < avctx->extradata_size; m++) {
833 if (!memcmp(extradata, "SEQH", 4))
834 break;
835 extradata++;
836 }
8b82a956 837
76de302d
DB
838 /* if a match was found, parse the extra data */
839 if (extradata && !memcmp(extradata, "SEQH", 4)) {
8b82a956 840
76de302d 841 GetBitContext gb;
faccfeec 842 int frame_size_code;
8b82a956 843
76de302d
DB
844 size = AV_RB32(&extradata[4]);
845 init_get_bits(&gb, extradata + 8, size*8);
8b82a956 846
76de302d 847 /* 'frame size code' and optional 'width, height' */
faccfeec
RB
848 frame_size_code = get_bits(&gb, 3);
849 switch (frame_size_code) {
850 case 0: avctx->width = 160; avctx->height = 120; break;
851 case 1: avctx->width = 128; avctx->height = 96; break;
852 case 2: avctx->width = 176; avctx->height = 144; break;
853 case 3: avctx->width = 352; avctx->height = 288; break;
854 case 4: avctx->width = 704; avctx->height = 576; break;
855 case 5: avctx->width = 240; avctx->height = 180; break;
856 case 6: avctx->width = 320; avctx->height = 240; break;
857 case 7:
858 avctx->width = get_bits(&gb, 12);
859 avctx->height = get_bits(&gb, 12);
860 break;
76de302d 861 }
8b82a956 862
8dfc6d1f
BC
863 svq3->halfpel_flag = get_bits1(&gb);
864 svq3->thirdpel_flag = get_bits1(&gb);
8b82a956 865
76de302d
DB
866 /* unknown fields */
867 skip_bits1(&gb);
868 skip_bits1(&gb);
869 skip_bits1(&gb);
870 skip_bits1(&gb);
8b82a956 871
76de302d 872 s->low_delay = get_bits1(&gb);
1e002b60 873
76de302d
DB
874 /* unknown field */
875 skip_bits1(&gb);
876
877 while (get_bits1(&gb)) {
878 skip_bits(&gb, 8);
879 }
880
8dfc6d1f 881 svq3->unknown_flag = get_bits1(&gb);
76de302d 882 avctx->has_b_frames = !s->low_delay;
8dfc6d1f 883 if (svq3->unknown_flag) {
b250f9c6 884#if CONFIG_ZLIB
76de302d
DB
885 unsigned watermark_width = svq3_get_ue_golomb(&gb);
886 unsigned watermark_height = svq3_get_ue_golomb(&gb);
887 int u1 = svq3_get_ue_golomb(&gb);
888 int u2 = get_bits(&gb, 8);
889 int u3 = get_bits(&gb, 2);
890 int u4 = svq3_get_ue_golomb(&gb);
891263ef 891 unsigned long buf_len = watermark_width*watermark_height*4;
76de302d
DB
892 int offset = (get_bits_count(&gb)+7)>>3;
893 uint8_t *buf;
894
895 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
896 return -1;
897
898 buf = av_malloc(buf_len);
899 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
900 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 901 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
76de302d
DB
902 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
903 av_free(buf);
904 return -1;
905 }
8dfc6d1f
BC
906 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
907 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
908 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
76de302d 909 av_free(buf);
1e002b60 910#else
76de302d
DB
911 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
912 return -1;
1e002b60 913#endif
76de302d
DB
914 }
915 }
cdca7c37
RB
916
917 s->width = avctx->width;
918 s->height = avctx->height;
919
920 if (MPV_common_init(s) < 0)
921 return -1;
922
923 h->b_stride = 4*s->mb_width;
924
925 ff_h264_alloc_tables(h);
da3b9756 926 }
76de302d 927
f4cca718
BC
928 return 0;
929}
930
931static int svq3_decode_frame(AVCodecContext *avctx,
932 void *data, int *data_size,
7a00bbad 933 AVPacket *avpkt)
f4cca718 934{
7a00bbad 935 const uint8_t *buf = avpkt->data;
8dfc6d1f
BC
936 SVQ3Context *svq3 = avctx->priv_data;
937 H264Context *h = &svq3->h;
938 MpegEncContext *s = &h->s;
7a00bbad 939 int buf_size = avpkt->size;
f4cca718
BC
940 int m, mb_type;
941
76de302d
DB
942 /* special case for last picture */
943 if (buf_size == 0) {
944 if (s->next_picture_ptr && !s->low_delay) {
945 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
946 s->next_picture_ptr = NULL;
947 *data_size = sizeof(AVFrame);
948 }
949 return 0;
da3b9756 950 }
8b82a956 951
76de302d 952 init_get_bits (&s->gb, buf, 8*buf_size);
8b82a956 953
76de302d 954 s->mb_x = s->mb_y = h->mb_xy = 0;
8b82a956 955
8dfc6d1f 956 if (svq3_decode_slice_header(avctx))
76de302d 957 return -1;
8b82a956 958
76de302d
DB
959 s->pict_type = h->slice_type;
960 s->picture_number = h->slice_num;
8b82a956 961
76de302d
DB
962 if (avctx->debug&FF_DEBUG_PICT_INFO){
963 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
8dfc6d1f 964 av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
76de302d
DB
965 s->adaptive_quant, s->qscale, h->slice_num);
966 }
8b82a956 967
8ed2ae09 968 /* for skipping the frame */
76de302d 969 s->current_picture.pict_type = s->pict_type;
975a1447 970 s->current_picture.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
76de302d
DB
971
972 /* Skip B-frames if we do not have reference frames. */
975a1447 973 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
76de302d 974 return 0;
975a1447
SS
975 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
976 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
76de302d
DB
977 || avctx->skip_frame >= AVDISCARD_ALL)
978 return 0;
979
980 if (s->next_p_frame_damaged) {
975a1447 981 if (s->pict_type == AV_PICTURE_TYPE_B)
76de302d
DB
982 return 0;
983 else
984 s->next_p_frame_damaged = 0;
985 }
da3b9756 986
903d58f6 987 if (ff_h264_frame_start(h) < 0)
76de302d 988 return -1;
8b82a956 989
975a1447 990 if (s->pict_type == AV_PICTURE_TYPE_B) {
76de302d 991 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
8b82a956 992
76de302d
DB
993 if (h->frame_num_offset < 0) {
994 h->frame_num_offset += 256;
995 }
996 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
997 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
998 return -1;
999 }
1000 } else {
1001 h->prev_frame_num = h->frame_num;
1002 h->frame_num = h->slice_num;
1003 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
da3b9756 1004
76de302d
DB
1005 if (h->prev_frame_num_offset < 0) {
1006 h->prev_frame_num_offset += 256;
1007 }
da3b9756 1008 }
da3b9756 1009
76de302d
DB
1010 for (m = 0; m < 2; m++){
1011 int i;
1012 for (i = 0; i < 4; i++){
1013 int j;
1014 for (j = -1; j < 4; j++)
1015 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1016 if (i < 3)
1017 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1018 }
da3b9756 1019 }
da3b9756 1020
76de302d
DB
1021 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1022 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1023 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
115329f1 1024
76de302d
DB
1025 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1026 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
da3b9756 1027
8dfc6d1f 1028 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
76de302d 1029 s->gb.size_in_bits = 8*buf_size;
da3b9756 1030
8dfc6d1f 1031 if (svq3_decode_slice_header(avctx))
76de302d 1032 return -1;
da3b9756 1033
76de302d
DB
1034 /* TODO: support s->mb_skip_run */
1035 }
da3b9756 1036
76de302d 1037 mb_type = svq3_get_ue_golomb(&s->gb);
da3b9756 1038
975a1447 1039 if (s->pict_type == AV_PICTURE_TYPE_I) {
76de302d 1040 mb_type += 8;
975a1447 1041 } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
76de302d
DB
1042 mb_type += 4;
1043 }
93d06bd1 1044 if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
76de302d
DB
1045 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1046 return -1;
1047 }
8b82a956 1048
76de302d 1049 if (mb_type != 0) {
903d58f6 1050 ff_h264_hl_decode_mb (h);
76de302d 1051 }
8b82a956 1052
975a1447 1053 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
76de302d 1054 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
975a1447 1055 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
76de302d
DB
1056 }
1057 }
2e26c8d2 1058
76de302d 1059 ff_draw_horiz_band(s, 16*s->mb_y, 16);
8b82a956 1060 }
4c701ac8 1061
76de302d 1062 MPV_frame_end(s);
8b82a956 1063
975a1447 1064 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
76de302d
DB
1065 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1066 } else {
1067 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1068 }
da3b9756 1069
76de302d
DB
1070 /* Do not output the last pic after seeking. */
1071 if (s->last_picture_ptr || s->low_delay) {
1072 *data_size = sizeof(AVFrame);
1073 }
da3b9756 1074
76de302d 1075 return buf_size;
8b82a956
MN
1076}
1077
8dfc6d1f
BC
1078static int svq3_decode_end(AVCodecContext *avctx)
1079{
1080 SVQ3Context *svq3 = avctx->priv_data;
1081 H264Context *h = &svq3->h;
1082 MpegEncContext *s = &h->s;
1083
1084 ff_h264_free_context(h);
1085
1086 MPV_common_end(s);
1087
1088 return 0;
1089}
8b82a956 1090
d36beb3f 1091AVCodec ff_svq3_decoder = {
8b82a956 1092 "svq3",
72415b2a 1093 AVMEDIA_TYPE_VIDEO,
8b82a956 1094 CODEC_ID_SVQ3,
8dfc6d1f 1095 sizeof(SVQ3Context),
f4cca718 1096 svq3_decode_init,
8b82a956 1097 NULL,
8dfc6d1f 1098 svq3_decode_end,
8b82a956 1099 svq3_decode_frame,
934982c4 1100 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
2917367c 1101 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
2ba83017 1102 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
8b82a956 1103};