avserver: don't set deprecated options.
[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
221 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
222                                     int index, const int type)
223 {
224     static const uint8_t *const scan_patterns[4] =
225     { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
226
227     int run, level, limit;
228     unsigned vlc;
229     const int intra           = 3 * type >> 2;
230     const uint8_t *const scan = scan_patterns[type];
231
232     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
233         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
234             int sign = (vlc & 1) ? 0 : -1;
235             vlc      = vlc + 1 >> 1;
236
237             if (type == 3) {
238                 if (vlc < 3) {
239                     run   = 0;
240                     level = vlc;
241                 } else if (vlc < 4) {
242                     run   = 1;
243                     level = 1;
244                 } else {
245                     run   = vlc & 0x3;
246                     level = (vlc + 9 >> 2) - run;
247                 }
248             } else {
249                 if (vlc < 16) {
250                     run   = svq3_dct_tables[intra][vlc].run;
251                     level = svq3_dct_tables[intra][vlc].level;
252                 } else if (intra) {
253                     run   = vlc & 0x7;
254                     level = (vlc >> 3) +
255                             ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
256                 } else {
257                     run   = vlc & 0xF;
258                     level = (vlc >> 4) +
259                             ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
260                 }
261             }
262
263             if ((index += run) >= limit)
264                 return -1;
265
266             block[scan[index]] = (level ^ sign) - sign;
267         }
268
269         if (type != 2) {
270             break;
271         }
272     }
273
274     return 0;
275 }
276
277 static inline void svq3_mc_dir_part(SVQ3Context *s,
278                                     int x, int y, int width, int height,
279                                     int mx, int my, int dxy,
280                                     int thirdpel, int dir, int avg)
281 {
282     H264Context *h     = &s->h;
283     const Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
284     uint8_t *src, *dest;
285     int i, emu = 0;
286     int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
287
288     mx += x;
289     my += y;
290
291     if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
292         my < 0 || my >= s->v_edge_pos - height - 1) {
293         emu = 1;
294         mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
295         my = av_clip(my, -16, s->v_edge_pos - height + 15);
296     }
297
298     /* form component predictions */
299     dest = h->cur_pic.f.data[0] + x + y * h->linesize;
300     src  = pic->f.data[0] + mx + my * h->linesize;
301
302     if (emu) {
303         h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src, h->linesize,
304                                  width + 1, height + 1,
305                                  mx, my, s->h_edge_pos, s->v_edge_pos);
306         src = h->edge_emu_buffer;
307     }
308     if (thirdpel)
309         (avg ? h->dsp.avg_tpel_pixels_tab
310              : h->dsp.put_tpel_pixels_tab)[dxy](dest, src, h->linesize,
311                                                 width, height);
312     else
313         (avg ? h->dsp.avg_pixels_tab
314              : h->dsp.put_pixels_tab)[blocksize][dxy](dest, src, h->linesize,
315                                                       height);
316
317     if (!(h->flags & CODEC_FLAG_GRAY)) {
318         mx     = mx + (mx < (int) x) >> 1;
319         my     = my + (my < (int) y) >> 1;
320         width  = width  >> 1;
321         height = height >> 1;
322         blocksize++;
323
324         for (i = 1; i < 3; i++) {
325             dest = h->cur_pic.f.data[i] + (x >> 1) + (y >> 1) * h->uvlinesize;
326             src  = pic->f.data[i] + mx + my * h->uvlinesize;
327
328             if (emu) {
329                 h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src, h->uvlinesize,
330                                          width + 1, height + 1,
331                                          mx, my, (s->h_edge_pos >> 1),
332                                          s->v_edge_pos >> 1);
333                 src = h->edge_emu_buffer;
334             }
335             if (thirdpel)
336                 (avg ? h->dsp.avg_tpel_pixels_tab
337                      : h->dsp.put_tpel_pixels_tab)[dxy](dest, src,
338                                                         h->uvlinesize,
339                                                         width, height);
340             else
341                 (avg ? h->dsp.avg_pixels_tab
342                      : h->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
343                                                               h->uvlinesize,
344                                                               height);
345         }
346     }
347 }
348
349 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
350                               int dir, int avg)
351 {
352     int i, j, k, mx, my, dx, dy, x, y;
353     H264Context *h          = &s->h;
354     const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
355     const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
356     const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
357     const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
358     const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;
359
360     for (i = 0; i < 16; i += part_height)
361         for (j = 0; j < 16; j += part_width) {
362             const int b_xy = (4 * h->mb_x + (j >> 2)) +
363                              (4 * h->mb_y + (i >> 2)) * h->b_stride;
364             int dxy;
365             x = 16 * h->mb_x + j;
366             y = 16 * h->mb_y + i;
367             k = (j >> 2 & 1) + (i >> 1 & 2) +
368                 (j >> 1 & 4) + (i      & 8);
369
370             if (mode != PREDICT_MODE) {
371                 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
372             } else {
373                 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
374                 my = s->next_pic->motion_val[0][b_xy][1] << 1;
375
376                 if (dir == 0) {
377                     mx = mx * h->frame_num_offset /
378                          h->prev_frame_num_offset + 1 >> 1;
379                     my = my * h->frame_num_offset /
380                          h->prev_frame_num_offset + 1 >> 1;
381                 } else {
382                     mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
383                          h->prev_frame_num_offset + 1 >> 1;
384                     my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
385                          h->prev_frame_num_offset + 1 >> 1;
386                 }
387             }
388
389             /* clip motion vector prediction to frame border */
390             mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
391             my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
392
393             /* get (optional) motion vector differential */
394             if (mode == PREDICT_MODE) {
395                 dx = dy = 0;
396             } else {
397                 dy = svq3_get_se_golomb(&h->gb);
398                 dx = svq3_get_se_golomb(&h->gb);
399
400                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
401                     av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
402                     return -1;
403                 }
404             }
405
406             /* compute motion vector */
407             if (mode == THIRDPEL_MODE) {
408                 int fx, fy;
409                 mx  = (mx + 1 >> 1) + dx;
410                 my  = (my + 1 >> 1) + dy;
411                 fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
412                 fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
413                 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
414
415                 svq3_mc_dir_part(s, x, y, part_width, part_height,
416                                  fx, fy, dxy, 1, dir, avg);
417                 mx += mx;
418                 my += my;
419             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
420                 mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
421                 my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
422                 dxy = (mx & 1) + 2 * (my & 1);
423
424                 svq3_mc_dir_part(s, x, y, part_width, part_height,
425                                  mx >> 1, my >> 1, dxy, 0, dir, avg);
426                 mx *= 3;
427                 my *= 3;
428             } else {
429                 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
430                 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
431
432                 svq3_mc_dir_part(s, x, y, part_width, part_height,
433                                  mx, my, 0, 0, dir, avg);
434                 mx *= 6;
435                 my *= 6;
436             }
437
438             /* update mv_cache */
439             if (mode != PREDICT_MODE) {
440                 int32_t mv = pack16to32(mx, my);
441
442                 if (part_height == 8 && i < 8) {
443                     AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
444
445                     if (part_width == 8 && j < 8)
446                         AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
447                 }
448                 if (part_width == 8 && j < 8)
449                     AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
450                 if (part_width == 4 || part_height == 4)
451                     AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
452             }
453
454             /* write back motion vectors */
455             fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
456                            part_width >> 2, part_height >> 2, h->b_stride,
457                            pack16to32(mx, my), 4);
458         }
459
460     return 0;
461 }
462
463 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
464 {
465     H264Context *h = &s->h;
466     int i, j, k, m, dir, mode;
467     int cbp = 0;
468     uint32_t vlc;
469     int8_t *top, *left;
470     const int mb_xy         = h->mb_xy;
471     const int b_xy          = 4 * h->mb_x + 4 * h->mb_y * h->b_stride;
472
473     h->top_samples_available      = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
474     h->left_samples_available     = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
475     h->topright_samples_available = 0xFFFF;
476
477     if (mb_type == 0) {           /* SKIP */
478         if (h->pict_type == AV_PICTURE_TYPE_P ||
479             s->next_pic->mb_type[mb_xy] == -1) {
480             svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
481                              0, 0, 0, 0, 0, 0);
482
483             if (h->pict_type == AV_PICTURE_TYPE_B)
484                 svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
485                                  0, 0, 0, 0, 1, 1);
486
487             mb_type = MB_TYPE_SKIP;
488         } else {
489             mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
490             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
491                 return -1;
492             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
493                 return -1;
494
495             mb_type = MB_TYPE_16x16;
496         }
497     } else if (mb_type < 8) {     /* INTER */
498         if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
499             mode = THIRDPEL_MODE;
500         else if (s->halfpel_flag &&
501                  s->thirdpel_flag == !get_bits1(&h->gb))
502             mode = HALFPEL_MODE;
503         else
504             mode = FULLPEL_MODE;
505
506         /* fill caches */
507         /* note ref_cache should contain here:
508          *  ????????
509          *  ???11111
510          *  N??11111
511          *  N??11111
512          *  N??11111
513          */
514
515         for (m = 0; m < 2; m++) {
516             if (h->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
517                 for (i = 0; i < 4; i++)
518                     AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
519                               h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
520             } else {
521                 for (i = 0; i < 4; i++)
522                     AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
523             }
524             if (h->mb_y > 0) {
525                 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
526                        h->cur_pic.motion_val[m][b_xy - h->b_stride],
527                        4 * 2 * sizeof(int16_t));
528                 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
529                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
530
531                 if (h->mb_x < h->mb_width - 1) {
532                     AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
533                               h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
534                     h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
535                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
536                          h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
537                 } else
538                     h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
539                 if (h->mb_x > 0) {
540                     AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
541                               h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
542                     h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
543                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
544                 } else
545                     h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
546             } else
547                 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
548                        PART_NOT_AVAILABLE, 8);
549
550             if (h->pict_type != AV_PICTURE_TYPE_B)
551                 break;
552         }
553
554         /* decode motion vector(s) and form prediction(s) */
555         if (h->pict_type == AV_PICTURE_TYPE_P) {
556             if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
557                 return -1;
558         } else {        /* AV_PICTURE_TYPE_B */
559             if (mb_type != 2) {
560                 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
561                     return -1;
562             } else {
563                 for (i = 0; i < 4; i++)
564                     memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
565                            0, 4 * 2 * sizeof(int16_t));
566             }
567             if (mb_type != 1) {
568                 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
569                     return -1;
570             } else {
571                 for (i = 0; i < 4; i++)
572                     memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
573                            0, 4 * 2 * sizeof(int16_t));
574             }
575         }
576
577         mb_type = MB_TYPE_16x16;
578     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
579         memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
580
581         if (mb_type == 8) {
582             if (h->mb_x > 0) {
583                 for (i = 0; i < 4; i++)
584                     h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
585                 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
586                     h->left_samples_available = 0x5F5F;
587             }
588             if (h->mb_y > 0) {
589                 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
590                 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
591                 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
592                 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
593
594                 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
595                     h->top_samples_available = 0x33FF;
596             }
597
598             /* decode prediction codes for luma blocks */
599             for (i = 0; i < 16; i += 2) {
600                 vlc = svq3_get_ue_golomb(&h->gb);
601
602                 if (vlc >= 25) {
603                     av_log(h->avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
604                     return -1;
605                 }
606
607                 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
608                 top  = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
609
610                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
611                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
612
613                 if (left[1] == -1 || left[2] == -1) {
614                     av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
615                     return -1;
616                 }
617             }
618         } else {    /* mb_type == 33, DC_128_PRED block type */
619             for (i = 0; i < 4; i++)
620                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
621         }
622
623         write_back_intra_pred_mode(h);
624
625         if (mb_type == 8) {
626             ff_h264_check_intra4x4_pred_mode(h);
627
628             h->top_samples_available  = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
629             h->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
630         } else {
631             for (i = 0; i < 4; i++)
632                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
633
634             h->top_samples_available  = 0x33FF;
635             h->left_samples_available = 0x5F5F;
636         }
637
638         mb_type = MB_TYPE_INTRA4x4;
639     } else {                      /* INTRA16x16 */
640         dir = i_mb_type_info[mb_type - 8].pred_mode;
641         dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
642
643         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
644             av_log(h->avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
645             return -1;
646         }
647
648         cbp     = i_mb_type_info[mb_type - 8].cbp;
649         mb_type = MB_TYPE_INTRA16x16;
650     }
651
652     if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
653         for (i = 0; i < 4; i++)
654             memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
655                    0, 4 * 2 * sizeof(int16_t));
656         if (h->pict_type == AV_PICTURE_TYPE_B) {
657             for (i = 0; i < 4; i++)
658                 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
659                        0, 4 * 2 * sizeof(int16_t));
660         }
661     }
662     if (!IS_INTRA4x4(mb_type)) {
663         memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
664     }
665     if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
666         memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
667         h->dsp.clear_blocks(h->mb +   0);
668         h->dsp.clear_blocks(h->mb + 384);
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->f.motion_subsample_log2 = 2;
1062     pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1063
1064     ret = ff_get_buffer(avctx, &pic->f,
1065                         pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1066     if (ret < 0)
1067         goto fail;
1068
1069     if (!h->edge_emu_buffer) {
1070         h->edge_emu_buffer = av_mallocz(pic->f.linesize[0] * 17);
1071         if (!h->edge_emu_buffer)
1072             return AVERROR(ENOMEM);
1073     }
1074
1075     h->linesize   = pic->f.linesize[0];
1076     h->uvlinesize = pic->f.linesize[1];
1077
1078     return 0;
1079 fail:
1080     free_picture(avctx, pic);
1081     return ret;
1082 }
1083
1084 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1085                              int *got_frame, AVPacket *avpkt)
1086 {
1087     const uint8_t *buf = avpkt->data;
1088     SVQ3Context *s     = avctx->priv_data;
1089     H264Context *h     = &s->h;
1090     int buf_size       = avpkt->size;
1091     int ret, m, i;
1092
1093     /* special case for last picture */
1094     if (buf_size == 0) {
1095         if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
1096             ret = av_frame_ref(data, &s->next_pic->f);
1097             if (ret < 0)
1098                 return ret;
1099             s->last_frame_output = 1;
1100             *got_frame          = 1;
1101         }
1102         return 0;
1103     }
1104
1105     init_get_bits(&h->gb, buf, 8 * buf_size);
1106
1107     h->mb_x = h->mb_y = h->mb_xy = 0;
1108
1109     if (svq3_decode_slice_header(avctx))
1110         return -1;
1111
1112     h->pict_type = h->slice_type;
1113
1114     if (h->pict_type != AV_PICTURE_TYPE_B)
1115         FFSWAP(Picture*, s->next_pic, s->last_pic);
1116
1117     av_frame_unref(&s->cur_pic->f);
1118
1119     /* for skipping the frame */
1120     s->cur_pic->f.pict_type = h->pict_type;
1121     s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1122
1123     ret = get_buffer(avctx, s->cur_pic);
1124     if (ret < 0)
1125         return ret;
1126
1127     h->cur_pic_ptr = s->cur_pic;
1128     av_frame_unref(&h->cur_pic.f);
1129     h->cur_pic     = *s->cur_pic;
1130     ret = av_frame_ref(&h->cur_pic.f, &s->cur_pic->f);
1131     if (ret < 0)
1132         return ret;
1133
1134     for (i = 0; i < 16; i++) {
1135         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1136         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1137     }
1138     for (i = 0; i < 16; i++) {
1139         h->block_offset[16 + i]      =
1140         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1141         h->block_offset[48 + 16 + i] =
1142         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1143     }
1144
1145     if (h->pict_type != AV_PICTURE_TYPE_I) {
1146         if (!s->last_pic->f.data[0]) {
1147             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1148             ret = get_buffer(avctx, s->last_pic);
1149             if (ret < 0)
1150                 return ret;
1151             memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1152             memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1153                    s->last_pic->f.linesize[1]);
1154             memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1155                    s->last_pic->f.linesize[2]);
1156         }
1157
1158         if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1159             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1160             ret = get_buffer(avctx, s->next_pic);
1161             if (ret < 0)
1162                 return ret;
1163             memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1164             memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1165                    s->next_pic->f.linesize[1]);
1166             memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1167                    s->next_pic->f.linesize[2]);
1168         }
1169     }
1170
1171     if (avctx->debug & FF_DEBUG_PICT_INFO)
1172         av_log(h->avctx, AV_LOG_DEBUG,
1173                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1174                av_get_picture_type_char(h->pict_type),
1175                s->halfpel_flag, s->thirdpel_flag,
1176                s->adaptive_quant, h->qscale, h->slice_num);
1177
1178     if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1179         avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1180         avctx->skip_frame >= AVDISCARD_ALL)
1181         return 0;
1182
1183     if (s->next_p_frame_damaged) {
1184         if (h->pict_type == AV_PICTURE_TYPE_B)
1185             return 0;
1186         else
1187             s->next_p_frame_damaged = 0;
1188     }
1189
1190     if (h->pict_type == AV_PICTURE_TYPE_B) {
1191         h->frame_num_offset = h->slice_num - h->prev_frame_num;
1192
1193         if (h->frame_num_offset < 0)
1194             h->frame_num_offset += 256;
1195         if (h->frame_num_offset == 0 ||
1196             h->frame_num_offset >= h->prev_frame_num_offset) {
1197             av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1198             return -1;
1199         }
1200     } else {
1201         h->prev_frame_num        = h->frame_num;
1202         h->frame_num             = h->slice_num;
1203         h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1204
1205         if (h->prev_frame_num_offset < 0)
1206             h->prev_frame_num_offset += 256;
1207     }
1208
1209     for (m = 0; m < 2; m++) {
1210         int i;
1211         for (i = 0; i < 4; i++) {
1212             int j;
1213             for (j = -1; j < 4; j++)
1214                 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1215             if (i < 3)
1216                 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1217         }
1218     }
1219
1220     for (h->mb_y = 0; h->mb_y < h->mb_height; h->mb_y++) {
1221         for (h->mb_x = 0; h->mb_x < h->mb_width; h->mb_x++) {
1222             unsigned mb_type;
1223             h->mb_xy = h->mb_x + h->mb_y * h->mb_stride;
1224
1225             if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1226                 ((get_bits_count(&h->gb) & 7) == 0 ||
1227                  show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1228                 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1229                 h->gb.size_in_bits = 8 * buf_size;
1230
1231                 if (svq3_decode_slice_header(avctx))
1232                     return -1;
1233
1234                 /* TODO: support s->mb_skip_run */
1235             }
1236
1237             mb_type = svq3_get_ue_golomb(&h->gb);
1238
1239             if (h->pict_type == AV_PICTURE_TYPE_I)
1240                 mb_type += 8;
1241             else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1242                 mb_type += 4;
1243             if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1244                 av_log(h->avctx, AV_LOG_ERROR,
1245                        "error while decoding MB %d %d\n", h->mb_x, h->mb_y);
1246                 return -1;
1247             }
1248
1249             if (mb_type != 0)
1250                 ff_h264_hl_decode_mb(h);
1251
1252             if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1253                 h->cur_pic.mb_type[h->mb_x + h->mb_y * h->mb_stride] =
1254                     (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1255         }
1256
1257         ff_draw_horiz_band(avctx, NULL, s->cur_pic, s->last_pic->f.data[0] ? s->last_pic : NULL,
1258                            16 * h->mb_y, 16, h->picture_structure, 0, 0,
1259                            h->low_delay, h->mb_height * 16, h->mb_width * 16);
1260     }
1261
1262     if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1263         ret = av_frame_ref(data, &s->cur_pic->f);
1264     else if (s->last_pic->f.data[0])
1265         ret = av_frame_ref(data, &s->last_pic->f);
1266     if (ret < 0)
1267         return ret;
1268
1269     /* Do not output the last pic after seeking. */
1270     if (s->last_pic->f.data[0] || h->low_delay)
1271         *got_frame = 1;
1272
1273     if (h->pict_type != AV_PICTURE_TYPE_B) {
1274         FFSWAP(Picture*, s->cur_pic, s->next_pic);
1275     } else {
1276         av_frame_unref(&s->cur_pic->f);
1277     }
1278
1279     return buf_size;
1280 }
1281
1282 static int svq3_decode_end(AVCodecContext *avctx)
1283 {
1284     SVQ3Context *s = avctx->priv_data;
1285     H264Context *h = &s->h;
1286
1287     free_picture(avctx, s->cur_pic);
1288     free_picture(avctx, s->next_pic);
1289     free_picture(avctx, s->last_pic);
1290     av_freep(&s->cur_pic);
1291     av_freep(&s->next_pic);
1292     av_freep(&s->last_pic);
1293
1294     av_frame_unref(&h->cur_pic.f);
1295
1296     ff_h264_free_context(h);
1297
1298     return 0;
1299 }
1300
1301 AVCodec ff_svq3_decoder = {
1302     .name           = "svq3",
1303     .type           = AVMEDIA_TYPE_VIDEO,
1304     .id             = AV_CODEC_ID_SVQ3,
1305     .priv_data_size = sizeof(SVQ3Context),
1306     .init           = svq3_decode_init,
1307     .close          = svq3_decode_end,
1308     .decode         = svq3_decode_frame,
1309     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND |
1310                       CODEC_CAP_DR1             |
1311                       CODEC_CAP_DELAY,
1312     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1313     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1314                                                      AV_PIX_FMT_NONE},
1315 };