H.264: fix CODEC_FLAG_GRAY
[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
903d58f6 592 ff_h264_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) {
504811ba
JGG
636 memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
637 s->dsp.clear_blocks(h->mb);
884182b3 638 }
2e26c8d2 639
975a1447 640 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
76de302d
DB
641 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
642 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
643 return -1;
644 }
8b82a956 645
76de302d 646 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
884182b3 647 }
975a1447 648 if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
76de302d 649 s->qscale += svq3_get_se_golomb(&s->gb);
8b82a956 650
76de302d
DB
651 if (s->qscale > 31){
652 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
bb270c08 653 return -1;
bb270c08 654 }
8b82a956 655 }
76de302d 656 if (IS_INTRA16x16(mb_type)) {
504811ba
JGG
657 AV_ZERO128(h->mb_luma_dc+0);
658 AV_ZERO128(h->mb_luma_dc+8);
290fabc6 659 if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
76de302d
DB
660 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
661 return -1;
884182b3 662 }
76de302d 663 }
8b82a956 664
76de302d
DB
665 if (cbp) {
666 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
667 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
668
669 for (i = 0; i < 4; i++) {
670 if ((cbp & (1 << i))) {
671 for (j = 0; j < 4; j++) {
672 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
673 h->non_zero_count_cache[ scan8[k] ] = 1;
674
675 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
676 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
677 return -1;
678 }
679 }
680 }
681 }
8b82a956 682
76de302d 683 if ((cbp & 0x30)) {
504811ba
JGG
684 for (i = 0; i < 2; ++i) {
685 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
66c6b5e2
RB
686 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
687 return -1;
688 }
76de302d
DB
689 }
690
691 if ((cbp & 0x20)) {
504811ba
JGG
692 for (i = 0; i < 8; i++) {
693 h->non_zero_count_cache[ scan8[16+i] ] = 1;
694
695 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
696 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
697 return -1;
76de302d
DB
698 }
699 }
700 }
bb270c08 701 }
8b82a956 702 }
8b82a956 703
2a5a9c28 704 h->cbp= cbp;
76de302d 705 s->current_picture.mb_type[mb_xy] = mb_type;
8b82a956 706
76de302d 707 if (IS_INTRA(mb_type)) {
903d58f6 708 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
76de302d 709 }
8b82a956 710
76de302d 711 return 0;
8b82a956
MN
712}
713
8dfc6d1f 714static int svq3_decode_slice_header(AVCodecContext *avctx)
7f8205da 715{
8dfc6d1f
BC
716 SVQ3Context *svq3 = avctx->priv_data;
717 H264Context *h = &svq3->h;
718 MpegEncContext *s = &h->s;
76de302d
DB
719 const int mb_xy = h->mb_xy;
720 int i, header;
da3b9756 721
76de302d 722 header = get_bits(&s->gb, 8);
da3b9756 723
76de302d
DB
724 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
725 /* TODO: what? */
8dfc6d1f 726 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
76de302d
DB
727 return -1;
728 } else {
729 int length = (header >> 5) & 3;
da3b9756 730
8dfc6d1f 731 svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
da3b9756 732
8dfc6d1f
BC
733 if (svq3->next_slice_index > s->gb.size_in_bits) {
734 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
76de302d 735 return -1;
303e50e6 736 }
da3b9756 737
8dfc6d1f 738 s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
76de302d 739 skip_bits(&s->gb, 8);
da3b9756 740
8dfc6d1f 741 if (svq3->watermark_key) {
76de302d 742 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
8dfc6d1f 743 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
76de302d
DB
744 }
745 if (length > 0) {
746 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
747 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
748 }
db794291 749 skip_bits_long(&s->gb, 0);
da3b9756 750 }
da3b9756 751
76de302d
DB
752 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
753 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
754 return -1;
755 }
da3b9756 756
76de302d 757 h->slice_type = golomb_to_pict_type[i];
da3b9756 758
76de302d
DB
759 if ((header & 0x9F) == 2) {
760 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
761 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
762 } else {
763 skip_bits1(&s->gb);
764 s->mb_skip_run = 0;
765 }
da3b9756 766
76de302d
DB
767 h->slice_num = get_bits(&s->gb, 8);
768 s->qscale = get_bits(&s->gb, 5);
769 s->adaptive_quant = get_bits1(&s->gb);
da3b9756 770
76de302d
DB
771 /* unknown fields */
772 skip_bits1(&s->gb);
da3b9756 773
8dfc6d1f 774 if (svq3->unknown_flag) {
76de302d
DB
775 skip_bits1(&s->gb);
776 }
da3b9756 777
76de302d
DB
778 skip_bits1(&s->gb);
779 skip_bits(&s->gb, 2);
da3b9756 780
76de302d
DB
781 while (get_bits1(&s->gb)) {
782 skip_bits(&s->gb, 8);
783 }
da3b9756 784
76de302d 785 /* reset intra predictors and invalidate motion vector references */
da3b9756 786 if (s->mb_x > 0) {
3b606e71
MN
787 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t));
788 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x);
76de302d
DB
789 }
790 if (s->mb_y > 0) {
3b606e71 791 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
792
793 if (s->mb_x > 0) {
3b606e71 794 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
76de302d 795 }
da3b9756 796 }
da3b9756 797
76de302d 798 return 0;
da3b9756
MM
799}
800
5ef251e5 801static av_cold int svq3_decode_init(AVCodecContext *avctx)
7f8205da 802{
8dfc6d1f
BC
803 SVQ3Context *svq3 = avctx->priv_data;
804 H264Context *h = &svq3->h;
805 MpegEncContext *s = &h->s;
f4cca718 806 int m;
76de302d
DB
807 unsigned char *extradata;
808 unsigned int size;
809
903d58f6 810 if (ff_h264_decode_init(avctx) < 0)
f4cca718
BC
811 return -1;
812
76de302d
DB
813 s->flags = avctx->flags;
814 s->flags2 = avctx->flags2;
815 s->unrestricted_mv = 1;
54dab661 816 h->is_complex=1;
94621d32 817 avctx->pix_fmt = avctx->codec->pix_fmts[0];
76de302d
DB
818
819 if (!s->context_initialized) {
8dfc6d1f
BC
820 h->chroma_qp[0] = h->chroma_qp[1] = 4;
821
822 svq3->halfpel_flag = 1;
823 svq3->thirdpel_flag = 1;
824 svq3->unknown_flag = 0;
76de302d 825
76de302d
DB
826 /* prowl for the "SEQH" marker in the extradata */
827 extradata = (unsigned char *)avctx->extradata;
828 for (m = 0; m < avctx->extradata_size; m++) {
829 if (!memcmp(extradata, "SEQH", 4))
830 break;
831 extradata++;
832 }
8b82a956 833
76de302d
DB
834 /* if a match was found, parse the extra data */
835 if (extradata && !memcmp(extradata, "SEQH", 4)) {
8b82a956 836
76de302d 837 GetBitContext gb;
faccfeec 838 int frame_size_code;
8b82a956 839
76de302d
DB
840 size = AV_RB32(&extradata[4]);
841 init_get_bits(&gb, extradata + 8, size*8);
8b82a956 842
76de302d 843 /* 'frame size code' and optional 'width, height' */
faccfeec
RB
844 frame_size_code = get_bits(&gb, 3);
845 switch (frame_size_code) {
846 case 0: avctx->width = 160; avctx->height = 120; break;
847 case 1: avctx->width = 128; avctx->height = 96; break;
848 case 2: avctx->width = 176; avctx->height = 144; break;
849 case 3: avctx->width = 352; avctx->height = 288; break;
850 case 4: avctx->width = 704; avctx->height = 576; break;
851 case 5: avctx->width = 240; avctx->height = 180; break;
852 case 6: avctx->width = 320; avctx->height = 240; break;
853 case 7:
854 avctx->width = get_bits(&gb, 12);
855 avctx->height = get_bits(&gb, 12);
856 break;
76de302d 857 }
8b82a956 858
8dfc6d1f
BC
859 svq3->halfpel_flag = get_bits1(&gb);
860 svq3->thirdpel_flag = get_bits1(&gb);
8b82a956 861
76de302d
DB
862 /* unknown fields */
863 skip_bits1(&gb);
864 skip_bits1(&gb);
865 skip_bits1(&gb);
866 skip_bits1(&gb);
8b82a956 867
76de302d 868 s->low_delay = get_bits1(&gb);
1e002b60 869
76de302d
DB
870 /* unknown field */
871 skip_bits1(&gb);
872
873 while (get_bits1(&gb)) {
874 skip_bits(&gb, 8);
875 }
876
8dfc6d1f 877 svq3->unknown_flag = get_bits1(&gb);
76de302d 878 avctx->has_b_frames = !s->low_delay;
8dfc6d1f 879 if (svq3->unknown_flag) {
b250f9c6 880#if CONFIG_ZLIB
76de302d
DB
881 unsigned watermark_width = svq3_get_ue_golomb(&gb);
882 unsigned watermark_height = svq3_get_ue_golomb(&gb);
883 int u1 = svq3_get_ue_golomb(&gb);
884 int u2 = get_bits(&gb, 8);
885 int u3 = get_bits(&gb, 2);
886 int u4 = svq3_get_ue_golomb(&gb);
891263ef 887 unsigned long buf_len = watermark_width*watermark_height*4;
76de302d
DB
888 int offset = (get_bits_count(&gb)+7)>>3;
889 uint8_t *buf;
890
891 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
892 return -1;
893
894 buf = av_malloc(buf_len);
895 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
896 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 897 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
76de302d
DB
898 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
899 av_free(buf);
900 return -1;
901 }
8dfc6d1f
BC
902 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
903 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
904 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
76de302d 905 av_free(buf);
1e002b60 906#else
76de302d
DB
907 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
908 return -1;
1e002b60 909#endif
76de302d
DB
910 }
911 }
cdca7c37
RB
912
913 s->width = avctx->width;
914 s->height = avctx->height;
915
916 if (MPV_common_init(s) < 0)
917 return -1;
918
919 h->b_stride = 4*s->mb_width;
920
921 ff_h264_alloc_tables(h);
da3b9756 922 }
76de302d 923
f4cca718
BC
924 return 0;
925}
926
927static int svq3_decode_frame(AVCodecContext *avctx,
928 void *data, int *data_size,
7a00bbad 929 AVPacket *avpkt)
f4cca718 930{
7a00bbad 931 const uint8_t *buf = avpkt->data;
8dfc6d1f
BC
932 SVQ3Context *svq3 = avctx->priv_data;
933 H264Context *h = &svq3->h;
934 MpegEncContext *s = &h->s;
7a00bbad 935 int buf_size = avpkt->size;
f4cca718
BC
936 int m, mb_type;
937
76de302d
DB
938 /* special case for last picture */
939 if (buf_size == 0) {
940 if (s->next_picture_ptr && !s->low_delay) {
941 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
942 s->next_picture_ptr = NULL;
943 *data_size = sizeof(AVFrame);
944 }
945 return 0;
da3b9756 946 }
8b82a956 947
76de302d 948 init_get_bits (&s->gb, buf, 8*buf_size);
8b82a956 949
76de302d 950 s->mb_x = s->mb_y = h->mb_xy = 0;
8b82a956 951
8dfc6d1f 952 if (svq3_decode_slice_header(avctx))
76de302d 953 return -1;
8b82a956 954
76de302d
DB
955 s->pict_type = h->slice_type;
956 s->picture_number = h->slice_num;
8b82a956 957
76de302d
DB
958 if (avctx->debug&FF_DEBUG_PICT_INFO){
959 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
8dfc6d1f 960 av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
76de302d
DB
961 s->adaptive_quant, s->qscale, h->slice_num);
962 }
8b82a956 963
8ed2ae09 964 /* for skipping the frame */
76de302d 965 s->current_picture.pict_type = s->pict_type;
975a1447 966 s->current_picture.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
76de302d
DB
967
968 /* Skip B-frames if we do not have reference frames. */
975a1447 969 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
76de302d 970 return 0;
975a1447
SS
971 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
972 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
76de302d
DB
973 || avctx->skip_frame >= AVDISCARD_ALL)
974 return 0;
975
976 if (s->next_p_frame_damaged) {
975a1447 977 if (s->pict_type == AV_PICTURE_TYPE_B)
76de302d
DB
978 return 0;
979 else
980 s->next_p_frame_damaged = 0;
981 }
da3b9756 982
903d58f6 983 if (ff_h264_frame_start(h) < 0)
76de302d 984 return -1;
8b82a956 985
975a1447 986 if (s->pict_type == AV_PICTURE_TYPE_B) {
76de302d 987 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
8b82a956 988
76de302d
DB
989 if (h->frame_num_offset < 0) {
990 h->frame_num_offset += 256;
991 }
992 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
993 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
994 return -1;
995 }
996 } else {
997 h->prev_frame_num = h->frame_num;
998 h->frame_num = h->slice_num;
999 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
da3b9756 1000
76de302d
DB
1001 if (h->prev_frame_num_offset < 0) {
1002 h->prev_frame_num_offset += 256;
1003 }
da3b9756 1004 }
da3b9756 1005
76de302d
DB
1006 for (m = 0; m < 2; m++){
1007 int i;
1008 for (i = 0; i < 4; i++){
1009 int j;
1010 for (j = -1; j < 4; j++)
1011 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1012 if (i < 3)
1013 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1014 }
da3b9756 1015 }
da3b9756 1016
76de302d
DB
1017 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1018 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1019 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
115329f1 1020
76de302d
DB
1021 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1022 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
da3b9756 1023
8dfc6d1f 1024 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
76de302d 1025 s->gb.size_in_bits = 8*buf_size;
da3b9756 1026
8dfc6d1f 1027 if (svq3_decode_slice_header(avctx))
76de302d 1028 return -1;
da3b9756 1029
76de302d
DB
1030 /* TODO: support s->mb_skip_run */
1031 }
da3b9756 1032
76de302d 1033 mb_type = svq3_get_ue_golomb(&s->gb);
da3b9756 1034
975a1447 1035 if (s->pict_type == AV_PICTURE_TYPE_I) {
76de302d 1036 mb_type += 8;
975a1447 1037 } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
76de302d
DB
1038 mb_type += 4;
1039 }
93d06bd1 1040 if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
76de302d
DB
1041 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1042 return -1;
1043 }
8b82a956 1044
76de302d 1045 if (mb_type != 0) {
903d58f6 1046 ff_h264_hl_decode_mb (h);
76de302d 1047 }
8b82a956 1048
975a1447 1049 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
76de302d 1050 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
975a1447 1051 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
76de302d
DB
1052 }
1053 }
2e26c8d2 1054
76de302d 1055 ff_draw_horiz_band(s, 16*s->mb_y, 16);
8b82a956 1056 }
4c701ac8 1057
76de302d 1058 MPV_frame_end(s);
8b82a956 1059
975a1447 1060 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
76de302d
DB
1061 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1062 } else {
1063 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1064 }
da3b9756 1065
76de302d
DB
1066 /* Do not output the last pic after seeking. */
1067 if (s->last_picture_ptr || s->low_delay) {
1068 *data_size = sizeof(AVFrame);
1069 }
da3b9756 1070
76de302d 1071 return buf_size;
8b82a956
MN
1072}
1073
8dfc6d1f
BC
1074static int svq3_decode_end(AVCodecContext *avctx)
1075{
1076 SVQ3Context *svq3 = avctx->priv_data;
1077 H264Context *h = &svq3->h;
1078 MpegEncContext *s = &h->s;
1079
1080 ff_h264_free_context(h);
1081
1082 MPV_common_end(s);
1083
1084 return 0;
1085}
8b82a956 1086
d36beb3f 1087AVCodec ff_svq3_decoder = {
8b82a956 1088 "svq3",
72415b2a 1089 AVMEDIA_TYPE_VIDEO,
8b82a956 1090 CODEC_ID_SVQ3,
8dfc6d1f 1091 sizeof(SVQ3Context),
f4cca718 1092 svq3_decode_init,
8b82a956 1093 NULL,
8dfc6d1f 1094 svq3_decode_end,
8b82a956 1095 svq3_decode_frame,
934982c4 1096 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
2917367c 1097 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
2ba83017 1098 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
8b82a956 1099};