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