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