Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 3b606e71

History | View | Annotate | Download (38.7 KB)

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

    
61
/**
62
 * @file libavcodec/svq3.c
63
 * svq3 decoder.
64
 */
65

    
66
#define FULLPEL_MODE  1
67
#define HALFPEL_MODE  2
68
#define THIRDPEL_MODE 3
69
#define PREDICT_MODE  4
70

    
71
/* dual scan (from some older h264 draft)
72
 o-->o-->o   o
73
         |  /|
74
 o   o   o / o
75
 | / |   |/  |
76
 o   o   o   o
77
   /
78
 o-->o-->o-->o
79
*/
80
static const uint8_t svq3_scan[16] = {
81
    0+0*4, 1+0*4, 2+0*4, 2+1*4,
82
    2+2*4, 3+0*4, 3+1*4, 3+2*4,
83
    0+1*4, 0+2*4, 1+1*4, 1+2*4,
84
    0+3*4, 1+3*4, 2+3*4, 3+3*4,
85
};
86

    
87
static const uint8_t svq3_pred_0[25][2] = {
88
    { 0, 0 },
89
    { 1, 0 }, { 0, 1 },
90
    { 0, 2 }, { 1, 1 }, { 2, 0 },
91
    { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
92
    { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
93
    { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
94
    { 2, 4 }, { 3, 3 }, { 4, 2 },
95
    { 4, 3 }, { 3, 4 },
96
    { 4, 4 }
97
};
98

    
99
static const int8_t svq3_pred_1[6][6][5] = {
100
    { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
101
      { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
102
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
103
      { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
104
    { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
105
      { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
106
    { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
107
      { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
108
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
109
      { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
110
    { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
111
      { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
112
};
113

    
114
static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
115
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
116
      { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
117
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
118
      { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
119
};
120

    
121
static const uint32_t svq3_dequant_coeff[32] = {
122
     3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
123
     9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
124
    24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
125
    61694, 68745, 77615, 89113,100253,109366,126635,141533
126
};
127

    
128

    
129
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp)
130
{
131
    const int qmul = svq3_dequant_coeff[qp];
132
#define stride 16
133
    int i;
134
    int temp[16];
135
    static const int x_offset[4] = {0, 1*stride, 4* stride,  5*stride};
136
    static const int y_offset[4] = {0, 2*stride, 8* stride, 10*stride};
137

    
138
    for (i = 0; i < 4; i++){
139
        const int offset = y_offset[i];
140
        const int z0 = 13*(block[offset+stride*0] +    block[offset+stride*4]);
141
        const int z1 = 13*(block[offset+stride*0] -    block[offset+stride*4]);
142
        const int z2 =  7* block[offset+stride*1] - 17*block[offset+stride*5];
143
        const int z3 = 17* block[offset+stride*1] +  7*block[offset+stride*5];
144

    
145
        temp[4*i+0] = z0+z3;
146
        temp[4*i+1] = z1+z2;
147
        temp[4*i+2] = z1-z2;
148
        temp[4*i+3] = z0-z3;
149
    }
150

    
151
    for (i = 0; i < 4; i++){
152
        const int offset = x_offset[i];
153
        const int z0 = 13*(temp[4*0+i] +    temp[4*2+i]);
154
        const int z1 = 13*(temp[4*0+i] -    temp[4*2+i]);
155
        const int z2 =  7* temp[4*1+i] - 17*temp[4*3+i];
156
        const int z3 = 17* temp[4*1+i] +  7*temp[4*3+i];
157

    
158
        block[stride*0 +offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
159
        block[stride*2 +offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
160
        block[stride*8 +offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
161
        block[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
162
    }
163
}
164
#undef stride
165

    
166
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
167
                            int dc)
168
{
169
    const int qmul = svq3_dequant_coeff[qp];
170
    int i;
171
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
172

    
173
    if (dc) {
174
        dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
175
        block[0] = 0;
176
    }
177

    
178
    for (i = 0; i < 4; i++) {
179
        const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
180
        const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
181
        const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
182
        const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
183

    
184
        block[0 + 4*i] = z0 + z3;
185
        block[1 + 4*i] = z1 + z2;
186
        block[2 + 4*i] = z1 - z2;
187
        block[3 + 4*i] = z0 - z3;
188
    }
189

    
190
    for (i = 0; i < 4; i++) {
191
        const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
192
        const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
193
        const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
194
        const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
195
        const int rr = (dc + 0x80000);
196

    
197
        dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
198
        dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
199
        dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
200
        dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
201
    }
202
}
203

    
204
static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
205
                                    int index, const int type)
206
{
207
    static const uint8_t *const scan_patterns[4] =
208
    { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
209

    
210
    int run, level, sign, vlc, limit;
211
    const int intra = (3 * type) >> 2;
212
    const uint8_t *const scan = scan_patterns[type];
213

    
214
    for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
215
        for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
216

    
217
          if (vlc == INVALID_VLC)
218
              return -1;
219

    
220
          sign = (vlc & 0x1) - 1;
221
          vlc  = (vlc + 1) >> 1;
222

    
223
          if (type == 3) {
224
              if (vlc < 3) {
225
                  run   = 0;
226
                  level = vlc;
227
              } else if (vlc < 4) {
228
                  run   = 1;
229
                  level = 1;
230
              } else {
231
                  run   = (vlc & 0x3);
232
                  level = ((vlc + 9) >> 2) - run;
233
              }
234
          } else {
235
              if (vlc < 16) {
236
                  run   = svq3_dct_tables[intra][vlc].run;
237
                  level = svq3_dct_tables[intra][vlc].level;
238
              } else if (intra) {
239
                  run   = (vlc & 0x7);
240
                  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
241
              } else {
242
                  run   = (vlc & 0xF);
243
                  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
244
              }
245
          }
246

    
247
          if ((index += run) >= limit)
248
              return -1;
249

    
250
          block[scan[index]] = (level ^ sign) - sign;
251
        }
252

    
253
        if (type != 2) {
254
            break;
255
        }
256
    }
257

    
258
    return 0;
259
}
260

    
261
static inline void svq3_mc_dir_part(MpegEncContext *s,
262
                                    int x, int y, int width, int height,
263
                                    int mx, int my, int dxy,
264
                                    int thirdpel, int dir, int avg)
265
{
266
    const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
267
    uint8_t *src, *dest;
268
    int i, emu = 0;
269
    int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
270

    
271
    mx += x;
272
    my += y;
273

    
274
    if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
275
        my < 0 || my >= (s->v_edge_pos - height - 1)) {
276

    
277
        if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
278
            emu = 1;
279
        }
280

    
281
        mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
282
        my = av_clip (my, -16, (s->v_edge_pos - height + 15));
283
    }
284

    
285
    /* form component predictions */
286
    dest = s->current_picture.data[0] + x + y*s->linesize;
287
    src  = pic->data[0] + mx + my*s->linesize;
288

    
289
    if (emu) {
290
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
291
                            mx, my, s->h_edge_pos, s->v_edge_pos);
292
        src = s->edge_emu_buffer;
293
    }
294
    if (thirdpel)
295
        (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
296
    else
297
        (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
298

    
299
    if (!(s->flags & CODEC_FLAG_GRAY)) {
300
        mx     = (mx + (mx < (int) x)) >> 1;
301
        my     = (my + (my < (int) y)) >> 1;
302
        width  = (width  >> 1);
303
        height = (height >> 1);
304
        blocksize++;
305

    
306
        for (i = 1; i < 3; i++) {
307
            dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
308
            src  = pic->data[i] + mx + my*s->uvlinesize;
309

    
310
            if (emu) {
311
                ff_emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
312
                                    mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
313
                src = s->edge_emu_buffer;
314
            }
315
            if (thirdpel)
316
                (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
317
            else
318
                (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
319
        }
320
    }
321
}
322

    
323
static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
324
                              int avg)
325
{
326
    int i, j, k, mx, my, dx, dy, x, y;
327
    MpegEncContext *const s = (MpegEncContext *) h;
328
    const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
329
    const int part_height = 16 >> ((unsigned) (size + 1) / 3);
330
    const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
331
    const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
332
    const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
333

    
334
    for (i = 0; i < 16; i += part_height) {
335
        for (j = 0; j < 16; j += part_width) {
336
            const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
337
            int dxy;
338
            x = 16*s->mb_x + j;
339
            y = 16*s->mb_y + i;
340
            k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
341

    
342
            if (mode != PREDICT_MODE) {
343
                pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
344
            } else {
345
                mx = s->next_picture.motion_val[0][b_xy][0]<<1;
346
                my = s->next_picture.motion_val[0][b_xy][1]<<1;
347

    
348
                if (dir == 0) {
349
                    mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
350
                    my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
351
                } else {
352
                    mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
353
                    my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
354
                }
355
            }
356

    
357
            /* clip motion vector prediction to frame border */
358
            mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
359
            my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
360

    
361
            /* get (optional) motion vector differential */
362
            if (mode == PREDICT_MODE) {
363
                dx = dy = 0;
364
            } else {
365
                dy = svq3_get_se_golomb(&s->gb);
366
                dx = svq3_get_se_golomb(&s->gb);
367

    
368
                if (dx == INVALID_VLC || dy == INVALID_VLC) {
369
                    av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
370
                    return -1;
371
                }
372
            }
373

    
374
            /* compute motion vector */
375
            if (mode == THIRDPEL_MODE) {
376
                int fx, fy;
377
                mx  = ((mx + 1)>>1) + dx;
378
                my  = ((my + 1)>>1) + dy;
379
                fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
380
                fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
381
                dxy = (mx - 3*fx) + 4*(my - 3*fy);
382

    
383
                svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
384
                mx += mx;
385
                my += my;
386
            } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
387
                mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
388
                my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
389
                dxy = (mx&1) + 2*(my&1);
390

    
391
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
392
                mx *= 3;
393
                my *= 3;
394
            } else {
395
                mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
396
                my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
397

    
398
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
399
                mx *= 6;
400
                my *= 6;
401
            }
402

    
403
            /* update mv_cache */
404
            if (mode != PREDICT_MODE) {
405
                int32_t mv = pack16to32(mx,my);
406

    
407
                if (part_height == 8 && i < 8) {
408
                    *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
409

    
410
                    if (part_width == 8 && j < 8) {
411
                        *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
412
                    }
413
                }
414
                if (part_width == 8 && j < 8) {
415
                    *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
416
                }
417
                if (part_width == 4 || part_height == 4) {
418
                    *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
419
                }
420
            }
421

    
422
            /* write back motion vectors */
423
            fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
424
        }
425
    }
426

    
427
    return 0;
428
}
429

    
430
static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
431
{
432
    int i, j, k, m, dir, mode;
433
    int cbp = 0;
434
    uint32_t vlc;
435
    int8_t *top, *left;
436
    MpegEncContext *const s = (MpegEncContext *) h;
437
    const int mb_xy = h->mb_xy;
438
    const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
439

    
440
    h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
441
    h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
442
    h->topright_samples_available = 0xFFFF;
443

    
444
    if (mb_type == 0) {           /* SKIP */
445
        if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
446
            svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
447

    
448
            if (s->pict_type == FF_B_TYPE) {
449
                svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
450
            }
451

    
452
            mb_type = MB_TYPE_SKIP;
453
        } else {
454
            mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
455
            if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
456
                return -1;
457
            if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
458
                return -1;
459

    
460
            mb_type = MB_TYPE_16x16;
461
        }
462
    } else if (mb_type < 8) {     /* INTER */
463
        if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
464
            mode = THIRDPEL_MODE;
465
        } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
466
            mode = HALFPEL_MODE;
467
        } else {
468
            mode = FULLPEL_MODE;
469
        }
470

    
471
        /* fill caches */
472
        /* note ref_cache should contain here:
473
            ????????
474
            ???11111
475
            N??11111
476
            N??11111
477
            N??11111
478
        */
479

    
480
        for (m = 0; m < 2; m++) {
481
            if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
482
                for (i = 0; i < 4; i++) {
483
                    *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
484
                }
485
            } else {
486
                for (i = 0; i < 4; i++) {
487
                    *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
488
                }
489
            }
490
            if (s->mb_y > 0) {
491
                memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
492
                memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
493

    
494
                if (s->mb_x < (s->mb_width - 1)) {
495
                    *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
496
                    h->ref_cache[m][scan8[0] + 4 - 1*8] =
497
                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
498
                         h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
499
                }else
500
                    h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
501
                if (s->mb_x > 0) {
502
                    *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
503
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] == -1) ? PART_NOT_AVAILABLE : 1;
504
                }else
505
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
506
            }else
507
                memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
508

    
509
            if (s->pict_type != FF_B_TYPE)
510
                break;
511
        }
512

    
513
        /* decode motion vector(s) and form prediction(s) */
514
        if (s->pict_type == FF_P_TYPE) {
515
            if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
516
                return -1;
517
        } else {        /* FF_B_TYPE */
518
            if (mb_type != 2) {
519
                if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
520
                    return -1;
521
            } else {
522
                for (i = 0; i < 4; i++) {
523
                    memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
524
                }
525
            }
526
            if (mb_type != 1) {
527
                if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
528
                    return -1;
529
            } else {
530
                for (i = 0; i < 4; i++) {
531
                    memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
532
                }
533
            }
534
        }
535

    
536
        mb_type = MB_TYPE_16x16;
537
    } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
538
        memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
539

    
540
        if (mb_type == 8) {
541
            if (s->mb_x > 0) {
542
                for (i = 0; i < 4; i++) {
543
                    h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
544
                }
545
                if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
546
                    h->left_samples_available = 0x5F5F;
547
                }
548
            }
549
            if (s->mb_y > 0) {
550
                h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
551
                h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
552
                h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
553
                h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
554

    
555
                if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
556
                    h->top_samples_available = 0x33FF;
557
                }
558
            }
559

    
560
            /* decode prediction codes for luma blocks */
561
            for (i = 0; i < 16; i+=2) {
562
                vlc = svq3_get_ue_golomb(&s->gb);
563

    
564
                if (vlc >= 25){
565
                    av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
566
                    return -1;
567
                }
568

    
569
                left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
570
                top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
571

    
572
                left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
573
                left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
574

    
575
                if (left[1] == -1 || left[2] == -1){
576
                    av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
577
                    return -1;
578
                }
579
            }
580
        } else {    /* mb_type == 33, DC_128_PRED block type */
581
            for (i = 0; i < 4; i++) {
582
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
583
            }
584
        }
585

    
586
        ff_h264_write_back_intra_pred_mode(h);
587

    
588
        if (mb_type == 8) {
589
            ff_h264_check_intra4x4_pred_mode(h);
590

    
591
            h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
592
            h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
593
        } else {
594
            for (i = 0; i < 4; i++) {
595
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
596
            }
597

    
598
            h->top_samples_available  = 0x33FF;
599
            h->left_samples_available = 0x5F5F;
600
        }
601

    
602
        mb_type = MB_TYPE_INTRA4x4;
603
    } else {                      /* INTRA16x16 */
604
        dir = i_mb_type_info[mb_type - 8].pred_mode;
605
        dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
606

    
607
        if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
608
            av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
609
            return -1;
610
        }
611

    
612
        cbp = i_mb_type_info[mb_type - 8].cbp;
613
        mb_type = MB_TYPE_INTRA16x16;
614
    }
615

    
616
    if (!IS_INTER(mb_type) && s->pict_type != FF_I_TYPE) {
617
        for (i = 0; i < 4; i++) {
618
            memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
619
        }
620
        if (s->pict_type == FF_B_TYPE) {
621
            for (i = 0; i < 4; i++) {
622
                memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
623
            }
624
        }
625
    }
626
    if (!IS_INTRA4x4(mb_type)) {
627
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
628
    }
629
    if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
630
        memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
631
        s->dsp.clear_blocks(h->mb);
632
    }
633

    
634
    if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
635
        if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
636
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
637
            return -1;
638
        }
639

    
640
        cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
641
    }
642
    if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
643
        s->qscale += svq3_get_se_golomb(&s->gb);
644

    
645
        if (s->qscale > 31){
646
            av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
647
            return -1;
648
        }
649
    }
650
    if (IS_INTRA16x16(mb_type)) {
651
        if (svq3_decode_block(&s->gb, h->mb, 0, 0)){
652
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
653
            return -1;
654
        }
655
    }
656

    
657
    if (cbp) {
658
        const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
659
        const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
660

    
661
        for (i = 0; i < 4; i++) {
662
            if ((cbp & (1 << i))) {
663
                for (j = 0; j < 4; j++) {
664
                    k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
665
                    h->non_zero_count_cache[ scan8[k] ] = 1;
666

    
667
                    if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
668
                        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
669
                        return -1;
670
                    }
671
                }
672
            }
673
        }
674

    
675
        if ((cbp & 0x30)) {
676
            for (i = 0; i < 2; ++i) {
677
              if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
678
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
679
                return -1;
680
              }
681
            }
682

    
683
            if ((cbp & 0x20)) {
684
                for (i = 0; i < 8; i++) {
685
                    h->non_zero_count_cache[ scan8[16+i] ] = 1;
686

    
687
                    if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
688
                        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
689
                        return -1;
690
                    }
691
                }
692
            }
693
        }
694
    }
695

    
696
    h->cbp= cbp;
697
    s->current_picture.mb_type[mb_xy] = mb_type;
698

    
699
    if (IS_INTRA(mb_type)) {
700
        h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
701
    }
702

    
703
    return 0;
704
}
705

    
706
static int svq3_decode_slice_header(H264Context *h)
707
{
708
    MpegEncContext *const s = (MpegEncContext *) h;
709
    const int mb_xy = h->mb_xy;
710
    int i, header;
711

    
712
    header = get_bits(&s->gb, 8);
713

    
714
    if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
715
        /* TODO: what? */
716
        av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
717
        return -1;
718
    } else {
719
        int length = (header >> 5) & 3;
720

    
721
        h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
722

    
723
        if (h->next_slice_index > s->gb.size_in_bits) {
724
            av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
725
            return -1;
726
    }
727

    
728
        s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
729
        skip_bits(&s->gb, 8);
730

    
731
        if (h->svq3_watermark_key) {
732
            uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
733
            AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
734
        }
735
        if (length > 0) {
736
            memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
737
                   &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
738
        }
739
        skip_bits_long(&s->gb, 0);
740
    }
741

    
742
    if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
743
        av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
744
        return -1;
745
    }
746

    
747
    h->slice_type = golomb_to_pict_type[i];
748

    
749
    if ((header & 0x9F) == 2) {
750
        i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
751
        s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
752
    } else {
753
        skip_bits1(&s->gb);
754
        s->mb_skip_run = 0;
755
    }
756

    
757
    h->slice_num = get_bits(&s->gb, 8);
758
    s->qscale = get_bits(&s->gb, 5);
759
    s->adaptive_quant = get_bits1(&s->gb);
760

    
761
    /* unknown fields */
762
    skip_bits1(&s->gb);
763

    
764
    if (h->unknown_svq3_flag) {
765
        skip_bits1(&s->gb);
766
    }
767

    
768
    skip_bits1(&s->gb);
769
    skip_bits(&s->gb, 2);
770

    
771
    while (get_bits1(&s->gb)) {
772
        skip_bits(&s->gb, 8);
773
    }
774

    
775
    /* reset intra predictors and invalidate motion vector references */
776
    if (s->mb_x > 0) {
777
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1      ]+3, -1, 4*sizeof(int8_t));
778
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x]  , -1, 8*sizeof(int8_t)*s->mb_x);
779
    }
780
    if (s->mb_y > 0) {
781
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
782

    
783
        if (s->mb_x > 0) {
784
            h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
785
        }
786
    }
787

    
788
    return 0;
789
}
790

    
791
static av_cold int svq3_decode_init(AVCodecContext *avctx)
792
{
793
    MpegEncContext *const s = avctx->priv_data;
794
    H264Context *const h = avctx->priv_data;
795
    int m;
796
    unsigned char *extradata;
797
    unsigned int size;
798

    
799
    if(avctx->thread_count > 1){
800
        av_log(avctx, AV_LOG_ERROR, "SVQ3 does not support multithreaded decoding, patch welcome! (check latest SVN too)\n");
801
        return -1;
802
    }
803

    
804
    if (ff_h264_decode_init(avctx) < 0)
805
        return -1;
806

    
807
    s->flags  = avctx->flags;
808
    s->flags2 = avctx->flags2;
809
    s->unrestricted_mv = 1;
810
    h->is_complex=1;
811
    avctx->pix_fmt = avctx->codec->pix_fmts[0];
812

    
813
    if (!s->context_initialized) {
814
        s->width  = avctx->width;
815
        s->height = avctx->height;
816
        h->halfpel_flag      = 1;
817
        h->thirdpel_flag     = 1;
818
        h->unknown_svq3_flag = 0;
819
        h->chroma_qp[0]      = h->chroma_qp[1] = 4;
820

    
821
        if (MPV_common_init(s) < 0)
822
            return -1;
823

    
824
        h->b_stride = 4*s->mb_width;
825

    
826
        ff_h264_alloc_tables(h);
827

    
828
        /* prowl for the "SEQH" marker in the extradata */
829
        extradata = (unsigned char *)avctx->extradata;
830
        for (m = 0; m < avctx->extradata_size; m++) {
831
            if (!memcmp(extradata, "SEQH", 4))
832
                break;
833
            extradata++;
834
        }
835

    
836
        /* if a match was found, parse the extra data */
837
        if (extradata && !memcmp(extradata, "SEQH", 4)) {
838

    
839
            GetBitContext gb;
840
            int frame_size_code;
841

    
842
            size = AV_RB32(&extradata[4]);
843
            init_get_bits(&gb, extradata + 8, size*8);
844

    
845
            /* 'frame size code' and optional 'width, height' */
846
            frame_size_code = get_bits(&gb, 3);
847
            switch (frame_size_code) {
848
                case 0: avctx->width = 160; avctx->height = 120; break;
849
                case 1: avctx->width = 128; avctx->height =  96; break;
850
                case 2: avctx->width = 176; avctx->height = 144; break;
851
                case 3: avctx->width = 352; avctx->height = 288; break;
852
                case 4: avctx->width = 704; avctx->height = 576; break;
853
                case 5: avctx->width = 240; avctx->height = 180; break;
854
                case 6: avctx->width = 320; avctx->height = 240; break;
855
                case 7:
856
                    avctx->width  = get_bits(&gb, 12);
857
                    avctx->height = get_bits(&gb, 12);
858
                    break;
859
            }
860

    
861
            h->halfpel_flag  = get_bits1(&gb);
862
            h->thirdpel_flag = get_bits1(&gb);
863

    
864
            /* unknown fields */
865
            skip_bits1(&gb);
866
            skip_bits1(&gb);
867
            skip_bits1(&gb);
868
            skip_bits1(&gb);
869

    
870
            s->low_delay = get_bits1(&gb);
871

    
872
            /* unknown field */
873
            skip_bits1(&gb);
874

    
875
            while (get_bits1(&gb)) {
876
                skip_bits(&gb, 8);
877
            }
878

    
879
            h->unknown_svq3_flag = get_bits1(&gb);
880
            avctx->has_b_frames = !s->low_delay;
881
            if (h->unknown_svq3_flag) {
882
#if CONFIG_ZLIB
883
                unsigned watermark_width  = svq3_get_ue_golomb(&gb);
884
                unsigned watermark_height = svq3_get_ue_golomb(&gb);
885
                int u1 = svq3_get_ue_golomb(&gb);
886
                int u2 = get_bits(&gb, 8);
887
                int u3 = get_bits(&gb, 2);
888
                int u4 = svq3_get_ue_golomb(&gb);
889
                unsigned buf_len = watermark_width*watermark_height*4;
890
                int offset = (get_bits_count(&gb)+7)>>3;
891
                uint8_t *buf;
892

    
893
                if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
894
                    return -1;
895

    
896
                buf = av_malloc(buf_len);
897
                av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
898
                av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
899
                if (uncompress(buf, (uLong*)&buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
900
                    av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
901
                    av_free(buf);
902
                    return -1;
903
                }
904
                h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
905
                h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
906
                av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
907
                av_free(buf);
908
#else
909
                av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
910
                return -1;
911
#endif
912
            }
913
        }
914
    }
915

    
916
    return 0;
917
}
918

    
919
static int svq3_decode_frame(AVCodecContext *avctx,
920
                             void *data, int *data_size,
921
                             AVPacket *avpkt)
922
{
923
    const uint8_t *buf = avpkt->data;
924
    int buf_size = avpkt->size;
925
    MpegEncContext *const s = avctx->priv_data;
926
    H264Context *const h = avctx->priv_data;
927
    int m, mb_type;
928

    
929
    /* special case for last picture */
930
    if (buf_size == 0) {
931
        if (s->next_picture_ptr && !s->low_delay) {
932
            *(AVFrame *) data = *(AVFrame *) &s->next_picture;
933
            s->next_picture_ptr = NULL;
934
            *data_size = sizeof(AVFrame);
935
        }
936
        return 0;
937
    }
938

    
939
    init_get_bits (&s->gb, buf, 8*buf_size);
940

    
941
    s->mb_x = s->mb_y = h->mb_xy = 0;
942

    
943
    if (svq3_decode_slice_header(h))
944
        return -1;
945

    
946
    s->pict_type = h->slice_type;
947
    s->picture_number = h->slice_num;
948

    
949
    if (avctx->debug&FF_DEBUG_PICT_INFO){
950
        av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
951
               av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
952
               s->adaptive_quant, s->qscale, h->slice_num);
953
    }
954

    
955
    /* for hurry_up == 5 */
956
    s->current_picture.pict_type = s->pict_type;
957
    s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
958

    
959
    /* Skip B-frames if we do not have reference frames. */
960
    if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
961
        return 0;
962
    /* Skip B-frames if we are in a hurry. */
963
    if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
964
        return 0;
965
    /* Skip everything if we are in a hurry >= 5. */
966
    if (avctx->hurry_up >= 5)
967
        return 0;
968
    if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
969
        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
970
        || avctx->skip_frame >= AVDISCARD_ALL)
971
        return 0;
972

    
973
    if (s->next_p_frame_damaged) {
974
        if (s->pict_type == FF_B_TYPE)
975
            return 0;
976
        else
977
            s->next_p_frame_damaged = 0;
978
    }
979

    
980
    if (ff_h264_frame_start(h) < 0)
981
        return -1;
982

    
983
    if (s->pict_type == FF_B_TYPE) {
984
        h->frame_num_offset = (h->slice_num - h->prev_frame_num);
985

    
986
        if (h->frame_num_offset < 0) {
987
            h->frame_num_offset += 256;
988
        }
989
        if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
990
            av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
991
            return -1;
992
        }
993
    } else {
994
        h->prev_frame_num = h->frame_num;
995
        h->frame_num = h->slice_num;
996
        h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
997

    
998
        if (h->prev_frame_num_offset < 0) {
999
            h->prev_frame_num_offset += 256;
1000
        }
1001
    }
1002

    
1003
    for (m = 0; m < 2; m++){
1004
        int i;
1005
        for (i = 0; i < 4; i++){
1006
            int j;
1007
            for (j = -1; j < 4; j++)
1008
                h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1009
            if (i < 3)
1010
                h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1011
        }
1012
    }
1013

    
1014
    for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1015
        for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1016
            h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1017

    
1018
            if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1019
                ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1020

    
1021
                skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
1022
                s->gb.size_in_bits = 8*buf_size;
1023

    
1024
                if (svq3_decode_slice_header(h))
1025
                    return -1;
1026

    
1027
                /* TODO: support s->mb_skip_run */
1028
            }
1029

    
1030
            mb_type = svq3_get_ue_golomb(&s->gb);
1031

    
1032
            if (s->pict_type == FF_I_TYPE) {
1033
                mb_type += 8;
1034
            } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1035
                mb_type += 4;
1036
            }
1037
            if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1038
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1039
                return -1;
1040
            }
1041

    
1042
            if (mb_type != 0) {
1043
                ff_h264_hl_decode_mb (h);
1044
            }
1045

    
1046
            if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1047
                s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1048
                    (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1049
            }
1050
        }
1051

    
1052
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
1053
    }
1054

    
1055
    MPV_frame_end(s);
1056

    
1057
    if (s->pict_type == FF_B_TYPE || s->low_delay) {
1058
        *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1059
    } else {
1060
        *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1061
    }
1062

    
1063
    /* Do not output the last pic after seeking. */
1064
    if (s->last_picture_ptr || s->low_delay) {
1065
        *data_size = sizeof(AVFrame);
1066
    }
1067

    
1068
    return buf_size;
1069
}
1070

    
1071

    
1072
AVCodec svq3_decoder = {
1073
    "svq3",
1074
    CODEC_TYPE_VIDEO,
1075
    CODEC_ID_SVQ3,
1076
    sizeof(H264Context),
1077
    svq3_decode_init,
1078
    NULL,
1079
    ff_h264_decode_end,
1080
    svq3_decode_frame,
1081
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1082
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1083
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1084
};