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