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