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