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