Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 2264c110

History | View | Annotate | Download (39.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
63
 * svq3 decoder.
64
 */
65

    
66
typedef struct {
67
    H264Context h;
68
    int halfpel_flag;
69
    int thirdpel_flag;
70
    int unknown_flag;
71
    int next_slice_index;
72
    uint32_t watermark_key;
73
    uint8_t *buf;
74
    int buf_size;
75
} SVQ3Context;
76

    
77
#define FULLPEL_MODE  1
78
#define HALFPEL_MODE  2
79
#define THIRDPEL_MODE 3
80
#define PREDICT_MODE  4
81

    
82
/* dual scan (from some older h264 draft)
83
 o-->o-->o   o
84
         |  /|
85
 o   o   o / o
86
 | / |   |/  |
87
 o   o   o   o
88
   /
89
 o-->o-->o-->o
90
*/
91
static const uint8_t svq3_scan[16] = {
92
    0+0*4, 1+0*4, 2+0*4, 2+1*4,
93
    2+2*4, 3+0*4, 3+1*4, 3+2*4,
94
    0+1*4, 0+2*4, 1+1*4, 1+2*4,
95
    0+3*4, 1+3*4, 2+3*4, 3+3*4,
96
};
97

    
98
static const uint8_t svq3_pred_0[25][2] = {
99
    { 0, 0 },
100
    { 1, 0 }, { 0, 1 },
101
    { 0, 2 }, { 1, 1 }, { 2, 0 },
102
    { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
103
    { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
104
    { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
105
    { 2, 4 }, { 3, 3 }, { 4, 2 },
106
    { 4, 3 }, { 3, 4 },
107
    { 4, 4 }
108
};
109

    
110
static const int8_t svq3_pred_1[6][6][5] = {
111
    { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
112
      { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
113
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
114
      { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
115
    { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
116
      { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
117
    { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
118
      { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
119
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
120
      { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
121
    { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
122
      { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
123
};
124

    
125
static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
126
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
127
      { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
128
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
129
      { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
130
};
131

    
132
static const uint32_t svq3_dequant_coeff[32] = {
133
     3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
134
     9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
135
    24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
136
    61694, 68745, 77615, 89113,100253,109366,126635,141533
137
};
138

    
139
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
140
    const int qmul = svq3_dequant_coeff[qp];
141
#define stride 16
142
    int i;
143
    int temp[16];
144
    static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
145

    
146
    for(i=0; i<4; i++){
147
        const int z0 = 13*(input[4*i+0] +    input[4*i+2]);
148
        const int z1 = 13*(input[4*i+0] -    input[4*i+2]);
149
        const int z2 =  7* input[4*i+1] - 17*input[4*i+3];
150
        const int z3 = 17* input[4*i+1] +  7*input[4*i+3];
151

    
152
        temp[4*i+0] = z0+z3;
153
        temp[4*i+1] = z1+z2;
154
        temp[4*i+2] = z1-z2;
155
        temp[4*i+3] = z0-z3;
156
    }
157

    
158
    for(i=0; i<4; i++){
159
        const int offset= x_offset[i];
160
        const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
161
        const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
162
        const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
163
        const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
164

    
165
        output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
166
        output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
167
        output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
168
        output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
169
    }
170
}
171
#undef stride
172

    
173
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
174
                            int dc)
175
{
176
    const int qmul = svq3_dequant_coeff[qp];
177
    int i;
178
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
179

    
180
    if (dc) {
181
        dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
182
        block[0] = 0;
183
    }
184

    
185
    for (i = 0; i < 4; i++) {
186
        const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
187
        const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
188
        const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
189
        const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
190

    
191
        block[0 + 4*i] = z0 + z3;
192
        block[1 + 4*i] = z1 + z2;
193
        block[2 + 4*i] = z1 - z2;
194
        block[3 + 4*i] = z0 - z3;
195
    }
196

    
197
    for (i = 0; i < 4; i++) {
198
        const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
199
        const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
200
        const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
201
        const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
202
        const int rr = (dc + 0x80000);
203

    
204
        dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
205
        dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
206
        dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
207
        dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
208
    }
209
}
210

    
211
static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
212
                                    int index, const int type)
213
{
214
    static const uint8_t *const scan_patterns[4] =
215
    { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
216

    
217
    int run, level, sign, vlc, limit;
218
    const int intra = (3 * type) >> 2;
219
    const uint8_t *const scan = scan_patterns[type];
220

    
221
    for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
222
        for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
223

    
224
          if (vlc == INVALID_VLC)
225
              return -1;
226

    
227
          sign = (vlc & 0x1) - 1;
228
          vlc  = (vlc + 1) >> 1;
229

    
230
          if (type == 3) {
231
              if (vlc < 3) {
232
                  run   = 0;
233
                  level = vlc;
234
              } else if (vlc < 4) {
235
                  run   = 1;
236
                  level = 1;
237
              } else {
238
                  run   = (vlc & 0x3);
239
                  level = ((vlc + 9) >> 2) - run;
240
              }
241
          } else {
242
              if (vlc < 16) {
243
                  run   = svq3_dct_tables[intra][vlc].run;
244
                  level = svq3_dct_tables[intra][vlc].level;
245
              } else if (intra) {
246
                  run   = (vlc & 0x7);
247
                  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
248
              } else {
249
                  run   = (vlc & 0xF);
250
                  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
251
              }
252
          }
253

    
254
          if ((index += run) >= limit)
255
              return -1;
256

    
257
          block[scan[index]] = (level ^ sign) - sign;
258
        }
259

    
260
        if (type != 2) {
261
            break;
262
        }
263
    }
264

    
265
    return 0;
266
}
267

    
268
static inline void svq3_mc_dir_part(MpegEncContext *s,
269
                                    int x, int y, int width, int height,
270
                                    int mx, int my, int dxy,
271
                                    int thirdpel, int dir, int avg)
272
{
273
    const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
274
    uint8_t *src, *dest;
275
    int i, emu = 0;
276
    int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
277

    
278
    mx += x;
279
    my += y;
280

    
281
    if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
282
        my < 0 || my >= (s->v_edge_pos - height - 1)) {
283

    
284
        if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
285
            emu = 1;
286
        }
287

    
288
        mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
289
        my = av_clip (my, -16, (s->v_edge_pos - height + 15));
290
    }
291

    
292
    /* form component predictions */
293
    dest = s->current_picture.data[0] + x + y*s->linesize;
294
    src  = pic->data[0] + mx + my*s->linesize;
295

    
296
    if (emu) {
297
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
298
                            mx, my, s->h_edge_pos, s->v_edge_pos);
299
        src = s->edge_emu_buffer;
300
    }
301
    if (thirdpel)
302
        (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
303
    else
304
        (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
305

    
306
    if (!(s->flags & CODEC_FLAG_GRAY)) {
307
        mx     = (mx + (mx < (int) x)) >> 1;
308
        my     = (my + (my < (int) y)) >> 1;
309
        width  = (width  >> 1);
310
        height = (height >> 1);
311
        blocksize++;
312

    
313
        for (i = 1; i < 3; i++) {
314
            dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
315
            src  = pic->data[i] + mx + my*s->uvlinesize;
316

    
317
            if (emu) {
318
                s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
319
                                    mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
320
                src = s->edge_emu_buffer;
321
            }
322
            if (thirdpel)
323
                (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
324
            else
325
                (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
326
        }
327
    }
328
}
329

    
330
static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
331
                              int avg)
332
{
333
    int i, j, k, mx, my, dx, dy, x, y;
334
    MpegEncContext *const s = (MpegEncContext *) h;
335
    const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
336
    const int part_height = 16 >> ((unsigned) (size + 1) / 3);
337
    const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
338
    const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
339
    const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
340

    
341
    for (i = 0; i < 16; i += part_height) {
342
        for (j = 0; j < 16; j += part_width) {
343
            const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
344
            int dxy;
345
            x = 16*s->mb_x + j;
346
            y = 16*s->mb_y + i;
347
            k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
348

    
349
            if (mode != PREDICT_MODE) {
350
                pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
351
            } else {
352
                mx = s->next_picture.motion_val[0][b_xy][0]<<1;
353
                my = s->next_picture.motion_val[0][b_xy][1]<<1;
354

    
355
                if (dir == 0) {
356
                    mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
357
                    my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
358
                } else {
359
                    mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
360
                    my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
361
                }
362
            }
363

    
364
            /* clip motion vector prediction to frame border */
365
            mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
366
            my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
367

    
368
            /* get (optional) motion vector differential */
369
            if (mode == PREDICT_MODE) {
370
                dx = dy = 0;
371
            } else {
372
                dy = svq3_get_se_golomb(&s->gb);
373
                dx = svq3_get_se_golomb(&s->gb);
374

    
375
                if (dx == INVALID_VLC || dy == INVALID_VLC) {
376
                    av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
377
                    return -1;
378
                }
379
            }
380

    
381
            /* compute motion vector */
382
            if (mode == THIRDPEL_MODE) {
383
                int fx, fy;
384
                mx  = ((mx + 1)>>1) + dx;
385
                my  = ((my + 1)>>1) + dy;
386
                fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
387
                fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
388
                dxy = (mx - 3*fx) + 4*(my - 3*fy);
389

    
390
                svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
391
                mx += mx;
392
                my += my;
393
            } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
394
                mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
395
                my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
396
                dxy = (mx&1) + 2*(my&1);
397

    
398
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
399
                mx *= 3;
400
                my *= 3;
401
            } else {
402
                mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
403
                my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
404

    
405
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
406
                mx *= 6;
407
                my *= 6;
408
            }
409

    
410
            /* update mv_cache */
411
            if (mode != PREDICT_MODE) {
412
                int32_t mv = pack16to32(mx,my);
413

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

    
417
                    if (part_width == 8 && j < 8) {
418
                        *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
419
                    }
420
                }
421
                if (part_width == 8 && j < 8) {
422
                    *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
423
                }
424
                if (part_width == 4 || part_height == 4) {
425
                    *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
426
                }
427
            }
428

    
429
            /* write back motion vectors */
430
            fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
431
        }
432
    }
433

    
434
    return 0;
435
}
436

    
437
static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
438
{
439
    H264Context *h = &svq3->h;
440
    int i, j, k, m, dir, mode;
441
    int cbp = 0;
442
    uint32_t vlc;
443
    int8_t *top, *left;
444
    MpegEncContext *const s = (MpegEncContext *) h;
445
    const int mb_xy = h->mb_xy;
446
    const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
447

    
448
    h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
449
    h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
450
    h->topright_samples_available = 0xFFFF;
451

    
452
    if (mb_type == 0) {           /* SKIP */
453
        if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.mb_type[mb_xy] == -1) {
454
            svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
455

    
456
            if (s->pict_type == AV_PICTURE_TYPE_B) {
457
                svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
458
            }
459

    
460
            mb_type = MB_TYPE_SKIP;
461
        } else {
462
            mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
463
            if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
464
                return -1;
465
            if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
466
                return -1;
467

    
468
            mb_type = MB_TYPE_16x16;
469
        }
470
    } else if (mb_type < 8) {     /* INTER */
471
        if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
472
            mode = THIRDPEL_MODE;
473
        } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
474
            mode = HALFPEL_MODE;
475
        } else {
476
            mode = FULLPEL_MODE;
477
        }
478

    
479
        /* fill caches */
480
        /* note ref_cache should contain here:
481
            ????????
482
            ???11111
483
            N??11111
484
            N??11111
485
            N??11111
486
        */
487

    
488
        for (m = 0; m < 2; m++) {
489
            if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
490
                for (i = 0; i < 4; i++) {
491
                    *(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];
492
                }
493
            } else {
494
                for (i = 0; i < 4; i++) {
495
                    *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
496
                }
497
            }
498
            if (s->mb_y > 0) {
499
                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));
500
                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);
501

    
502
                if (s->mb_x < (s->mb_width - 1)) {
503
                    *(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];
504
                    h->ref_cache[m][scan8[0] + 4 - 1*8] =
505
                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
506
                         h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
507
                }else
508
                    h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
509
                if (s->mb_x > 0) {
510
                    *(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];
511
                    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;
512
                }else
513
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
514
            }else
515
                memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
516

    
517
            if (s->pict_type != AV_PICTURE_TYPE_B)
518
                break;
519
        }
520

    
521
        /* decode motion vector(s) and form prediction(s) */
522
        if (s->pict_type == AV_PICTURE_TYPE_P) {
523
            if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
524
                return -1;
525
        } else {        /* AV_PICTURE_TYPE_B */
526
            if (mb_type != 2) {
527
                if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
528
                    return -1;
529
            } else {
530
                for (i = 0; i < 4; i++) {
531
                    memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
532
                }
533
            }
534
            if (mb_type != 1) {
535
                if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
536
                    return -1;
537
            } else {
538
                for (i = 0; i < 4; i++) {
539
                    memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
540
                }
541
            }
542
        }
543

    
544
        mb_type = MB_TYPE_16x16;
545
    } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
546
        memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
547

    
548
        if (mb_type == 8) {
549
            if (s->mb_x > 0) {
550
                for (i = 0; i < 4; i++) {
551
                    h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
552
                }
553
                if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
554
                    h->left_samples_available = 0x5F5F;
555
                }
556
            }
557
            if (s->mb_y > 0) {
558
                h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
559
                h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
560
                h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
561
                h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
562

    
563
                if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
564
                    h->top_samples_available = 0x33FF;
565
                }
566
            }
567

    
568
            /* decode prediction codes for luma blocks */
569
            for (i = 0; i < 16; i+=2) {
570
                vlc = svq3_get_ue_golomb(&s->gb);
571

    
572
                if (vlc >= 25){
573
                    av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
574
                    return -1;
575
                }
576

    
577
                left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
578
                top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
579

    
580
                left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
581
                left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
582

    
583
                if (left[1] == -1 || left[2] == -1){
584
                    av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
585
                    return -1;
586
                }
587
            }
588
        } else {    /* mb_type == 33, DC_128_PRED block type */
589
            for (i = 0; i < 4; i++) {
590
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
591
            }
592
        }
593

    
594
        ff_h264_write_back_intra_pred_mode(h);
595

    
596
        if (mb_type == 8) {
597
            ff_h264_check_intra4x4_pred_mode(h);
598

    
599
            h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
600
            h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
601
        } else {
602
            for (i = 0; i < 4; i++) {
603
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
604
            }
605

    
606
            h->top_samples_available  = 0x33FF;
607
            h->left_samples_available = 0x5F5F;
608
        }
609

    
610
        mb_type = MB_TYPE_INTRA4x4;
611
    } else {                      /* INTRA16x16 */
612
        dir = i_mb_type_info[mb_type - 8].pred_mode;
613
        dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
614

    
615
        if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
616
            av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
617
            return -1;
618
        }
619

    
620
        cbp = i_mb_type_info[mb_type - 8].cbp;
621
        mb_type = MB_TYPE_INTRA16x16;
622
    }
623

    
624
    if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
625
        for (i = 0; i < 4; i++) {
626
            memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
627
        }
628
        if (s->pict_type == AV_PICTURE_TYPE_B) {
629
            for (i = 0; i < 4; i++) {
630
                memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
631
            }
632
        }
633
    }
634
    if (!IS_INTRA4x4(mb_type)) {
635
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
636
    }
637
    if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
638
        memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
639
        s->dsp.clear_blocks(h->mb);
640
    }
641

    
642
    if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
643
        if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
644
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
645
            return -1;
646
        }
647

    
648
        cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
649
    }
650
    if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
651
        s->qscale += svq3_get_se_golomb(&s->gb);
652

    
653
        if (s->qscale > 31){
654
            av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
655
            return -1;
656
        }
657
    }
658
    if (IS_INTRA16x16(mb_type)) {
659
        AV_ZERO128(h->mb_luma_dc+0);
660
        AV_ZERO128(h->mb_luma_dc+8);
661
        if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
662
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
663
            return -1;
664
        }
665
    }
666

    
667
    if (cbp) {
668
        const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
669
        const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
670

    
671
        for (i = 0; i < 4; i++) {
672
            if ((cbp & (1 << i))) {
673
                for (j = 0; j < 4; j++) {
674
                    k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
675
                    h->non_zero_count_cache[ scan8[k] ] = 1;
676

    
677
                    if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
678
                        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
679
                        return -1;
680
                    }
681
                }
682
            }
683
        }
684

    
685
        if ((cbp & 0x30)) {
686
            for (i = 0; i < 2; ++i) {
687
              if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
688
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
689
                return -1;
690
              }
691
            }
692

    
693
            if ((cbp & 0x20)) {
694
                for (i = 0; i < 8; i++) {
695
                    h->non_zero_count_cache[ scan8[16+i] ] = 1;
696

    
697
                    if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
698
                        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
699
                        return -1;
700
                    }
701
                }
702
            }
703
        }
704
    }
705

    
706
    h->cbp= cbp;
707
    s->current_picture.mb_type[mb_xy] = mb_type;
708

    
709
    if (IS_INTRA(mb_type)) {
710
        h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
711
    }
712

    
713
    return 0;
714
}
715

    
716
static int svq3_decode_slice_header(AVCodecContext *avctx)
717
{
718
    SVQ3Context *svq3 = avctx->priv_data;
719
    H264Context *h = &svq3->h;
720
    MpegEncContext *s = &h->s;
721
    const int mb_xy = h->mb_xy;
722
    int i, header;
723

    
724
    header = get_bits(&s->gb, 8);
725

    
726
    if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
727
        /* TODO: what? */
728
        av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
729
        return -1;
730
    } else {
731
        int length = (header >> 5) & 3;
732

    
733
        svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
734

    
735
        if (svq3->next_slice_index > s->gb.size_in_bits) {
736
            av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
737
            return -1;
738
    }
739

    
740
        s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
741
        skip_bits(&s->gb, 8);
742

    
743
        if (svq3->watermark_key) {
744
            uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
745
            AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
746
        }
747
        if (length > 0) {
748
            memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
749
                   &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
750
        }
751
        skip_bits_long(&s->gb, 0);
752
    }
753

    
754
    if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
755
        av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
756
        return -1;
757
    }
758

    
759
    h->slice_type = golomb_to_pict_type[i];
760

    
761
    if ((header & 0x9F) == 2) {
762
        i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
763
        s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
764
    } else {
765
        skip_bits1(&s->gb);
766
        s->mb_skip_run = 0;
767
    }
768

    
769
    h->slice_num = get_bits(&s->gb, 8);
770
    s->qscale = get_bits(&s->gb, 5);
771
    s->adaptive_quant = get_bits1(&s->gb);
772

    
773
    /* unknown fields */
774
    skip_bits1(&s->gb);
775

    
776
    if (svq3->unknown_flag) {
777
        skip_bits1(&s->gb);
778
    }
779

    
780
    skip_bits1(&s->gb);
781
    skip_bits(&s->gb, 2);
782

    
783
    while (get_bits1(&s->gb)) {
784
        skip_bits(&s->gb, 8);
785
    }
786

    
787
    /* reset intra predictors and invalidate motion vector references */
788
    if (s->mb_x > 0) {
789
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1      ]+3, -1, 4*sizeof(int8_t));
790
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x]  , -1, 8*sizeof(int8_t)*s->mb_x);
791
    }
792
    if (s->mb_y > 0) {
793
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
794

    
795
        if (s->mb_x > 0) {
796
            h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
797
        }
798
    }
799

    
800
    return 0;
801
}
802

    
803
static av_cold int svq3_decode_init(AVCodecContext *avctx)
804
{
805
    SVQ3Context *svq3 = avctx->priv_data;
806
    H264Context *h = &svq3->h;
807
    MpegEncContext *s = &h->s;
808
    int m;
809
    unsigned char *extradata;
810
    unsigned int size;
811

    
812
    if (ff_h264_decode_init(avctx) < 0)
813
        return -1;
814

    
815
    s->flags  = avctx->flags;
816
    s->flags2 = avctx->flags2;
817
    s->unrestricted_mv = 1;
818
    h->is_complex=1;
819
    avctx->pix_fmt = avctx->codec->pix_fmts[0];
820

    
821
    if (!s->context_initialized) {
822
        s->width  = avctx->width;
823
        s->height = avctx->height;
824
        h->chroma_qp[0] = h->chroma_qp[1] = 4;
825

    
826
        svq3->halfpel_flag = 1;
827
        svq3->thirdpel_flag = 1;
828
        svq3->unknown_flag = 0;
829

    
830
        if (MPV_common_init(s) < 0)
831
            return -1;
832

    
833
        h->b_stride = 4*s->mb_width;
834

    
835
        ff_h264_alloc_tables(h);
836

    
837
        /* prowl for the "SEQH" marker in the extradata */
838
        extradata = (unsigned char *)avctx->extradata;
839
        for (m = 0; m < avctx->extradata_size; m++) {
840
            if (!memcmp(extradata, "SEQH", 4))
841
                break;
842
            extradata++;
843
        }
844

    
845
        /* if a match was found, parse the extra data */
846
        if (extradata && !memcmp(extradata, "SEQH", 4)) {
847

    
848
            GetBitContext gb;
849
            int frame_size_code;
850

    
851
            size = AV_RB32(&extradata[4]);
852
            init_get_bits(&gb, extradata + 8, size*8);
853

    
854
            /* 'frame size code' and optional 'width, height' */
855
            frame_size_code = get_bits(&gb, 3);
856
            switch (frame_size_code) {
857
                case 0: avctx->width = 160; avctx->height = 120; break;
858
                case 1: avctx->width = 128; avctx->height =  96; break;
859
                case 2: avctx->width = 176; avctx->height = 144; break;
860
                case 3: avctx->width = 352; avctx->height = 288; break;
861
                case 4: avctx->width = 704; avctx->height = 576; break;
862
                case 5: avctx->width = 240; avctx->height = 180; break;
863
                case 6: avctx->width = 320; avctx->height = 240; break;
864
                case 7:
865
                    avctx->width  = get_bits(&gb, 12);
866
                    avctx->height = get_bits(&gb, 12);
867
                    break;
868
            }
869

    
870
            svq3->halfpel_flag  = get_bits1(&gb);
871
            svq3->thirdpel_flag = get_bits1(&gb);
872

    
873
            /* unknown fields */
874
            skip_bits1(&gb);
875
            skip_bits1(&gb);
876
            skip_bits1(&gb);
877
            skip_bits1(&gb);
878

    
879
            s->low_delay = get_bits1(&gb);
880

    
881
            /* unknown field */
882
            skip_bits1(&gb);
883

    
884
            while (get_bits1(&gb)) {
885
                skip_bits(&gb, 8);
886
            }
887

    
888
            svq3->unknown_flag = get_bits1(&gb);
889
            avctx->has_b_frames = !s->low_delay;
890
            if (svq3->unknown_flag) {
891
#if CONFIG_ZLIB
892
                unsigned watermark_width  = svq3_get_ue_golomb(&gb);
893
                unsigned watermark_height = svq3_get_ue_golomb(&gb);
894
                int u1 = svq3_get_ue_golomb(&gb);
895
                int u2 = get_bits(&gb, 8);
896
                int u3 = get_bits(&gb, 2);
897
                int u4 = svq3_get_ue_golomb(&gb);
898
                unsigned long buf_len = watermark_width*watermark_height*4;
899
                int offset = (get_bits_count(&gb)+7)>>3;
900
                uint8_t *buf;
901

    
902
                if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
903
                    return -1;
904

    
905
                buf = av_malloc(buf_len);
906
                av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
907
                av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
908
                if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
909
                    av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
910
                    av_free(buf);
911
                    return -1;
912
                }
913
                svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
914
                svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
915
                av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
916
                av_free(buf);
917
#else
918
                av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
919
                return -1;
920
#endif
921
            }
922
        }
923
    }
924

    
925
    return 0;
926
}
927

    
928
static int svq3_decode_frame(AVCodecContext *avctx,
929
                             void *data, int *data_size,
930
                             AVPacket *avpkt)
931
{
932
    SVQ3Context *svq3 = avctx->priv_data;
933
    H264Context *h = &svq3->h;
934
    MpegEncContext *s = &h->s;
935
    int buf_size = avpkt->size;
936
    int m, mb_type, left;
937
    uint8_t *buf;
938

    
939
    /* special case for last picture */
940
    if (buf_size == 0) {
941
        if (s->next_picture_ptr && !s->low_delay) {
942
            *(AVFrame *) data = *(AVFrame *) &s->next_picture;
943
            s->next_picture_ptr = NULL;
944
            *data_size = sizeof(AVFrame);
945
        }
946
        return 0;
947
    }
948

    
949
    s->mb_x = s->mb_y = h->mb_xy = 0;
950

    
951
    if (svq3->watermark_key) {
952
        svq3->buf = av_fast_realloc(svq3->buf, &svq3->buf_size,
953
                                    buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
954
        if (!svq3->buf)
955
            return AVERROR(ENOMEM);
956
        memcpy(svq3->buf, avpkt->data, buf_size);
957
        buf = svq3->buf;
958
    } else {
959
        buf = avpkt->data;
960
    }
961

    
962
    init_get_bits(&s->gb, buf, 8*buf_size);
963

    
964
    if (svq3_decode_slice_header(avctx))
965
        return -1;
966

    
967
    s->pict_type = h->slice_type;
968
    s->picture_number = h->slice_num;
969

    
970
    if (avctx->debug&FF_DEBUG_PICT_INFO){
971
        av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
972
               av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
973
               s->adaptive_quant, s->qscale, h->slice_num);
974
    }
975

    
976
    /* for skipping the frame */
977
    s->current_picture.pict_type = s->pict_type;
978
    s->current_picture.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
979

    
980
    /* Skip B-frames if we do not have reference frames. */
981
    if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
982
        return 0;
983
    if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
984
        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
985
        || avctx->skip_frame >= AVDISCARD_ALL)
986
        return 0;
987

    
988
    if (s->next_p_frame_damaged) {
989
        if (s->pict_type == AV_PICTURE_TYPE_B)
990
            return 0;
991
        else
992
            s->next_p_frame_damaged = 0;
993
    }
994

    
995
    if (ff_h264_frame_start(h) < 0)
996
        return -1;
997

    
998
    if (s->pict_type == AV_PICTURE_TYPE_B) {
999
        h->frame_num_offset = (h->slice_num - h->prev_frame_num);
1000

    
1001
        if (h->frame_num_offset < 0) {
1002
            h->frame_num_offset += 256;
1003
        }
1004
        if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1005
            av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1006
            return -1;
1007
        }
1008
    } else {
1009
        h->prev_frame_num = h->frame_num;
1010
        h->frame_num = h->slice_num;
1011
        h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1012

    
1013
        if (h->prev_frame_num_offset < 0) {
1014
            h->prev_frame_num_offset += 256;
1015
        }
1016
    }
1017

    
1018
    for (m = 0; m < 2; m++){
1019
        int i;
1020
        for (i = 0; i < 4; i++){
1021
            int j;
1022
            for (j = -1; j < 4; j++)
1023
                h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1024
            if (i < 3)
1025
                h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1026
        }
1027
    }
1028

    
1029
    for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1030
        for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1031
            h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1032

    
1033
            if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1034
                ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1035

    
1036
                skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1037
                s->gb.size_in_bits = 8*buf_size;
1038

    
1039
                if (svq3_decode_slice_header(avctx))
1040
                    return -1;
1041

    
1042
                /* TODO: support s->mb_skip_run */
1043
            }
1044

    
1045
            mb_type = svq3_get_ue_golomb(&s->gb);
1046

    
1047
            if (s->pict_type == AV_PICTURE_TYPE_I) {
1048
                mb_type += 8;
1049
            } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1050
                mb_type += 4;
1051
            }
1052
            if (mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1053
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1054
                return -1;
1055
            }
1056

    
1057
            if (mb_type != 0) {
1058
                ff_h264_hl_decode_mb (h);
1059
            }
1060

    
1061
            if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1062
                s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1063
                    (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1064
            }
1065
        }
1066

    
1067
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
1068
    }
1069

    
1070
    left = buf_size*8 - get_bits_count(&s->gb);
1071

    
1072
    if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1073
        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);
1074
        //av_hex_dump(stderr, buf+buf_size-8, 8);
1075
    }
1076

    
1077
    if (left < 0) {
1078
        av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1079
        return -1;
1080
    }
1081

    
1082
    MPV_frame_end(s);
1083

    
1084
    if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1085
        *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1086
    } else {
1087
        *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1088
    }
1089

    
1090
    /* Do not output the last pic after seeking. */
1091
    if (s->last_picture_ptr || s->low_delay) {
1092
        *data_size = sizeof(AVFrame);
1093
    }
1094

    
1095
    return buf_size;
1096
}
1097

    
1098
static int svq3_decode_end(AVCodecContext *avctx)
1099
{
1100
    SVQ3Context *svq3 = avctx->priv_data;
1101
    H264Context *h = &svq3->h;
1102
    MpegEncContext *s = &h->s;
1103

    
1104
    ff_h264_free_context(h);
1105

    
1106
    MPV_common_end(s);
1107

    
1108
    av_freep(&svq3->buf);
1109
    svq3->buf_size = 0;
1110

    
1111
    return 0;
1112
}
1113

    
1114
AVCodec ff_svq3_decoder = {
1115
    "svq3",
1116
    AVMEDIA_TYPE_VIDEO,
1117
    CODEC_ID_SVQ3,
1118
    sizeof(SVQ3Context),
1119
    svq3_decode_init,
1120
    NULL,
1121
    svq3_decode_end,
1122
    svq3_decode_frame,
1123
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1124
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1125
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1126
};