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