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