Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 54dab661

History | View | Annotate | Download (37.2 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
 *  ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41
 */
42

    
43
#ifdef CONFIG_ZLIB
44
#include <zlib.h>
45
#endif
46

    
47
#include "svq1.h"
48

    
49
/**
50
 * @file svq3.c
51
 * svq3 decoder.
52
 */
53

    
54
#define FULLPEL_MODE  1
55
#define HALFPEL_MODE  2
56
#define THIRDPEL_MODE 3
57
#define PREDICT_MODE  4
58

    
59
/* dual scan (from some older h264 draft)
60
 o-->o-->o   o
61
         |  /|
62
 o   o   o / o
63
 | / |   |/  |
64
 o   o   o   o
65
   /
66
 o-->o-->o-->o
67
*/
68
static const uint8_t svq3_scan[16] = {
69
    0+0*4, 1+0*4, 2+0*4, 2+1*4,
70
    2+2*4, 3+0*4, 3+1*4, 3+2*4,
71
    0+1*4, 0+2*4, 1+1*4, 1+2*4,
72
    0+3*4, 1+3*4, 2+3*4, 3+3*4,
73
};
74

    
75
static const uint8_t svq3_pred_0[25][2] = {
76
    { 0, 0 },
77
    { 1, 0 }, { 0, 1 },
78
    { 0, 2 }, { 1, 1 }, { 2, 0 },
79
    { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
80
    { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
81
    { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
82
    { 2, 4 }, { 3, 3 }, { 4, 2 },
83
    { 4, 3 }, { 3, 4 },
84
    { 4, 4 }
85
};
86

    
87
static const int8_t svq3_pred_1[6][6][5] = {
88
    { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
89
      { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
90
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
91
      { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
92
    { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
93
      { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
94
    { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
95
      { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
96
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
97
      { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
98
    { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
99
      { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
100
};
101

    
102
static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
103
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
104
      { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
105
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
106
      { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
107
};
108

    
109
static const uint32_t svq3_dequant_coeff[32] = {
110
     3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
111
     9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
112
    24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
113
    61694, 68745, 77615, 89113,100253,109366,126635,141533
114
};
115

    
116

    
117
static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp)
118
{
119
    const int qmul = svq3_dequant_coeff[qp];
120
#define stride 16
121
    int i;
122
    int temp[16];
123
    static const int x_offset[4] = {0, 1*stride, 4* stride,  5*stride};
124
    static const int y_offset[4] = {0, 2*stride, 8* stride, 10*stride};
125

    
126
    for (i = 0; i < 4; i++){
127
        const int offset = y_offset[i];
128
        const int z0 = 13*(block[offset+stride*0] +    block[offset+stride*4]);
129
        const int z1 = 13*(block[offset+stride*0] -    block[offset+stride*4]);
130
        const int z2 =  7* block[offset+stride*1] - 17*block[offset+stride*5];
131
        const int z3 = 17* block[offset+stride*1] +  7*block[offset+stride*5];
132

    
133
        temp[4*i+0] = z0+z3;
134
        temp[4*i+1] = z1+z2;
135
        temp[4*i+2] = z1-z2;
136
        temp[4*i+3] = z0-z3;
137
    }
138

    
139
    for (i = 0; i < 4; i++){
140
        const int offset = x_offset[i];
141
        const int z0 = 13*(temp[4*0+i] +    temp[4*2+i]);
142
        const int z1 = 13*(temp[4*0+i] -    temp[4*2+i]);
143
        const int z2 =  7* temp[4*1+i] - 17*temp[4*3+i];
144
        const int z3 = 17* temp[4*1+i] +  7*temp[4*3+i];
145

    
146
        block[stride*0 +offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
147
        block[stride*2 +offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
148
        block[stride*8 +offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
149
        block[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
150
    }
151
}
152
#undef stride
153

    
154
static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
155
                            int dc)
156
{
157
    const int qmul = svq3_dequant_coeff[qp];
158
    int i;
159
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
160

    
161
    if (dc) {
162
        dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
163
        block[0] = 0;
164
    }
165

    
166
    for (i = 0; i < 4; i++) {
167
        const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
168
        const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
169
        const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
170
        const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
171

    
172
        block[0 + 4*i] = z0 + z3;
173
        block[1 + 4*i] = z1 + z2;
174
        block[2 + 4*i] = z1 - z2;
175
        block[3 + 4*i] = z0 - z3;
176
    }
177

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

    
185
        dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
186
        dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
187
        dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
188
        dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
189
    }
190
}
191

    
192
static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
193
                                    int index, const int type)
194
{
195
    static const uint8_t *const scan_patterns[4] =
196
    { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
197

    
198
    int run, level, sign, vlc, limit;
199
    const int intra = (3 * type) >> 2;
200
    const uint8_t *const scan = scan_patterns[type];
201

    
202
    for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
203
        for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
204

    
205
          if (vlc == INVALID_VLC)
206
              return -1;
207

    
208
          sign = (vlc & 0x1) - 1;
209
          vlc  = (vlc + 1) >> 1;
210

    
211
          if (type == 3) {
212
              if (vlc < 3) {
213
                  run   = 0;
214
                  level = vlc;
215
              } else if (vlc < 4) {
216
                  run   = 1;
217
                  level = 1;
218
              } else {
219
                  run   = (vlc & 0x3);
220
                  level = ((vlc + 9) >> 2) - run;
221
              }
222
          } else {
223
              if (vlc < 16) {
224
                  run   = svq3_dct_tables[intra][vlc].run;
225
                  level = svq3_dct_tables[intra][vlc].level;
226
              } else if (intra) {
227
                  run   = (vlc & 0x7);
228
                  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
229
              } else {
230
                  run   = (vlc & 0xF);
231
                  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
232
              }
233
          }
234

    
235
          if ((index += run) >= limit)
236
              return -1;
237

    
238
          block[scan[index]] = (level ^ sign) - sign;
239
        }
240

    
241
        if (type != 2) {
242
            break;
243
        }
244
    }
245

    
246
    return 0;
247
}
248

    
249
static inline void svq3_mc_dir_part(MpegEncContext *s,
250
                                    int x, int y, int width, int height,
251
                                    int mx, int my, int dxy,
252
                                    int thirdpel, int dir, int avg)
253
{
254
    const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
255
    uint8_t *src, *dest;
256
    int i, emu = 0;
257
    int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
258

    
259
    mx += x;
260
    my += y;
261

    
262
    if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
263
        my < 0 || my >= (s->v_edge_pos - height - 1)) {
264

    
265
        if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
266
            emu = 1;
267
        }
268

    
269
        mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
270
        my = av_clip (my, -16, (s->v_edge_pos - height + 15));
271
    }
272

    
273
    /* form component predictions */
274
    dest = s->current_picture.data[0] + x + y*s->linesize;
275
    src  = pic->data[0] + mx + my*s->linesize;
276

    
277
    if (emu) {
278
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
279
                            mx, my, s->h_edge_pos, s->v_edge_pos);
280
        src = s->edge_emu_buffer;
281
    }
282
    if (thirdpel)
283
        (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
284
    else
285
        (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
286

    
287
    if (!(s->flags & CODEC_FLAG_GRAY)) {
288
        mx     = (mx + (mx < (int) x)) >> 1;
289
        my     = (my + (my < (int) y)) >> 1;
290
        width  = (width  >> 1);
291
        height = (height >> 1);
292
        blocksize++;
293

    
294
        for (i = 1; i < 3; i++) {
295
            dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
296
            src  = pic->data[i] + mx + my*s->uvlinesize;
297

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

    
311
static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
312
                              int avg)
313
{
314
    int i, j, k, mx, my, dx, dy, x, y;
315
    MpegEncContext *const s = (MpegEncContext *) h;
316
    const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
317
    const int part_height = 16 >> ((unsigned) (size + 1) / 3);
318
    const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
319
    const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
320
    const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
321

    
322
    for (i = 0; i < 16; i += part_height) {
323
        for (j = 0; j < 16; j += part_width) {
324
            const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
325
            int dxy;
326
            x = 16*s->mb_x + j;
327
            y = 16*s->mb_y + i;
328
            k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
329

    
330
            if (mode != PREDICT_MODE) {
331
                pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
332
            } else {
333
                mx = s->next_picture.motion_val[0][b_xy][0]<<1;
334
                my = s->next_picture.motion_val[0][b_xy][1]<<1;
335

    
336
                if (dir == 0) {
337
                    mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
338
                    my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
339
                } else {
340
                    mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
341
                    my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
342
                }
343
            }
344

    
345
            /* clip motion vector prediction to frame border */
346
            mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
347
            my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
348

    
349
            /* get (optional) motion vector differential */
350
            if (mode == PREDICT_MODE) {
351
                dx = dy = 0;
352
            } else {
353
                dy = svq3_get_se_golomb(&s->gb);
354
                dx = svq3_get_se_golomb(&s->gb);
355

    
356
                if (dx == INVALID_VLC || dy == INVALID_VLC) {
357
                    av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
358
                    return -1;
359
                }
360
            }
361

    
362
            /* compute motion vector */
363
            if (mode == THIRDPEL_MODE) {
364
                int fx, fy;
365
                mx  = ((mx + 1)>>1) + dx;
366
                my  = ((my + 1)>>1) + dy;
367
                fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
368
                fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
369
                dxy = (mx - 3*fx) + 4*(my - 3*fy);
370

    
371
                svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
372
                mx += mx;
373
                my += my;
374
            } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
375
                mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
376
                my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
377
                dxy = (mx&1) + 2*(my&1);
378

    
379
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
380
                mx *= 3;
381
                my *= 3;
382
            } else {
383
                mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
384
                my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
385

    
386
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
387
                mx *= 6;
388
                my *= 6;
389
            }
390

    
391
            /* update mv_cache */
392
            if (mode != PREDICT_MODE) {
393
                int32_t mv = pack16to32(mx,my);
394

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

    
398
                    if (part_width == 8 && j < 8) {
399
                        *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
400
                    }
401
                }
402
                if (part_width == 8 && j < 8) {
403
                    *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
404
                }
405
                if (part_width == 4 || part_height == 4) {
406
                    *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
407
                }
408
            }
409

    
410
            /* write back motion vectors */
411
            fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
412
        }
413
    }
414

    
415
    return 0;
416
}
417

    
418
static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
419
{
420
    int i, j, k, m, dir, mode;
421
    int cbp = 0;
422
    uint32_t vlc;
423
    int8_t *top, *left;
424
    MpegEncContext *const s = (MpegEncContext *) h;
425
    const int mb_xy = h->mb_xy;
426
    const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
427

    
428
    h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
429
    h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
430
    h->topright_samples_available = 0xFFFF;
431

    
432
    if (mb_type == 0) {           /* SKIP */
433
        if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
434
            svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
435

    
436
            if (s->pict_type == FF_B_TYPE) {
437
                svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
438
            }
439

    
440
            mb_type = MB_TYPE_SKIP;
441
        } else {
442
            mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
443
            if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
444
                return -1;
445
            if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
446
                return -1;
447

    
448
            mb_type = MB_TYPE_16x16;
449
        }
450
    } else if (mb_type < 8) {     /* INTER */
451
        if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
452
            mode = THIRDPEL_MODE;
453
        } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
454
            mode = HALFPEL_MODE;
455
        } else {
456
            mode = FULLPEL_MODE;
457
        }
458

    
459
        /* fill caches */
460
        /* note ref_cache should contain here:
461
            ????????
462
            ???11111
463
            N??11111
464
            N??11111
465
            N??11111
466
        */
467

    
468
        for (m = 0; m < 2; m++) {
469
            if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
470
                for (i = 0; i < 4; i++) {
471
                    *(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];
472
                }
473
            } else {
474
                for (i = 0; i < 4; i++) {
475
                    *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
476
                }
477
            }
478
            if (s->mb_y > 0) {
479
                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));
480
                memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);
481

    
482
                if (s->mb_x < (s->mb_width - 1)) {
483
                    *(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];
484
                    h->ref_cache[m][scan8[0] + 4 - 1*8] =
485
                        (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
486
                         h->intra4x4_pred_mode[mb_xy - s->mb_stride    ][4] == -1) ? PART_NOT_AVAILABLE : 1;
487
                }else
488
                    h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
489
                if (s->mb_x > 0) {
490
                    *(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];
491
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;
492
                }else
493
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
494
            }else
495
                memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
496

    
497
            if (s->pict_type != FF_B_TYPE)
498
                break;
499
        }
500

    
501
        /* decode motion vector(s) and form prediction(s) */
502
        if (s->pict_type == FF_P_TYPE) {
503
            if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
504
                return -1;
505
        } else {        /* FF_B_TYPE */
506
            if (mb_type != 2) {
507
                if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
508
                    return -1;
509
            } else {
510
                for (i = 0; i < 4; i++) {
511
                    memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
512
                }
513
            }
514
            if (mb_type != 1) {
515
                if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
516
                    return -1;
517
            } else {
518
                for (i = 0; i < 4; i++) {
519
                    memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
520
                }
521
            }
522
        }
523

    
524
        mb_type = MB_TYPE_16x16;
525
    } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
526
        memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
527

    
528
        if (mb_type == 8) {
529
            if (s->mb_x > 0) {
530
                for (i = 0; i < 4; i++) {
531
                    h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
532
                }
533
                if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
534
                    h->left_samples_available = 0x5F5F;
535
                }
536
            }
537
            if (s->mb_y > 0) {
538
                h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
539
                h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
540
                h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
541
                h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
542

    
543
                if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
544
                    h->top_samples_available = 0x33FF;
545
                }
546
            }
547

    
548
            /* decode prediction codes for luma blocks */
549
            for (i = 0; i < 16; i+=2) {
550
                vlc = svq3_get_ue_golomb(&s->gb);
551

    
552
                if (vlc >= 25){
553
                    av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
554
                    return -1;
555
                }
556

    
557
                left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
558
                top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
559

    
560
                left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
561
                left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
562

    
563
                if (left[1] == -1 || left[2] == -1){
564
                    av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
565
                    return -1;
566
                }
567
            }
568
        } else {    /* mb_type == 33, DC_128_PRED block type */
569
            for (i = 0; i < 4; i++) {
570
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
571
            }
572
        }
573

    
574
        write_back_intra_pred_mode(h);
575

    
576
        if (mb_type == 8) {
577
            check_intra4x4_pred_mode(h);
578

    
579
            h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
580
            h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
581
        } else {
582
            for (i = 0; i < 4; i++) {
583
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
584
            }
585

    
586
            h->top_samples_available  = 0x33FF;
587
            h->left_samples_available = 0x5F5F;
588
        }
589

    
590
        mb_type = MB_TYPE_INTRA4x4;
591
    } else {                      /* INTRA16x16 */
592
        dir = i_mb_type_info[mb_type - 8].pred_mode;
593
        dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
594

    
595
        if ((h->intra16x16_pred_mode = check_intra_pred_mode(h, dir)) == -1){
596
            av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
597
            return -1;
598
        }
599

    
600
        cbp = i_mb_type_info[mb_type - 8].cbp;
601
        mb_type = MB_TYPE_INTRA16x16;
602
    }
603

    
604
    if (!IS_INTER(mb_type) && s->pict_type != FF_I_TYPE) {
605
        for (i = 0; i < 4; i++) {
606
            memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
607
        }
608
        if (s->pict_type == FF_B_TYPE) {
609
            for (i = 0; i < 4; i++) {
610
                memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
611
            }
612
        }
613
    }
614
    if (!IS_INTRA4x4(mb_type)) {
615
        memset(h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
616
    }
617
    if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
618
        memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
619
        s->dsp.clear_blocks(h->mb);
620
    }
621

    
622
    if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
623
        if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
624
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
625
            return -1;
626
        }
627

    
628
        cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
629
    }
630
    if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
631
        s->qscale += svq3_get_se_golomb(&s->gb);
632

    
633
        if (s->qscale > 31){
634
            av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
635
            return -1;
636
        }
637
    }
638
    if (IS_INTRA16x16(mb_type)) {
639
        if (svq3_decode_block(&s->gb, h->mb, 0, 0)){
640
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
641
            return -1;
642
        }
643
    }
644

    
645
    if (cbp) {
646
        const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
647
        const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
648

    
649
        for (i = 0; i < 4; i++) {
650
            if ((cbp & (1 << i))) {
651
                for (j = 0; j < 4; j++) {
652
                    k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
653
                    h->non_zero_count_cache[ scan8[k] ] = 1;
654

    
655
                    if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
656
                        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
657
                        return -1;
658
                    }
659
                }
660
            }
661
        }
662

    
663
        if ((cbp & 0x30)) {
664
            for (i = 0; i < 2; ++i) {
665
              if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
666
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
667
                return -1;
668
              }
669
            }
670

    
671
            if ((cbp & 0x20)) {
672
                for (i = 0; i < 8; i++) {
673
                    h->non_zero_count_cache[ scan8[16+i] ] = 1;
674

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

    
684
    s->current_picture.mb_type[mb_xy] = mb_type;
685

    
686
    if (IS_INTRA(mb_type)) {
687
        h->chroma_pred_mode = check_intra_pred_mode(h, DC_PRED8x8);
688
    }
689

    
690
    return 0;
691
}
692

    
693
static int svq3_decode_slice_header(H264Context *h)
694
{
695
    MpegEncContext *const s = (MpegEncContext *) h;
696
    const int mb_xy = h->mb_xy;
697
    int i, header;
698

    
699
    header = get_bits(&s->gb, 8);
700

    
701
    if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
702
        /* TODO: what? */
703
        av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
704
        return -1;
705
    } else {
706
        int length = (header >> 5) & 3;
707

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

    
710
        if (h->next_slice_index > s->gb.size_in_bits) {
711
            av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
712
            return -1;
713
    }
714

    
715
        s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
716
        skip_bits(&s->gb, 8);
717

    
718
        if (h->svq3_watermark_key) {
719
            uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
720
            AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
721
        }
722
        if (length > 0) {
723
            memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
724
                   &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
725
        }
726
    }
727

    
728
    if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
729
        av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
730
        return -1;
731
    }
732

    
733
    h->slice_type = golomb_to_pict_type[i];
734

    
735
    if ((header & 0x9F) == 2) {
736
        i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
737
        s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
738
    } else {
739
        skip_bits1(&s->gb);
740
        s->mb_skip_run = 0;
741
    }
742

    
743
    h->slice_num = get_bits(&s->gb, 8);
744
    s->qscale = get_bits(&s->gb, 5);
745
    s->adaptive_quant = get_bits1(&s->gb);
746

    
747
    /* unknown fields */
748
    skip_bits1(&s->gb);
749

    
750
    if (h->unknown_svq3_flag) {
751
        skip_bits1(&s->gb);
752
    }
753

    
754
    skip_bits1(&s->gb);
755
    skip_bits(&s->gb, 2);
756

    
757
    while (get_bits1(&s->gb)) {
758
        skip_bits(&s->gb, 8);
759
    }
760

    
761
    /* reset intra predictors and invalidate motion vector references */
762
    if (s->mb_x > 0) {
763
        memset(h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
764
        memset(h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
765
    }
766
    if (s->mb_y > 0) {
767
        memset(h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
768

    
769
        if (s->mb_x > 0) {
770
            h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
771
        }
772
    }
773

    
774
    return 0;
775
}
776

    
777
static int svq3_decode_init(AVCodecContext *avctx)
778
{
779
    MpegEncContext *const s = avctx->priv_data;
780
    H264Context *const h = avctx->priv_data;
781
    int m;
782
    unsigned char *extradata;
783
    unsigned int size;
784

    
785
    if (decode_init(avctx) < 0)
786
        return -1;
787

    
788
    s->flags  = avctx->flags;
789
    s->flags2 = avctx->flags2;
790
    s->unrestricted_mv = 1;
791
    h->is_complex=1;
792

    
793
    if (!s->context_initialized) {
794
        s->width  = avctx->width;
795
        s->height = avctx->height;
796
        h->halfpel_flag      = 1;
797
        h->thirdpel_flag     = 1;
798
        h->unknown_svq3_flag = 0;
799
        h->chroma_qp[0]      = h->chroma_qp[1] = 4;
800

    
801
        if (MPV_common_init(s) < 0)
802
            return -1;
803

    
804
        h->b_stride = 4*s->mb_width;
805

    
806
        alloc_tables(h);
807

    
808
        /* prowl for the "SEQH" marker in the extradata */
809
        extradata = (unsigned char *)avctx->extradata;
810
        for (m = 0; m < avctx->extradata_size; m++) {
811
            if (!memcmp(extradata, "SEQH", 4))
812
                break;
813
            extradata++;
814
        }
815

    
816
        /* if a match was found, parse the extra data */
817
        if (extradata && !memcmp(extradata, "SEQH", 4)) {
818

    
819
            GetBitContext gb;
820

    
821
            size = AV_RB32(&extradata[4]);
822
            init_get_bits(&gb, extradata + 8, size*8);
823

    
824
            /* 'frame size code' and optional 'width, height' */
825
            if (get_bits(&gb, 3) == 7) {
826
                skip_bits(&gb, 12);
827
                skip_bits(&gb, 12);
828
            }
829

    
830
            h->halfpel_flag  = get_bits1(&gb);
831
            h->thirdpel_flag = get_bits1(&gb);
832

    
833
            /* unknown fields */
834
            skip_bits1(&gb);
835
            skip_bits1(&gb);
836
            skip_bits1(&gb);
837
            skip_bits1(&gb);
838

    
839
            s->low_delay = get_bits1(&gb);
840

    
841
            /* unknown field */
842
            skip_bits1(&gb);
843

    
844
            while (get_bits1(&gb)) {
845
                skip_bits(&gb, 8);
846
            }
847

    
848
            h->unknown_svq3_flag = get_bits1(&gb);
849
            avctx->has_b_frames = !s->low_delay;
850
            if (h->unknown_svq3_flag) {
851
#ifdef CONFIG_ZLIB
852
                unsigned watermark_width  = svq3_get_ue_golomb(&gb);
853
                unsigned watermark_height = svq3_get_ue_golomb(&gb);
854
                int u1 = svq3_get_ue_golomb(&gb);
855
                int u2 = get_bits(&gb, 8);
856
                int u3 = get_bits(&gb, 2);
857
                int u4 = svq3_get_ue_golomb(&gb);
858
                unsigned buf_len = watermark_width*watermark_height*4;
859
                int offset = (get_bits_count(&gb)+7)>>3;
860
                uint8_t *buf;
861

    
862
                if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
863
                    return -1;
864

    
865
                buf = av_malloc(buf_len);
866
                av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
867
                av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
868
                if (uncompress(buf, (uLong*)&buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
869
                    av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
870
                    av_free(buf);
871
                    return -1;
872
                }
873
                h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
874
                h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
875
                av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
876
                av_free(buf);
877
#else
878
                av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
879
                return -1;
880
#endif
881
            }
882
        }
883
    }
884

    
885
    return 0;
886
}
887

    
888
static int svq3_decode_frame(AVCodecContext *avctx,
889
                             void *data, int *data_size,
890
                             const uint8_t *buf, int buf_size)
891
{
892
    MpegEncContext *const s = avctx->priv_data;
893
    H264Context *const h = avctx->priv_data;
894
    int m, mb_type;
895

    
896
    /* special case for last picture */
897
    if (buf_size == 0) {
898
        if (s->next_picture_ptr && !s->low_delay) {
899
            *(AVFrame *) data = *(AVFrame *) &s->next_picture;
900
            s->next_picture_ptr = NULL;
901
            *data_size = sizeof(AVFrame);
902
        }
903
        return 0;
904
    }
905

    
906
    init_get_bits (&s->gb, buf, 8*buf_size);
907

    
908
    s->mb_x = s->mb_y = h->mb_xy = 0;
909

    
910
    if (svq3_decode_slice_header(h))
911
        return -1;
912

    
913
    s->pict_type = h->slice_type;
914
    s->picture_number = h->slice_num;
915

    
916
    if (avctx->debug&FF_DEBUG_PICT_INFO){
917
        av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
918
               av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
919
               s->adaptive_quant, s->qscale, h->slice_num);
920
    }
921

    
922
    /* for hurry_up == 5 */
923
    s->current_picture.pict_type = s->pict_type;
924
    s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
925

    
926
    /* Skip B-frames if we do not have reference frames. */
927
    if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
928
        return 0;
929
    /* Skip B-frames if we are in a hurry. */
930
    if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
931
        return 0;
932
    /* Skip everything if we are in a hurry >= 5. */
933
    if (avctx->hurry_up >= 5)
934
        return 0;
935
    if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
936
        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
937
        || avctx->skip_frame >= AVDISCARD_ALL)
938
        return 0;
939

    
940
    if (s->next_p_frame_damaged) {
941
        if (s->pict_type == FF_B_TYPE)
942
            return 0;
943
        else
944
            s->next_p_frame_damaged = 0;
945
    }
946

    
947
    if (frame_start(h) < 0)
948
        return -1;
949

    
950
    if (s->pict_type == FF_B_TYPE) {
951
        h->frame_num_offset = (h->slice_num - h->prev_frame_num);
952

    
953
        if (h->frame_num_offset < 0) {
954
            h->frame_num_offset += 256;
955
        }
956
        if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
957
            av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
958
            return -1;
959
        }
960
    } else {
961
        h->prev_frame_num = h->frame_num;
962
        h->frame_num = h->slice_num;
963
        h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
964

    
965
        if (h->prev_frame_num_offset < 0) {
966
            h->prev_frame_num_offset += 256;
967
        }
968
    }
969

    
970
    for (m = 0; m < 2; m++){
971
        int i;
972
        for (i = 0; i < 4; i++){
973
            int j;
974
            for (j = -1; j < 4; j++)
975
                h->ref_cache[m][scan8[0] + 8*i + j]= 1;
976
            if (i < 3)
977
                h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
978
        }
979
    }
980

    
981
    for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
982
        for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
983
            h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
984

    
985
            if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
986
                ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
987

    
988
                skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
989
                s->gb.size_in_bits = 8*buf_size;
990

    
991
                if (svq3_decode_slice_header(h))
992
                    return -1;
993

    
994
                /* TODO: support s->mb_skip_run */
995
            }
996

    
997
            mb_type = svq3_get_ue_golomb(&s->gb);
998

    
999
            if (s->pict_type == FF_I_TYPE) {
1000
                mb_type += 8;
1001
            } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1002
                mb_type += 4;
1003
            }
1004
            if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1005
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1006
                return -1;
1007
            }
1008

    
1009
            if (mb_type != 0) {
1010
                hl_decode_mb (h);
1011
            }
1012

    
1013
            if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1014
                s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1015
                    (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1016
            }
1017
        }
1018

    
1019
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
1020
    }
1021

    
1022
    MPV_frame_end(s);
1023

    
1024
    if (s->pict_type == FF_B_TYPE || s->low_delay) {
1025
        *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1026
    } else {
1027
        *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1028
    }
1029

    
1030
    avctx->frame_number = s->picture_number - 1;
1031

    
1032
    /* Do not output the last pic after seeking. */
1033
    if (s->last_picture_ptr || s->low_delay) {
1034
        *data_size = sizeof(AVFrame);
1035
    }
1036

    
1037
    return buf_size;
1038
}
1039

    
1040

    
1041
AVCodec svq3_decoder = {
1042
    "svq3",
1043
    CODEC_TYPE_VIDEO,
1044
    CODEC_ID_SVQ3,
1045
    sizeof(H264Context),
1046
    svq3_decode_init,
1047
    NULL,
1048
    decode_end,
1049
    svq3_decode_frame,
1050
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1051
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),
1052
};