Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 2be3fe39

History | View | Annotate | Download (33.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
 *  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
    const int qmul= svq3_dequant_coeff[qp];
119
#define stride 16
120
    int i;
121
    int temp[16];
122
    static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
123
    static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
124

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

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

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

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

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

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

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

    
169
        block[0 + 4*i]= z0 + z3;
170
        block[1 + 4*i]= z1 + z2;
171
        block[2 + 4*i]= z1 - z2;
172
        block[3 + 4*i]= z0 - z3;
173
    }
174

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

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

    
189
static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
190
                                     int index, const int type) {
191

    
192
  static const uint8_t *const scan_patterns[4] =
193
  { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
194

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

    
199
  for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
200
    for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
201

    
202
      if (vlc == INVALID_VLC)
203
        return -1;
204

    
205
      sign = (vlc & 0x1) - 1;
206
      vlc  = (vlc + 1) >> 1;
207

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

    
232
      if ((index += run) >= limit)
233
        return -1;
234

    
235
      block[scan[index]] = (level ^ sign) - sign;
236
    }
237

    
238
    if (type != 2) {
239
      break;
240
    }
241
  }
242

    
243
  return 0;
244
}
245

    
246
static inline void svq3_mc_dir_part (MpegEncContext *s,
247
                                     int x, int y, int width, int height,
248
                                     int mx, int my, int dxy,
249
                                     int thirdpel, int dir, int avg) {
250

    
251
  const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
252
  uint8_t *src, *dest;
253
  int i, emu = 0;
254
  int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
255

    
256
  mx += x;
257
  my += y;
258

    
259
  if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
260
      my < 0 || my >= (s->v_edge_pos - height - 1)) {
261

    
262
    if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
263
      emu = 1;
264
    }
265

    
266
    mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
267
    my = av_clip (my, -16, (s->v_edge_pos - height + 15));
268
  }
269

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

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

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

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

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

    
308
static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
309

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

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

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

    
332
        if (dir == 0) {
333
          mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
334
          my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
335
        } else {
336
          mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
337
          my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
338
        }
339
      }
340

    
341
      /* clip motion vector prediction to frame border */
342
      mx = av_clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
343
      my = av_clip (my, extra_width - 6*y, v_edge_pos - 6*y);
344

    
345
      /* get (optional) motion vector differential */
346
      if (mode == PREDICT_MODE) {
347
        dx = dy = 0;
348
      } else {
349
        dy = svq3_get_se_golomb (&s->gb);
350
        dx = svq3_get_se_golomb (&s->gb);
351

    
352
        if (dx == INVALID_VLC || dy == INVALID_VLC) {
353
          av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
354
          return -1;
355
        }
356
      }
357

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

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

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

    
382
        svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
383
        mx *= 6;
384
        my *= 6;
385
      }
386

    
387
      /* update mv_cache */
388
      if (mode != PREDICT_MODE) {
389
        int32_t mv = pack16to32(mx,my);
390

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

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

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

    
411
  return 0;
412
}
413

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

    
423
  h->top_samples_available        = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
424
  h->left_samples_available        = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
425
  h->topright_samples_available        = 0xFFFF;
426

    
427
  if (mb_type == 0) {           /* SKIP */
428
    if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
429
      svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
430

    
431
      if (s->pict_type == FF_B_TYPE) {
432
        svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
433
      }
434

    
435
      mb_type = MB_TYPE_SKIP;
436
    } else {
437
      mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
438
      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
439
        return -1;
440
      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
441
        return -1;
442

    
443
      mb_type = MB_TYPE_16x16;
444
    }
445
  } else if (mb_type < 8) {     /* INTER */
446
    if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
447
      mode = THIRDPEL_MODE;
448
    } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
449
      mode = HALFPEL_MODE;
450
    } else {
451
      mode = FULLPEL_MODE;
452
    }
453

    
454
    /* fill caches */
455
    /* note ref_cache should contain here:
456
        ????????
457
        ???11111
458
        N??11111
459
        N??11111
460
        N??11111
461
    */
462

    
463
    for (m=0; m < 2; m++) {
464
      if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
465
        for (i=0; i < 4; i++) {
466
          *(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];
467
        }
468
      } else {
469
        for (i=0; i < 4; i++) {
470
          *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
471
        }
472
      }
473
      if (s->mb_y > 0) {
474
        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));
475
        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);
476

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

    
492
      if (s->pict_type != FF_B_TYPE)
493
        break;
494
    }
495

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

    
519
    mb_type = MB_TYPE_16x16;
520
  } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
521
    memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
522

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

    
538
        if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
539
          h->top_samples_available = 0x33FF;
540
        }
541
      }
542

    
543
      /* decode prediction codes for luma blocks */
544
      for (i=0; i < 16; i+=2) {
545
        vlc = svq3_get_ue_golomb (&s->gb);
546

    
547
        if (vlc >= 25){
548
          av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
549
          return -1;
550
        }
551

    
552
        left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
553
        top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
554

    
555
        left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
556
        left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
557

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

    
569
    write_back_intra_pred_mode (h);
570

    
571
    if (mb_type == 8) {
572
      check_intra4x4_pred_mode (h);
573

    
574
      h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
575
      h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
576
    } else {
577
      for (i=0; i < 4; i++) {
578
        memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
579
      }
580

    
581
      h->top_samples_available  = 0x33FF;
582
      h->left_samples_available = 0x5F5F;
583
    }
584

    
585
    mb_type = MB_TYPE_INTRA4x4;
586
  } else {                      /* INTRA16x16 */
587
    dir = i_mb_type_info[mb_type - 8].pred_mode;
588
    dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
589

    
590
    if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
591
      av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
592
      return -1;
593
    }
594

    
595
    cbp = i_mb_type_info[mb_type - 8].cbp;
596
    mb_type = MB_TYPE_INTRA16x16;
597
  }
598

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

    
617
  if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
618
    if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
619
      av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
620
      return -1;
621
    }
622

    
623
    cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
624
  }
625
  if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
626
    s->qscale += svq3_get_se_golomb (&s->gb);
627

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

    
640
  if (cbp) {
641
    const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
642
    const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
643

    
644
    for (i=0; i < 4; i++) {
645
      if ((cbp & (1 << i))) {
646
        for (j=0; j < 4; j++) {
647
          k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
648
          h->non_zero_count_cache[ scan8[k] ] = 1;
649

    
650
          if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
651
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
652
            return -1;
653
          }
654
        }
655
      }
656
    }
657

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

    
666
      if ((cbp & 0x20)) {
667
        for (i=0; i < 8; i++) {
668
          h->non_zero_count_cache[ scan8[16+i] ] = 1;
669

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

    
679
  s->current_picture.mb_type[mb_xy] = mb_type;
680

    
681
  if (IS_INTRA(mb_type)) {
682
    h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
683
  }
684

    
685
  return 0;
686
}
687

    
688
static int svq3_decode_slice_header (H264Context *h) {
689
  MpegEncContext *const s = (MpegEncContext *) h;
690
  const int mb_xy = h->mb_xy;
691
  int i, header;
692

    
693
  header = get_bits (&s->gb, 8);
694

    
695
  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
696
    /* TODO: what? */
697
    av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
698
    return -1;
699
  } else {
700
    int length = (header >> 5) & 3;
701

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

    
704
    if (h->next_slice_index > s->gb.size_in_bits){
705
      av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
706
      return -1;
707
    }
708

    
709
    s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
710
    skip_bits(&s->gb, 8);
711

    
712
    if (h->svq3_watermark_key) {
713
        uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
714
        AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
715
    }
716
    if (length > 0) {
717
      memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
718
             &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
719
    }
720
  }
721

    
722
  if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
723
    av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
724
    return -1;
725
  }
726

    
727
  h->slice_type = golomb_to_pict_type[i];
728

    
729
  if ((header & 0x9F) == 2) {
730
    i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
731
    s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
732
  } else {
733
    skip_bits1 (&s->gb);
734
    s->mb_skip_run = 0;
735
  }
736

    
737
  h->slice_num = get_bits (&s->gb, 8);
738
  s->qscale = get_bits (&s->gb, 5);
739
  s->adaptive_quant = get_bits1 (&s->gb);
740

    
741
  /* unknown fields */
742
  skip_bits1 (&s->gb);
743

    
744
  if (h->unknown_svq3_flag) {
745
    skip_bits1 (&s->gb);
746
  }
747

    
748
  skip_bits1 (&s->gb);
749
  skip_bits (&s->gb, 2);
750

    
751
  while (get_bits1 (&s->gb)) {
752
    skip_bits (&s->gb, 8);
753
  }
754

    
755
  /* reset intra predictors and invalidate motion vector references */
756
  if (s->mb_x > 0) {
757
    memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
758
    memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
759
  }
760
  if (s->mb_y > 0) {
761
    memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
762

    
763
    if (s->mb_x > 0) {
764
      h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
765
    }
766
  }
767

    
768
  return 0;
769
}
770

    
771
static int svq3_decode_frame (AVCodecContext *avctx,
772
                              void *data, int *data_size,
773
                              const uint8_t *buf, int buf_size) {
774
  MpegEncContext *const s = avctx->priv_data;
775
  H264Context *const h = avctx->priv_data;
776
  int m, mb_type;
777
  unsigned char *extradata;
778
  unsigned int size;
779

    
780
  s->flags = avctx->flags;
781
  s->flags2 = avctx->flags2;
782
  s->unrestricted_mv = 1;
783

    
784
  if (!s->context_initialized) {
785
    s->width = avctx->width;
786
    s->height = avctx->height;
787
    h->halfpel_flag = 1;
788
    h->thirdpel_flag = 1;
789
    h->unknown_svq3_flag = 0;
790
    h->chroma_qp[0] = h->chroma_qp[1] = 4;
791

    
792
    if (MPV_common_init (s) < 0)
793
      return -1;
794

    
795
    h->b_stride = 4*s->mb_width;
796

    
797
    alloc_tables (h);
798

    
799
    /* prowl for the "SEQH" marker in the extradata */
800
    extradata = (unsigned char *)avctx->extradata;
801
    for (m = 0; m < avctx->extradata_size; m++) {
802
      if (!memcmp (extradata, "SEQH", 4))
803
        break;
804
      extradata++;
805
    }
806

    
807
    /* if a match was found, parse the extra data */
808
    if (extradata && !memcmp (extradata, "SEQH", 4)) {
809

    
810
      GetBitContext gb;
811

    
812
      size = AV_RB32(&extradata[4]);
813
      init_get_bits (&gb, extradata + 8, size*8);
814

    
815
      /* 'frame size code' and optional 'width, height' */
816
      if (get_bits (&gb, 3) == 7) {
817
        skip_bits (&gb, 12);
818
        skip_bits (&gb, 12);
819
      }
820

    
821
      h->halfpel_flag = get_bits1 (&gb);
822
      h->thirdpel_flag = get_bits1 (&gb);
823

    
824
      /* unknown fields */
825
      skip_bits1 (&gb);
826
      skip_bits1 (&gb);
827
      skip_bits1 (&gb);
828
      skip_bits1 (&gb);
829

    
830
      s->low_delay = get_bits1 (&gb);
831

    
832
      /* unknown field */
833
      skip_bits1 (&gb);
834

    
835
      while (get_bits1 (&gb)) {
836
        skip_bits (&gb, 8);
837
      }
838

    
839
      h->unknown_svq3_flag = get_bits1 (&gb);
840
      avctx->has_b_frames = !s->low_delay;
841
      if (h->unknown_svq3_flag) {
842
#ifdef CONFIG_ZLIB
843
          unsigned watermark_width  = svq3_get_ue_golomb(&gb);
844
          unsigned watermark_height = svq3_get_ue_golomb(&gb);
845
          int u1 = svq3_get_ue_golomb(&gb);
846
          int u2 = get_bits(&gb, 8);
847
          int u3 = get_bits(&gb, 2);
848
          int u4 = svq3_get_ue_golomb(&gb);
849
          unsigned buf_len = watermark_width*watermark_height*4;
850
          int offset = (get_bits_count(&gb)+7)>>3;
851
          uint8_t *buf;
852

    
853
          if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
854
              return -1;
855

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

    
876
  /* special case for last picture */
877
  if (buf_size == 0) {
878
    if (s->next_picture_ptr && !s->low_delay) {
879
      *(AVFrame *) data = *(AVFrame *) &s->next_picture;
880
      s->next_picture_ptr= NULL;
881
      *data_size = sizeof(AVFrame);
882
    }
883
    return 0;
884
  }
885

    
886
  init_get_bits (&s->gb, buf, 8*buf_size);
887

    
888
  s->mb_x = s->mb_y = h->mb_xy = 0;
889

    
890
  if (svq3_decode_slice_header (h))
891
    return -1;
892

    
893
  s->pict_type = h->slice_type;
894
  s->picture_number = h->slice_num;
895

    
896
  if(avctx->debug&FF_DEBUG_PICT_INFO){
897
      av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
898
      av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
899
      s->adaptive_quant, s->qscale, h->slice_num
900
      );
901
  }
902

    
903
  /* for hurry_up==5 */
904
  s->current_picture.pict_type = s->pict_type;
905
  s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
906

    
907
  /* Skip B-frames if we do not have reference frames. */
908
  if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE) return 0;
909
  /* Skip B-frames if we are in a hurry. */
910
  if (avctx->hurry_up && s->pict_type == FF_B_TYPE) return 0;
911
  /* Skip everything if we are in a hurry >= 5. */
912
  if (avctx->hurry_up >= 5) return 0;
913
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
914
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
915
     || avctx->skip_frame >= AVDISCARD_ALL)
916
      return 0;
917

    
918
  if (s->next_p_frame_damaged) {
919
    if (s->pict_type == FF_B_TYPE)
920
      return 0;
921
    else
922
      s->next_p_frame_damaged = 0;
923
  }
924

    
925
  if (frame_start (h) < 0)
926
    return -1;
927

    
928
  if (s->pict_type == FF_B_TYPE) {
929
    h->frame_num_offset = (h->slice_num - h->prev_frame_num);
930

    
931
    if (h->frame_num_offset < 0) {
932
      h->frame_num_offset += 256;
933
    }
934
    if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
935
      av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
936
      return -1;
937
    }
938
  } else {
939
    h->prev_frame_num = h->frame_num;
940
    h->frame_num = h->slice_num;
941
    h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
942

    
943
    if (h->prev_frame_num_offset < 0) {
944
      h->prev_frame_num_offset += 256;
945
    }
946
  }
947

    
948
  for(m=0; m<2; m++){
949
    int i;
950
    for(i=0; i<4; i++){
951
      int j;
952
      for(j=-1; j<4; j++)
953
        h->ref_cache[m][scan8[0] + 8*i + j]= 1;
954
      if(i<3)
955
        h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
956
    }
957
  }
958

    
959
  for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
960
    for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
961
      h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
962

    
963
      if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
964
          ((get_bits_count(&s->gb) & 7) == 0 || show_bits (&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
965

    
966
        skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
967
        s->gb.size_in_bits = 8*buf_size;
968

    
969
        if (svq3_decode_slice_header (h))
970
          return -1;
971

    
972
        /* TODO: support s->mb_skip_run */
973
      }
974

    
975
      mb_type = svq3_get_ue_golomb (&s->gb);
976

    
977
      if (s->pict_type == FF_I_TYPE) {
978
        mb_type += 8;
979
      } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
980
        mb_type += 4;
981
      }
982
      if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
983
        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
984
        return -1;
985
      }
986

    
987
      if (mb_type != 0) {
988
        hl_decode_mb (h);
989
      }
990

    
991
      if (s->pict_type != FF_B_TYPE && !s->low_delay) {
992
        s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
993
                        (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
994
      }
995
    }
996

    
997
    ff_draw_horiz_band(s, 16*s->mb_y, 16);
998
  }
999

    
1000
  MPV_frame_end(s);
1001

    
1002
  if (s->pict_type == FF_B_TYPE || s->low_delay) {
1003
    *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1004
  } else {
1005
    *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1006
  }
1007

    
1008
  avctx->frame_number = s->picture_number - 1;
1009

    
1010
  /* Do not output the last pic after seeking. */
1011
  if (s->last_picture_ptr || s->low_delay) {
1012
    *data_size = sizeof(AVFrame);
1013
  }
1014

    
1015
  return buf_size;
1016
}
1017

    
1018

    
1019
AVCodec svq3_decoder = {
1020
    "svq3",
1021
    CODEC_TYPE_VIDEO,
1022
    CODEC_ID_SVQ3,
1023
    sizeof(H264Context),
1024
    decode_init,
1025
    NULL,
1026
    decode_end,
1027
    svq3_decode_frame,
1028
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1029
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),
1030
};