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