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