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