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