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