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