h264: fix intra 16x16 mode check when using mbaff and constrained_intra_pred.
[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_intra16x16_pred_mode(h, dir)) == -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_chroma_pred_mode(h, DC_PRED8x8);
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 int size;
817
818     if (ff_h264_decode_init(avctx) < 0)
819         return -1;
820
821     s->flags  = avctx->flags;
822     s->flags2 = avctx->flags2;
823     s->unrestricted_mv = 1;
824     h->is_complex=1;
825     avctx->pix_fmt = avctx->codec->pix_fmts[0];
826
827     if (!s->context_initialized) {
828         h->chroma_qp[0] = h->chroma_qp[1] = 4;
829
830         svq3->halfpel_flag  = 1;
831         svq3->thirdpel_flag = 1;
832         svq3->unknown_flag  = 0;
833
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         s->width  = avctx->width;
923         s->height = avctx->height;
924
925         if (MPV_common_init(s) < 0)
926             return -1;
927
928         h->b_stride = 4*s->mb_width;
929
930         if (ff_h264_alloc_tables(h) < 0) {
931             av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
932             return AVERROR(ENOMEM);
933         }
934     }
935
936     return 0;
937 }
938
939 static int svq3_decode_frame(AVCodecContext *avctx,
940                              void *data, int *data_size,
941                              AVPacket *avpkt)
942 {
943     SVQ3Context *svq3 = avctx->priv_data;
944     H264Context *h = &svq3->h;
945     MpegEncContext *s = &h->s;
946     int buf_size = avpkt->size;
947     int m, mb_type, left;
948     uint8_t *buf;
949
950     /* special case for last picture */
951     if (buf_size == 0) {
952         if (s->next_picture_ptr && !s->low_delay) {
953             *(AVFrame *) data = *(AVFrame *) &s->next_picture;
954             s->next_picture_ptr = NULL;
955             *data_size = sizeof(AVFrame);
956         }
957         return 0;
958     }
959
960     s->mb_x = s->mb_y = h->mb_xy = 0;
961
962     if (svq3->watermark_key) {
963         av_fast_malloc(&svq3->buf, &svq3->buf_size,
964                        buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
965         if (!svq3->buf)
966             return AVERROR(ENOMEM);
967         memcpy(svq3->buf, avpkt->data, buf_size);
968         buf = svq3->buf;
969     } else {
970         buf = avpkt->data;
971     }
972
973     init_get_bits(&s->gb, buf, 8*buf_size);
974
975     if (svq3_decode_slice_header(avctx))
976         return -1;
977
978     s->pict_type = h->slice_type;
979     s->picture_number = h->slice_num;
980
981     if (avctx->debug&FF_DEBUG_PICT_INFO){
982         av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
983                av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
984                s->adaptive_quant, s->qscale, h->slice_num);
985     }
986
987     /* for skipping the frame */
988     s->current_picture.f.pict_type = s->pict_type;
989     s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
990
991     /* Skip B-frames if we do not have reference frames. */
992     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
993         return 0;
994     if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
995         ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
996         || avctx->skip_frame >= AVDISCARD_ALL)
997         return 0;
998
999     if (s->next_p_frame_damaged) {
1000         if (s->pict_type == AV_PICTURE_TYPE_B)
1001             return 0;
1002         else
1003             s->next_p_frame_damaged = 0;
1004     }
1005
1006     if (ff_h264_frame_start(h) < 0)
1007         return -1;
1008
1009     if (s->pict_type == AV_PICTURE_TYPE_B) {
1010         h->frame_num_offset = (h->slice_num - h->prev_frame_num);
1011
1012         if (h->frame_num_offset < 0) {
1013             h->frame_num_offset += 256;
1014         }
1015         if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1016             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1017             return -1;
1018         }
1019     } else {
1020         h->prev_frame_num = h->frame_num;
1021         h->frame_num = h->slice_num;
1022         h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1023
1024         if (h->prev_frame_num_offset < 0) {
1025             h->prev_frame_num_offset += 256;
1026         }
1027     }
1028
1029     for (m = 0; m < 2; m++){
1030         int i;
1031         for (i = 0; i < 4; i++){
1032             int j;
1033             for (j = -1; j < 4; j++)
1034                 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1035             if (i < 3)
1036                 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1037         }
1038     }
1039
1040     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1041         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1042             h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1043
1044             if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1045                 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1046
1047                 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1048                 s->gb.size_in_bits = 8*buf_size;
1049
1050                 if (svq3_decode_slice_header(avctx))
1051                     return -1;
1052
1053                 /* TODO: support s->mb_skip_run */
1054             }
1055
1056             mb_type = svq3_get_ue_golomb(&s->gb);
1057
1058             if (s->pict_type == AV_PICTURE_TYPE_I) {
1059                 mb_type += 8;
1060             } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1061                 mb_type += 4;
1062             }
1063             if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1064                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1065                 return -1;
1066             }
1067
1068             if (mb_type != 0) {
1069                 ff_h264_hl_decode_mb (h);
1070             }
1071
1072             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1073                 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1074                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1075             }
1076         }
1077
1078         ff_draw_horiz_band(s, 16*s->mb_y, 16);
1079     }
1080
1081     left = buf_size*8 - get_bits_count(&s->gb);
1082
1083     if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1084         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);
1085         //av_hex_dump(stderr, buf+buf_size-8, 8);
1086     }
1087
1088     if (left < 0) {
1089         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1090         return -1;
1091     }
1092
1093     MPV_frame_end(s);
1094
1095     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1096         *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1097     } else {
1098         *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1099     }
1100
1101     /* Do not output the last pic after seeking. */
1102     if (s->last_picture_ptr || s->low_delay) {
1103         *data_size = sizeof(AVFrame);
1104     }
1105
1106     return buf_size;
1107 }
1108
1109 static int svq3_decode_end(AVCodecContext *avctx)
1110 {
1111     SVQ3Context *svq3 = avctx->priv_data;
1112     H264Context *h = &svq3->h;
1113     MpegEncContext *s = &h->s;
1114
1115     ff_h264_free_context(h);
1116
1117     MPV_common_end(s);
1118
1119     av_freep(&svq3->buf);
1120     svq3->buf_size = 0;
1121
1122     return 0;
1123 }
1124
1125 AVCodec ff_svq3_decoder = {
1126     .name           = "svq3",
1127     .type           = AVMEDIA_TYPE_VIDEO,
1128     .id             = CODEC_ID_SVQ3,
1129     .priv_data_size = sizeof(SVQ3Context),
1130     .init           = svq3_decode_init,
1131     .close          = svq3_decode_end,
1132     .decode         = svq3_decode_frame,
1133     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1134     .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1135     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1136 };