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