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