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