Update to MPlayer SVN rev 30302 and FFmpeg SVN rev 21211.
[vaapi:sewalliniusms-mplayer.git] / libavcodec / .svn / text-base / svq3.c.svn-base
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 ARCH_X86
56 #include "x86/h264_i386.h"
57 #endif
58
59 #if CONFIG_ZLIB
60 #include <zlib.h>
61 #endif
62
63 #include "svq1.h"
64
65 /**
66  * @file libavcodec/svq3.c
67  * svq3 decoder.
68  */
69
70 #define FULLPEL_MODE  1
71 #define HALFPEL_MODE  2
72 #define THIRDPEL_MODE 3
73 #define PREDICT_MODE  4
74
75 /* dual scan (from some older h264 draft)
76  o-->o-->o   o
77          |  /|
78  o   o   o / o
79  | / |   |/  |
80  o   o   o   o
81    /
82  o-->o-->o-->o
83 */
84 static const uint8_t svq3_scan[16] = {
85     0+0*4, 1+0*4, 2+0*4, 2+1*4,
86     2+2*4, 3+0*4, 3+1*4, 3+2*4,
87     0+1*4, 0+2*4, 1+1*4, 1+2*4,
88     0+3*4, 1+3*4, 2+3*4, 3+3*4,
89 };
90
91 static const uint8_t svq3_pred_0[25][2] = {
92     { 0, 0 },
93     { 1, 0 }, { 0, 1 },
94     { 0, 2 }, { 1, 1 }, { 2, 0 },
95     { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
96     { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
97     { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
98     { 2, 4 }, { 3, 3 }, { 4, 2 },
99     { 4, 3 }, { 3, 4 },
100     { 4, 4 }
101 };
102
103 static const int8_t svq3_pred_1[6][6][5] = {
104     { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
105       { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
106     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
107       { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
108     { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
109       { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
110     { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
111       { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
112     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
113       { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
114     { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
115       { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
116 };
117
118 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
119     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
120       { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
121     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
122       { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
123 };
124
125 static const uint32_t svq3_dequant_coeff[32] = {
126      3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
127      9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
128     24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
129     61694, 68745, 77615, 89113,100253,109366,126635,141533
130 };
131
132
133 void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp)
134 {
135     const int qmul = svq3_dequant_coeff[qp];
136 #define stride 16
137     int i;
138     int temp[16];
139     static const int x_offset[4] = {0, 1*stride, 4* stride,  5*stride};
140     static const int y_offset[4] = {0, 2*stride, 8* stride, 10*stride};
141
142     for (i = 0; i < 4; i++){
143         const int offset = y_offset[i];
144         const int z0 = 13*(block[offset+stride*0] +    block[offset+stride*4]);
145         const int z1 = 13*(block[offset+stride*0] -    block[offset+stride*4]);
146         const int z2 =  7* block[offset+stride*1] - 17*block[offset+stride*5];
147         const int z3 = 17* block[offset+stride*1] +  7*block[offset+stride*5];
148
149         temp[4*i+0] = z0+z3;
150         temp[4*i+1] = z1+z2;
151         temp[4*i+2] = z1-z2;
152         temp[4*i+3] = z0-z3;
153     }
154
155     for (i = 0; i < 4; i++){
156         const int offset = x_offset[i];
157         const int z0 = 13*(temp[4*0+i] +    temp[4*2+i]);
158         const int z1 = 13*(temp[4*0+i] -    temp[4*2+i]);
159         const int z2 =  7* temp[4*1+i] - 17*temp[4*3+i];
160         const int z3 = 17* temp[4*1+i] +  7*temp[4*3+i];
161
162         block[stride*0 +offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
163         block[stride*2 +offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
164         block[stride*8 +offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
165         block[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
166     }
167 }
168 #undef stride
169
170 void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
171                             int dc)
172 {
173     const int qmul = svq3_dequant_coeff[qp];
174     int i;
175     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
176
177     if (dc) {
178         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
179         block[0] = 0;
180     }
181
182     for (i = 0; i < 4; i++) {
183         const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
184         const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
185         const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
186         const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
187
188         block[0 + 4*i] = z0 + z3;
189         block[1 + 4*i] = z1 + z2;
190         block[2 + 4*i] = z1 - z2;
191         block[3 + 4*i] = z0 - z3;
192     }
193
194     for (i = 0; i < 4; i++) {
195         const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
196         const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
197         const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
198         const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
199         const int rr = (dc + 0x80000);
200
201         dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
202         dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
203         dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
204         dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
205     }
206 }
207
208 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
209                                     int index, const int type)
210 {
211     static const uint8_t *const scan_patterns[4] =
212     { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
213
214     int run, level, sign, vlc, limit;
215     const int intra = (3 * type) >> 2;
216     const uint8_t *const scan = scan_patterns[type];
217
218     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
219         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
220
221           if (vlc == INVALID_VLC)
222               return -1;
223
224           sign = (vlc & 0x1) - 1;
225           vlc  = (vlc + 1) >> 1;
226
227           if (type == 3) {
228               if (vlc < 3) {
229                   run   = 0;
230                   level = vlc;
231               } else if (vlc < 4) {
232                   run   = 1;
233                   level = 1;
234               } else {
235                   run   = (vlc & 0x3);
236                   level = ((vlc + 9) >> 2) - run;
237               }
238           } else {
239               if (vlc < 16) {
240                   run   = svq3_dct_tables[intra][vlc].run;
241                   level = svq3_dct_tables[intra][vlc].level;
242               } else if (intra) {
243                   run   = (vlc & 0x7);
244                   level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
245               } else {
246                   run   = (vlc & 0xF);
247                   level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
248               }
249           }
250
251           if ((index += run) >= limit)
252               return -1;
253
254           block[scan[index]] = (level ^ sign) - sign;
255         }
256
257         if (type != 2) {
258             break;
259         }
260     }
261
262     return 0;
263 }
264
265 static inline void svq3_mc_dir_part(MpegEncContext *s,
266                                     int x, int y, int width, int height,
267                                     int mx, int my, int dxy,
268                                     int thirdpel, int dir, int avg)
269 {
270     const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
271     uint8_t *src, *dest;
272     int i, emu = 0;
273     int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
274
275     mx += x;
276     my += y;
277
278     if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
279         my < 0 || my >= (s->v_edge_pos - height - 1)) {
280
281         if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
282             emu = 1;
283         }
284
285         mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
286         my = av_clip (my, -16, (s->v_edge_pos - height + 15));
287     }
288
289     /* form component predictions */
290     dest = s->current_picture.data[0] + x + y*s->linesize;
291     src  = pic->data[0] + mx + my*s->linesize;
292
293     if (emu) {
294         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
295                             mx, my, s->h_edge_pos, s->v_edge_pos);
296         src = s->edge_emu_buffer;
297     }
298     if (thirdpel)
299         (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
300     else
301         (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
302
303     if (!(s->flags & CODEC_FLAG_GRAY)) {
304         mx     = (mx + (mx < (int) x)) >> 1;
305         my     = (my + (my < (int) y)) >> 1;
306         width  = (width  >> 1);
307         height = (height >> 1);
308         blocksize++;
309
310         for (i = 1; i < 3; i++) {
311             dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
312             src  = pic->data[i] + mx + my*s->uvlinesize;
313
314             if (emu) {
315                 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
316                                     mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
317                 src = s->edge_emu_buffer;
318             }
319             if (thirdpel)
320                 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
321             else
322                 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
323         }
324     }
325 }
326
327 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
328                               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 = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
363             my = av_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) {
373                     av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
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
434 static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
435 {
436     int i, j, k, m, dir, mode;
437     int cbp = 0;
438     uint32_t vlc;
439     int8_t *top, *left;
440     MpegEncContext *const s = (MpegEncContext *) h;
441     const int mb_xy = h->mb_xy;
442     const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
443
444     h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
445     h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
446     h->topright_samples_available = 0xFFFF;
447
448     if (mb_type == 0) {           /* SKIP */
449         if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
450             svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
451
452             if (s->pict_type == FF_B_TYPE) {
453                 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
454             }
455
456             mb_type = MB_TYPE_SKIP;
457         } else {
458             mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
459             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
460                 return -1;
461             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
462                 return -1;
463
464             mb_type = MB_TYPE_16x16;
465         }
466     } else if (mb_type < 8) {     /* INTER */
467         if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
468             mode = THIRDPEL_MODE;
469         } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
470             mode = HALFPEL_MODE;
471         } else {
472             mode = FULLPEL_MODE;
473         }
474
475         /* fill caches */
476         /* note ref_cache should contain here:
477             ????????
478             ???11111
479             N??11111
480             N??11111
481             N??11111
482         */
483
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                 }
493             }
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) {
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];
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;
510             }else
511                 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
512
513             if (s->pict_type != FF_B_TYPE)
514                 break;
515         }
516
517         /* decode motion vector(s) and form prediction(s) */
518         if (s->pict_type == FF_P_TYPE) {
519             if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
520                 return -1;
521         } else {        /* FF_B_TYPE */
522             if (mb_type != 2) {
523                 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
524                     return -1;
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));
528                 }
529             }
530             if (mb_type != 1) {
531                 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
532                     return -1;
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             }
538         }
539
540         mb_type = MB_TYPE_16x16;
541     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
542         memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
543
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                 }
562             }
563
564             /* decode prediction codes for luma blocks */
565             for (i = 0; i < 16; i+=2) {
566                 vlc = svq3_get_ue_golomb(&s->gb);
567
568                 if (vlc >= 25){
569                     av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
570                     return -1;
571                 }
572
573                 left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
574                 top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
575
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]];
578
579                 if (left[1] == -1 || left[2] == -1){
580                     av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
581                     return -1;
582                 }
583             }
584         } else {    /* mb_type == 33, DC_128_PRED block type */
585             for (i = 0; i < 4; i++) {
586                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
587             }
588         }
589
590         ff_h264_write_back_intra_pred_mode(h);
591
592         if (mb_type == 8) {
593             ff_h264_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         }
605
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
611         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
612             av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
613             return -1;
614         }
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 != FF_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         }
624         if (s->pict_type == FF_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         }
629     }
630     if (!IS_INTRA4x4(mb_type)) {
631         memset(h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
632     }
633     if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
634         memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
635         s->dsp.clear_blocks(h->mb);
636     }
637
638     if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
639         if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
640             av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
641             return -1;
642         }
643
644         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
645     }
646     if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
647         s->qscale += svq3_get_se_golomb(&s->gb);
648
649         if (s->qscale > 31){
650             av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
651             return -1;
652         }
653     }
654     if (IS_INTRA16x16(mb_type)) {
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");
657             return -1;
658         }
659     }
660
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);
664
665         for (i = 0; i < 4; i++) {
666             if ((cbp & (1 << i))) {
667                 for (j = 0; j < 4; j++) {
668                     k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
669                     h->non_zero_count_cache[ scan8[k] ] = 1;
670
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");
673                         return -1;
674                     }
675                 }
676             }
677         }
678
679         if ((cbp & 0x30)) {
680             for (i = 0; i < 2; ++i) {
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");
683                 return -1;
684               }
685             }
686
687             if ((cbp & 0x20)) {
688                 for (i = 0; i < 8; i++) {
689                     h->non_zero_count_cache[ scan8[16+i] ] = 1;
690
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");
693                         return -1;
694                     }
695                 }
696             }
697         }
698     }
699
700     h->cbp= cbp;
701     s->current_picture.mb_type[mb_xy] = mb_type;
702
703     if (IS_INTRA(mb_type)) {
704         h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
705     }
706
707     return 0;
708 }
709
710 static int svq3_decode_slice_header(H264Context *h)
711 {
712     MpegEncContext *const s = (MpegEncContext *) h;
713     const int mb_xy = h->mb_xy;
714     int i, header;
715
716     header = get_bits(&s->gb, 8);
717
718     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
719         /* TODO: what? */
720         av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
721         return -1;
722     } else {
723         int length = (header >> 5) & 3;
724
725         h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
726
727         if (h->next_slice_index > s->gb.size_in_bits) {
728             av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
729             return -1;
730     }
731
732         s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
733         skip_bits(&s->gb, 8);
734
735         if (h->svq3_watermark_key) {
736             uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
737             AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
738         }
739         if (length > 0) {
740             memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
741                    &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
742         }
743         skip_bits_long(&s->gb, 0);
744     }
745
746     if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
747         av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
748         return -1;
749     }
750
751     h->slice_type = golomb_to_pict_type[i];
752
753     if ((header & 0x9F) == 2) {
754         i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
755         s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
756     } else {
757         skip_bits1(&s->gb);
758         s->mb_skip_run = 0;
759     }
760
761     h->slice_num = get_bits(&s->gb, 8);
762     s->qscale = get_bits(&s->gb, 5);
763     s->adaptive_quant = get_bits1(&s->gb);
764
765     /* unknown fields */
766     skip_bits1(&s->gb);
767
768     if (h->unknown_svq3_flag) {
769         skip_bits1(&s->gb);
770     }
771
772     skip_bits1(&s->gb);
773     skip_bits(&s->gb, 2);
774
775     while (get_bits1(&s->gb)) {
776         skip_bits(&s->gb, 8);
777     }
778
779     /* reset intra predictors and invalidate motion vector references */
780     if (s->mb_x > 0) {
781         memset(h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
782         memset(h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
783     }
784     if (s->mb_y > 0) {
785         memset(h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
786
787         if (s->mb_x > 0) {
788             h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
789         }
790     }
791
792     return 0;
793 }
794
795 static av_cold int svq3_decode_init(AVCodecContext *avctx)
796 {
797     MpegEncContext *const s = avctx->priv_data;
798     H264Context *const h = avctx->priv_data;
799     int m;
800     unsigned char *extradata;
801     unsigned int size;
802
803     if(avctx->thread_count > 1){
804         av_log(avctx, AV_LOG_ERROR, "SVQ3 does not support multithreaded decoding, patch welcome! (check latest SVN too)\n");
805         return -1;
806     }
807
808     if (ff_h264_decode_init(avctx) < 0)
809         return -1;
810
811     s->flags  = avctx->flags;
812     s->flags2 = avctx->flags2;
813     s->unrestricted_mv = 1;
814     h->is_complex=1;
815     avctx->pix_fmt = avctx->codec->pix_fmts[0];
816
817     if (!s->context_initialized) {
818         s->width  = avctx->width;
819         s->height = avctx->height;
820         h->halfpel_flag      = 1;
821         h->thirdpel_flag     = 1;
822         h->unknown_svq3_flag = 0;
823         h->chroma_qp[0]      = h->chroma_qp[1] = 4;
824
825         if (MPV_common_init(s) < 0)
826             return -1;
827
828         h->b_stride = 4*s->mb_width;
829
830         ff_h264_alloc_tables(h);
831
832         /* prowl for the "SEQH" marker in the extradata */
833         extradata = (unsigned char *)avctx->extradata;
834         for (m = 0; m < avctx->extradata_size; m++) {
835             if (!memcmp(extradata, "SEQH", 4))
836                 break;
837             extradata++;
838         }
839
840         /* if a match was found, parse the extra data */
841         if (extradata && !memcmp(extradata, "SEQH", 4)) {
842
843             GetBitContext gb;
844             int frame_size_code;
845
846             size = AV_RB32(&extradata[4]);
847             init_get_bits(&gb, extradata + 8, size*8);
848
849             /* 'frame size code' and optional 'width, height' */
850             frame_size_code = get_bits(&gb, 3);
851             switch (frame_size_code) {
852                 case 0: avctx->width = 160; avctx->height = 120; break;
853                 case 1: avctx->width = 128; avctx->height =  96; break;
854                 case 2: avctx->width = 176; avctx->height = 144; break;
855                 case 3: avctx->width = 352; avctx->height = 288; break;
856                 case 4: avctx->width = 704; avctx->height = 576; break;
857                 case 5: avctx->width = 240; avctx->height = 180; break;
858                 case 6: avctx->width = 320; avctx->height = 240; break;
859                 case 7:
860                     avctx->width  = get_bits(&gb, 12);
861                     avctx->height = get_bits(&gb, 12);
862                     break;
863             }
864
865             h->halfpel_flag  = get_bits1(&gb);
866             h->thirdpel_flag = get_bits1(&gb);
867
868             /* unknown fields */
869             skip_bits1(&gb);
870             skip_bits1(&gb);
871             skip_bits1(&gb);
872             skip_bits1(&gb);
873
874             s->low_delay = get_bits1(&gb);
875
876             /* unknown field */
877             skip_bits1(&gb);
878
879             while (get_bits1(&gb)) {
880                 skip_bits(&gb, 8);
881             }
882
883             h->unknown_svq3_flag = get_bits1(&gb);
884             avctx->has_b_frames = !s->low_delay;
885             if (h->unknown_svq3_flag) {
886 #if CONFIG_ZLIB
887                 unsigned watermark_width  = svq3_get_ue_golomb(&gb);
888                 unsigned watermark_height = svq3_get_ue_golomb(&gb);
889                 int u1 = svq3_get_ue_golomb(&gb);
890                 int u2 = get_bits(&gb, 8);
891                 int u3 = get_bits(&gb, 2);
892                 int u4 = svq3_get_ue_golomb(&gb);
893                 unsigned buf_len = watermark_width*watermark_height*4;
894                 int offset = (get_bits_count(&gb)+7)>>3;
895                 uint8_t *buf;
896
897                 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
898                     return -1;
899
900                 buf = av_malloc(buf_len);
901                 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
902                 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
903                 if (uncompress(buf, (uLong*)&buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
904                     av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
905                     av_free(buf);
906                     return -1;
907                 }
908                 h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
909                 h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
910                 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
911                 av_free(buf);
912 #else
913                 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
914                 return -1;
915 #endif
916             }
917         }
918     }
919
920     return 0;
921 }
922
923 static int svq3_decode_frame(AVCodecContext *avctx,
924                              void *data, int *data_size,
925                              AVPacket *avpkt)
926 {
927     const uint8_t *buf = avpkt->data;
928     int buf_size = avpkt->size;
929     MpegEncContext *const s = avctx->priv_data;
930     H264Context *const h = avctx->priv_data;
931     int m, mb_type;
932
933     /* special case for last picture */
934     if (buf_size == 0) {
935         if (s->next_picture_ptr && !s->low_delay) {
936             *(AVFrame *) data = *(AVFrame *) &s->next_picture;
937             s->next_picture_ptr = NULL;
938             *data_size = sizeof(AVFrame);
939         }
940         return 0;
941     }
942
943     init_get_bits (&s->gb, buf, 8*buf_size);
944
945     s->mb_x = s->mb_y = h->mb_xy = 0;
946
947     if (svq3_decode_slice_header(h))
948         return -1;
949
950     s->pict_type = h->slice_type;
951     s->picture_number = h->slice_num;
952
953     if (avctx->debug&FF_DEBUG_PICT_INFO){
954         av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
955                av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
956                s->adaptive_quant, s->qscale, h->slice_num);
957     }
958
959     /* for hurry_up == 5 */
960     s->current_picture.pict_type = s->pict_type;
961     s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
962
963     /* Skip B-frames if we do not have reference frames. */
964     if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
965         return 0;
966     /* Skip B-frames if we are in a hurry. */
967     if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
968         return 0;
969     /* Skip everything if we are in a hurry >= 5. */
970     if (avctx->hurry_up >= 5)
971         return 0;
972     if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
973         ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
974         || avctx->skip_frame >= AVDISCARD_ALL)
975         return 0;
976
977     if (s->next_p_frame_damaged) {
978         if (s->pict_type == FF_B_TYPE)
979             return 0;
980         else
981             s->next_p_frame_damaged = 0;
982     }
983
984     if (ff_h264_frame_start(h) < 0)
985         return -1;
986
987     if (s->pict_type == FF_B_TYPE) {
988         h->frame_num_offset = (h->slice_num - h->prev_frame_num);
989
990         if (h->frame_num_offset < 0) {
991             h->frame_num_offset += 256;
992         }
993         if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
994             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
995             return -1;
996         }
997     } else {
998         h->prev_frame_num = h->frame_num;
999         h->frame_num = h->slice_num;
1000         h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1001
1002         if (h->prev_frame_num_offset < 0) {
1003             h->prev_frame_num_offset += 256;
1004         }
1005     }
1006
1007     for (m = 0; m < 2; m++){
1008         int i;
1009         for (i = 0; i < 4; i++){
1010             int j;
1011             for (j = -1; j < 4; j++)
1012                 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1013             if (i < 3)
1014                 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1015         }
1016     }
1017
1018     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1019         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1020             h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1021
1022             if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1023                 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1024
1025                 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
1026                 s->gb.size_in_bits = 8*buf_size;
1027
1028                 if (svq3_decode_slice_header(h))
1029                     return -1;
1030
1031                 /* TODO: support s->mb_skip_run */
1032             }
1033
1034             mb_type = svq3_get_ue_golomb(&s->gb);
1035
1036             if (s->pict_type == FF_I_TYPE) {
1037                 mb_type += 8;
1038             } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1039                 mb_type += 4;
1040             }
1041             if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1042                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1043                 return -1;
1044             }
1045
1046             if (mb_type != 0) {
1047                 ff_h264_hl_decode_mb (h);
1048             }
1049
1050             if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1051                 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1052                     (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1053             }
1054         }
1055
1056         ff_draw_horiz_band(s, 16*s->mb_y, 16);
1057     }
1058
1059     MPV_frame_end(s);
1060
1061     if (s->pict_type == FF_B_TYPE || s->low_delay) {
1062         *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1063     } else {
1064         *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1065     }
1066
1067     /* Do not output the last pic after seeking. */
1068     if (s->last_picture_ptr || s->low_delay) {
1069         *data_size = sizeof(AVFrame);
1070     }
1071
1072     return buf_size;
1073 }
1074
1075
1076 AVCodec svq3_decoder = {
1077     "svq3",
1078     CODEC_TYPE_VIDEO,
1079     CODEC_ID_SVQ3,
1080     sizeof(H264Context),
1081     svq3_decode_init,
1082     NULL,
1083     ff_h264_decode_end,
1084     svq3_decode_frame,
1085     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1086     .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1087     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1088 };