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