Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 8ed2ae09

History | View | Annotate | Download (38.4 KB)

1
/*
2
 * Copyright (c) 2003 The Libav Project
3
 *
4
 * This file is part of Libav.
5
 *
6
 * Libav is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * Libav is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with Libav; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20

    
21
/*
22
 * How to use this decoder:
23
 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24
 * have stsd atoms to describe media trak properties. A stsd atom for a
25
 * video trak contains 1 or more ImageDescription atoms. These atoms begin
26
 * with the 4-byte length of the atom followed by the codec fourcc. Some
27
 * decoders need information in this atom to operate correctly. Such
28
 * is the case with SVQ3. In order to get the best use out of this decoder,
29
 * the calling app must make the SVQ3 ImageDescription atom available
30
 * via the AVCodecContext's extradata[_size] field:
31
 *
32
 * AVCodecContext.extradata = pointer to ImageDescription, first characters
33
 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34
 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35
 * buffer (which will be the same as the ImageDescription atom size field
36
 * from the QT file, minus 4 bytes since the length is missing)
37
 *
38
 * You will know you have these parameters passed correctly when the decoder
39
 * correctly decodes this file:
40
 *  http://samples.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
#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
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
129
    const int qmul = svq3_dequant_coeff[qp];
130
#define stride 16
131
    int i;
132
    int temp[16];
133
    static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
134

    
135
    for(i=0; i<4; i++){
136
        const int z0 = 13*(input[4*i+0] +    input[4*i+2]);
137
        const int z1 = 13*(input[4*i+0] -    input[4*i+2]);
138
        const int z2 =  7* input[4*i+1] - 17*input[4*i+3];
139
        const int z3 = 17* input[4*i+1] +  7*input[4*i+3];
140

    
141
        temp[4*i+0] = z0+z3;
142
        temp[4*i+1] = z1+z2;
143
        temp[4*i+2] = z1-z2;
144
        temp[4*i+3] = z0-z3;
145
    }
146

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

    
154
        output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
155
        output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
156
        output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
157
        output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
158
    }
159
}
160
#undef stride
161

    
162
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
163
                            int dc)
164
{
165
    const int qmul = svq3_dequant_coeff[qp];
166
    int i;
167
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
168

    
169
    if (dc) {
170
        dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
171
        block[0] = 0;
172
    }
173

    
174
    for (i = 0; i < 4; i++) {
175
        const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
176
        const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
177
        const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
178
        const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
179

    
180
        block[0 + 4*i] = z0 + z3;
181
        block[1 + 4*i] = z1 + z2;
182
        block[2 + 4*i] = z1 - z2;
183
        block[3 + 4*i] = z0 - z3;
184
    }
185

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

    
193
        dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
194
        dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
195
        dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
196
        dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
197
    }
198
}
199

    
200
static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
201
                                    int index, const int type)
202
{
203
    static const uint8_t *const scan_patterns[4] =
204
    { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
205

    
206
    int run, level, sign, vlc, limit;
207
    const int intra = (3 * type) >> 2;
208
    const uint8_t *const scan = scan_patterns[type];
209

    
210
    for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
211
        for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
212

    
213
          if (vlc == INVALID_VLC)
214
              return -1;
215

    
216
          sign = (vlc & 0x1) - 1;
217
          vlc  = (vlc + 1) >> 1;
218

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

    
243
          if ((index += run) >= limit)
244
              return -1;
245

    
246
          block[scan[index]] = (level ^ sign) - sign;
247
        }
248

    
249
        if (type != 2) {
250
            break;
251
        }
252
    }
253

    
254
    return 0;
255
}
256

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

    
267
    mx += x;
268
    my += y;
269

    
270
    if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
271
        my < 0 || my >= (s->v_edge_pos - height - 1)) {
272

    
273
        if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
274
            emu = 1;
275
        }
276

    
277
        mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
278
        my = av_clip (my, -16, (s->v_edge_pos - height + 15));
279
    }
280

    
281
    /* form component predictions */
282
    dest = s->current_picture.data[0] + x + y*s->linesize;
283
    src  = pic->data[0] + mx + my*s->linesize;
284

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

    
295
    if (!(s->flags & CODEC_FLAG_GRAY)) {
296
        mx     = (mx + (mx < (int) x)) >> 1;
297
        my     = (my + (my < (int) y)) >> 1;
298
        width  = (width  >> 1);
299
        height = (height >> 1);
300
        blocksize++;
301

    
302
        for (i = 1; i < 3; i++) {
303
            dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
304
            src  = pic->data[i] + mx + my*s->uvlinesize;
305

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

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

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

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

    
344
                if (dir == 0) {
345
                    mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
346
                    my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
347
                } else {
348
                    mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
349
                    my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
350
                }
351
            }
352

    
353
            /* clip motion vector prediction to frame border */
354
            mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
355
            my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
356

    
357
            /* get (optional) motion vector differential */
358
            if (mode == PREDICT_MODE) {
359
                dx = dy = 0;
360
            } else {
361
                dy = svq3_get_se_golomb(&s->gb);
362
                dx = svq3_get_se_golomb(&s->gb);
363

    
364
                if (dx == INVALID_VLC || dy == INVALID_VLC) {
365
                    av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
366
                    return -1;
367
                }
368
            }
369

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

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

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

    
394
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
395
                mx *= 6;
396
                my *= 6;
397
            }
398

    
399
            /* update mv_cache */
400
            if (mode != PREDICT_MODE) {
401
                int32_t mv = pack16to32(mx,my);
402

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

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

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

    
423
    return 0;
424
}
425

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

    
436
    h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
437
    h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
438
    h->topright_samples_available = 0xFFFF;
439

    
440
    if (mb_type == 0) {           /* SKIP */
441
        if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
442
            svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
443

    
444
            if (s->pict_type == FF_B_TYPE) {
445
                svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
446
            }
447

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

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

    
467
        /* fill caches */
468
        /* note ref_cache should contain here:
469
            ????????
470
            ???11111
471
            N??11111
472
            N??11111
473
            N??11111
474
        */
475

    
476
        for (m = 0; m < 2; m++) {
477
            if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
478
                for (i = 0; i < 4; i++) {
479
                    *(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];
480
                }
481
            } else {
482
                for (i = 0; i < 4; i++) {
483
                    *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
484
                }
485
            }
486
            if (s->mb_y > 0) {
487
                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));
488
                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);
489

    
490
                if (s->mb_x < (s->mb_width - 1)) {
491
                    *(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];
492
                    h->ref_cache[m][scan8[0] + 4 - 1*8] =
493
                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
494
                         h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
495
                }else
496
                    h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
497
                if (s->mb_x > 0) {
498
                    *(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];
499
                    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;
500
                }else
501
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
502
            }else
503
                memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
504

    
505
            if (s->pict_type != FF_B_TYPE)
506
                break;
507
        }
508

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

    
532
        mb_type = MB_TYPE_16x16;
533
    } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
534
        memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
535

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

    
551
                if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
552
                    h->top_samples_available = 0x33FF;
553
                }
554
            }
555

    
556
            /* decode prediction codes for luma blocks */
557
            for (i = 0; i < 16; i+=2) {
558
                vlc = svq3_get_ue_golomb(&s->gb);
559

    
560
                if (vlc >= 25){
561
                    av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
562
                    return -1;
563
                }
564

    
565
                left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
566
                top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
567

    
568
                left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
569
                left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
570

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

    
582
        ff_h264_write_back_intra_pred_mode(h);
583

    
584
        if (mb_type == 8) {
585
            ff_h264_check_intra4x4_pred_mode(h);
586

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

    
594
            h->top_samples_available  = 0x33FF;
595
            h->left_samples_available = 0x5F5F;
596
        }
597

    
598
        mb_type = MB_TYPE_INTRA4x4;
599
    } else {                      /* INTRA16x16 */
600
        dir = i_mb_type_info[mb_type - 8].pred_mode;
601
        dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
602

    
603
        if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
604
            av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
605
            return -1;
606
        }
607

    
608
        cbp = i_mb_type_info[mb_type - 8].cbp;
609
        mb_type = MB_TYPE_INTRA16x16;
610
    }
611

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

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

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

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

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

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

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

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

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

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

    
694
    h->cbp= cbp;
695
    s->current_picture.mb_type[mb_xy] = mb_type;
696

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

    
701
    return 0;
702
}
703

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

    
710
    header = get_bits(&s->gb, 8);
711

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

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

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

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

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

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

    
745
    h->slice_type = golomb_to_pict_type[i];
746

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

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

    
759
    /* unknown fields */
760
    skip_bits1(&s->gb);
761

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

    
766
    skip_bits1(&s->gb);
767
    skip_bits(&s->gb, 2);
768

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

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

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

    
786
    return 0;
787
}
788

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

    
797
    if (ff_h264_decode_init(avctx) < 0)
798
        return -1;
799

    
800
    s->flags  = avctx->flags;
801
    s->flags2 = avctx->flags2;
802
    s->unrestricted_mv = 1;
803
    h->is_complex=1;
804
    avctx->pix_fmt = avctx->codec->pix_fmts[0];
805

    
806
    if (!s->context_initialized) {
807
        s->width  = avctx->width;
808
        s->height = avctx->height;
809
        h->halfpel_flag      = 1;
810
        h->thirdpel_flag     = 1;
811
        h->unknown_svq3_flag = 0;
812
        h->chroma_qp[0]      = h->chroma_qp[1] = 4;
813

    
814
        if (MPV_common_init(s) < 0)
815
            return -1;
816

    
817
        h->b_stride = 4*s->mb_width;
818

    
819
        ff_h264_alloc_tables(h);
820

    
821
        /* prowl for the "SEQH" marker in the extradata */
822
        extradata = (unsigned char *)avctx->extradata;
823
        for (m = 0; m < avctx->extradata_size; m++) {
824
            if (!memcmp(extradata, "SEQH", 4))
825
                break;
826
            extradata++;
827
        }
828

    
829
        /* if a match was found, parse the extra data */
830
        if (extradata && !memcmp(extradata, "SEQH", 4)) {
831

    
832
            GetBitContext gb;
833
            int frame_size_code;
834

    
835
            size = AV_RB32(&extradata[4]);
836
            init_get_bits(&gb, extradata + 8, size*8);
837

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

    
854
            h->halfpel_flag  = get_bits1(&gb);
855
            h->thirdpel_flag = get_bits1(&gb);
856

    
857
            /* unknown fields */
858
            skip_bits1(&gb);
859
            skip_bits1(&gb);
860
            skip_bits1(&gb);
861
            skip_bits1(&gb);
862

    
863
            s->low_delay = get_bits1(&gb);
864

    
865
            /* unknown field */
866
            skip_bits1(&gb);
867

    
868
            while (get_bits1(&gb)) {
869
                skip_bits(&gb, 8);
870
            }
871

    
872
            h->unknown_svq3_flag = get_bits1(&gb);
873
            avctx->has_b_frames = !s->low_delay;
874
            if (h->unknown_svq3_flag) {
875
#if CONFIG_ZLIB
876
                unsigned watermark_width  = svq3_get_ue_golomb(&gb);
877
                unsigned watermark_height = svq3_get_ue_golomb(&gb);
878
                int u1 = svq3_get_ue_golomb(&gb);
879
                int u2 = get_bits(&gb, 8);
880
                int u3 = get_bits(&gb, 2);
881
                int u4 = svq3_get_ue_golomb(&gb);
882
                unsigned long buf_len = watermark_width*watermark_height*4;
883
                int offset = (get_bits_count(&gb)+7)>>3;
884
                uint8_t *buf;
885

    
886
                if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
887
                    return -1;
888

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

    
909
    return 0;
910
}
911

    
912
static int svq3_decode_frame(AVCodecContext *avctx,
913
                             void *data, int *data_size,
914
                             AVPacket *avpkt)
915
{
916
    const uint8_t *buf = avpkt->data;
917
    int buf_size = avpkt->size;
918
    MpegEncContext *const s = avctx->priv_data;
919
    H264Context *const h = avctx->priv_data;
920
    int m, mb_type;
921

    
922
    /* special case for last picture */
923
    if (buf_size == 0) {
924
        if (s->next_picture_ptr && !s->low_delay) {
925
            *(AVFrame *) data = *(AVFrame *) &s->next_picture;
926
            s->next_picture_ptr = NULL;
927
            *data_size = sizeof(AVFrame);
928
        }
929
        return 0;
930
    }
931

    
932
    init_get_bits (&s->gb, buf, 8*buf_size);
933

    
934
    s->mb_x = s->mb_y = h->mb_xy = 0;
935

    
936
    if (svq3_decode_slice_header(h))
937
        return -1;
938

    
939
    s->pict_type = h->slice_type;
940
    s->picture_number = h->slice_num;
941

    
942
    if (avctx->debug&FF_DEBUG_PICT_INFO){
943
        av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
944
               av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
945
               s->adaptive_quant, s->qscale, h->slice_num);
946
    }
947

    
948
    /* for skipping the frame */
949
    s->current_picture.pict_type = s->pict_type;
950
    s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
951

    
952
    /* Skip B-frames if we do not have reference frames. */
953
    if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
954
        return 0;
955
#if FF_API_HURRY_UP
956
    /* Skip B-frames if we are in a hurry. */
957
    if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
958
        return 0;
959
    /* Skip everything if we are in a hurry >= 5. */
960
    if (avctx->hurry_up >= 5)
961
        return 0;
962
#endif
963
    if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
964
        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
965
        || avctx->skip_frame >= AVDISCARD_ALL)
966
        return 0;
967

    
968
    if (s->next_p_frame_damaged) {
969
        if (s->pict_type == FF_B_TYPE)
970
            return 0;
971
        else
972
            s->next_p_frame_damaged = 0;
973
    }
974

    
975
    if (ff_h264_frame_start(h) < 0)
976
        return -1;
977

    
978
    if (s->pict_type == FF_B_TYPE) {
979
        h->frame_num_offset = (h->slice_num - h->prev_frame_num);
980

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

    
993
        if (h->prev_frame_num_offset < 0) {
994
            h->prev_frame_num_offset += 256;
995
        }
996
    }
997

    
998
    for (m = 0; m < 2; m++){
999
        int i;
1000
        for (i = 0; i < 4; i++){
1001
            int j;
1002
            for (j = -1; j < 4; j++)
1003
                h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1004
            if (i < 3)
1005
                h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1006
        }
1007
    }
1008

    
1009
    for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1010
        for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1011
            h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1012

    
1013
            if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1014
                ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1015

    
1016
                skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
1017
                s->gb.size_in_bits = 8*buf_size;
1018

    
1019
                if (svq3_decode_slice_header(h))
1020
                    return -1;
1021

    
1022
                /* TODO: support s->mb_skip_run */
1023
            }
1024

    
1025
            mb_type = svq3_get_ue_golomb(&s->gb);
1026

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

    
1037
            if (mb_type != 0) {
1038
                ff_h264_hl_decode_mb (h);
1039
            }
1040

    
1041
            if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1042
                s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1043
                    (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1044
            }
1045
        }
1046

    
1047
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
1048
    }
1049

    
1050
    MPV_frame_end(s);
1051

    
1052
    if (s->pict_type == FF_B_TYPE || s->low_delay) {
1053
        *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1054
    } else {
1055
        *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1056
    }
1057

    
1058
    /* Do not output the last pic after seeking. */
1059
    if (s->last_picture_ptr || s->low_delay) {
1060
        *data_size = sizeof(AVFrame);
1061
    }
1062

    
1063
    return buf_size;
1064
}
1065

    
1066

    
1067
AVCodec ff_svq3_decoder = {
1068
    "svq3",
1069
    AVMEDIA_TYPE_VIDEO,
1070
    CODEC_ID_SVQ3,
1071
    sizeof(H264Context),
1072
    svq3_decode_init,
1073
    NULL,
1074
    ff_h264_decode_end,
1075
    svq3_decode_frame,
1076
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1077
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1078
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1079
};