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