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