Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ b0e7a932

History | View | Annotate | Download (39.3 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
} SVQ3Context;
74

    
75
#define FULLPEL_MODE  1
76
#define HALFPEL_MODE  2
77
#define THIRDPEL_MODE 3
78
#define PREDICT_MODE  4
79

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
222
          if (vlc == INVALID_VLC)
223
              return -1;
224

    
225
          sign = (vlc & 0x1) - 1;
226
          vlc  = (vlc + 1) >> 1;
227

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

    
252
          if ((index += run) >= limit)
253
              return -1;
254

    
255
          block[scan[index]] = (level ^ sign) - sign;
256
        }
257

    
258
        if (type != 2) {
259
            break;
260
        }
261
    }
262

    
263
    return 0;
264
}
265

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

    
276
    mx += x;
277
    my += y;
278

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
432
    return 0;
433
}
434

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

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

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

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

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

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

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

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

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

    
515
            if (s->pict_type != AV_PICTURE_TYPE_B)
516
                break;
517
        }
518

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

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

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

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

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

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

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

    
578
                left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
579
                left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
580

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

    
592
        ff_h264_write_back_intra_pred_mode(h);
593

    
594
        if (mb_type == 8) {
595
            ff_h264_check_intra4x4_pred_mode(h);
596

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

    
604
            h->top_samples_available  = 0x33FF;
605
            h->left_samples_available = 0x5F5F;
606
        }
607

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

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

    
618
        cbp = i_mb_type_info[mb_type - 8].cbp;
619
        mb_type = MB_TYPE_INTRA16x16;
620
    }
621

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

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

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

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

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

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

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

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

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

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

    
704
    h->cbp= cbp;
705
    s->current_picture.mb_type[mb_xy] = mb_type;
706

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

    
711
    return 0;
712
}
713

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

    
722
    header = get_bits(&s->gb, 8);
723

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

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

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

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

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

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

    
757
    h->slice_type = golomb_to_pict_type[i];
758

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

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

    
771
    /* unknown fields */
772
    skip_bits1(&s->gb);
773

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

    
778
    skip_bits1(&s->gb);
779
    skip_bits(&s->gb, 2);
780

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

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

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

    
798
    return 0;
799
}
800

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

    
810
    if (ff_h264_decode_init(avctx) < 0)
811
        return -1;
812

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

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

    
824
        svq3->halfpel_flag = 1;
825
        svq3->thirdpel_flag = 1;
826
        svq3->unknown_flag = 0;
827

    
828
        if (MPV_common_init(s) < 0)
829
            return -1;
830

    
831
        h->b_stride = 4*s->mb_width;
832

    
833
        ff_h264_alloc_tables(h);
834

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

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

    
846
            GetBitContext gb;
847
            int frame_size_code;
848

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

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

    
868
            svq3->halfpel_flag  = get_bits1(&gb);
869
            svq3->thirdpel_flag = get_bits1(&gb);
870

    
871
            /* unknown fields */
872
            skip_bits1(&gb);
873
            skip_bits1(&gb);
874
            skip_bits1(&gb);
875
            skip_bits1(&gb);
876

    
877
            s->low_delay = get_bits1(&gb);
878

    
879
            /* unknown field */
880
            skip_bits1(&gb);
881

    
882
            while (get_bits1(&gb)) {
883
                skip_bits(&gb, 8);
884
            }
885

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

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

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

    
923
    return 0;
924
}
925

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

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

    
947
    init_get_bits (&s->gb, buf, 8*buf_size);
948

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

    
951
    if (svq3_decode_slice_header(avctx))
952
        return -1;
953

    
954
    s->pict_type = h->slice_type;
955
    s->picture_number = h->slice_num;
956

    
957
    if (avctx->debug&FF_DEBUG_PICT_INFO){
958
        av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
959
               av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
960
               s->adaptive_quant, s->qscale, h->slice_num);
961
    }
962

    
963
    /* for skipping the frame */
964
    s->current_picture.pict_type = s->pict_type;
965
    s->current_picture.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
966

    
967
    /* Skip B-frames if we do not have reference frames. */
968
    if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
969
        return 0;
970
    if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
971
        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
972
        || avctx->skip_frame >= AVDISCARD_ALL)
973
        return 0;
974

    
975
    if (s->next_p_frame_damaged) {
976
        if (s->pict_type == AV_PICTURE_TYPE_B)
977
            return 0;
978
        else
979
            s->next_p_frame_damaged = 0;
980
    }
981

    
982
    if (ff_h264_frame_start(h) < 0)
983
        return -1;
984

    
985
    if (s->pict_type == AV_PICTURE_TYPE_B) {
986
        h->frame_num_offset = (h->slice_num - h->prev_frame_num);
987

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

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

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

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

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

    
1023
                skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1024
                s->gb.size_in_bits = 8*buf_size;
1025

    
1026
                if (svq3_decode_slice_header(avctx))
1027
                    return -1;
1028

    
1029
                /* TODO: support s->mb_skip_run */
1030
            }
1031

    
1032
            mb_type = svq3_get_ue_golomb(&s->gb);
1033

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

    
1044
            if (mb_type != 0) {
1045
                ff_h264_hl_decode_mb (h);
1046
            }
1047

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

    
1054
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
1055
    }
1056

    
1057
    left = buf_size*8 - get_bits_count(&s->gb);
1058

    
1059
    if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1060
        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);
1061
        //av_hex_dump(stderr, buf+buf_size-8, 8);
1062
    }
1063

    
1064
    if (left < 0) {
1065
        av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1066
        return -1;
1067
    }
1068

    
1069
    MPV_frame_end(s);
1070

    
1071
    if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1072
        *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1073
    } else {
1074
        *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1075
    }
1076

    
1077
    /* Do not output the last pic after seeking. */
1078
    if (s->last_picture_ptr || s->low_delay) {
1079
        *data_size = sizeof(AVFrame);
1080
    }
1081

    
1082
    return buf_size;
1083
}
1084

    
1085
static int svq3_decode_end(AVCodecContext *avctx)
1086
{
1087
    SVQ3Context *svq3 = avctx->priv_data;
1088
    H264Context *h = &svq3->h;
1089
    MpegEncContext *s = &h->s;
1090

    
1091
    ff_h264_free_context(h);
1092

    
1093
    MPV_common_end(s);
1094

    
1095
    return 0;
1096
}
1097

    
1098
AVCodec ff_svq3_decoder = {
1099
    "svq3",
1100
    AVMEDIA_TYPE_VIDEO,
1101
    CODEC_ID_SVQ3,
1102
    sizeof(SVQ3Context),
1103
    svq3_decode_init,
1104
    NULL,
1105
    svq3_decode_end,
1106
    svq3_decode_frame,
1107
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1108
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1109
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1110
};