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