Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 1e002b60

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
/**
44
 * @file svq3.c
45
 * svq3 decoder.
46
 */
47

    
48
#define FULLPEL_MODE  1
49
#define HALFPEL_MODE  2
50
#define THIRDPEL_MODE 3
51
#define PREDICT_MODE  4
52

    
53
/* dual scan (from some older h264 draft)
54
 o-->o-->o   o
55
         |  /|
56
 o   o   o / o
57
 | / |   |/  |
58
 o   o   o   o
59
   /
60
 o-->o-->o-->o
61
*/
62
static const uint8_t svq3_scan[16]={
63
 0+0*4, 1+0*4, 2+0*4, 2+1*4,
64
 2+2*4, 3+0*4, 3+1*4, 3+2*4,
65
 0+1*4, 0+2*4, 1+1*4, 1+2*4,
66
 0+3*4, 1+3*4, 2+3*4, 3+3*4,
67
};
68

    
69
static const uint8_t svq3_pred_0[25][2] = {
70
  { 0, 0 },
71
  { 1, 0 }, { 0, 1 },
72
  { 0, 2 }, { 1, 1 }, { 2, 0 },
73
  { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
74
  { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
75
  { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
76
  { 2, 4 }, { 3, 3 }, { 4, 2 },
77
  { 4, 3 }, { 3, 4 },
78
  { 4, 4 }
79
};
80

    
81
static const int8_t svq3_pred_1[6][6][5] = {
82
  { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
83
    { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
84
  { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
85
    { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
86
  { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
87
    { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
88
  { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
89
    { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
90
  { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
91
    { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
92
  { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
93
    { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
94
};
95

    
96
static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
97
  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
98
    { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
99
  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
100
    { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
101
};
102

    
103
static const uint32_t svq3_dequant_coeff[32] = {
104
   3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
105
   9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
106
  24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
107
  61694, 68745, 77615, 89113,100253,109366,126635,141533
108
};
109

    
110

    
111
static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
112
    const int qmul= svq3_dequant_coeff[qp];
113
#define stride 16
114
    int i;
115
    int temp[16];
116
    static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
117
    static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
118

    
119
    for(i=0; i<4; i++){
120
        const int offset= y_offset[i];
121
        const int z0= 13*(block[offset+stride*0] +    block[offset+stride*4]);
122
        const int z1= 13*(block[offset+stride*0] -    block[offset+stride*4]);
123
        const int z2=  7* block[offset+stride*1] - 17*block[offset+stride*5];
124
        const int z3= 17* block[offset+stride*1] +  7*block[offset+stride*5];
125

    
126
        temp[4*i+0]= z0+z3;
127
        temp[4*i+1]= z1+z2;
128
        temp[4*i+2]= z1-z2;
129
        temp[4*i+3]= z0-z3;
130
    }
131

    
132
    for(i=0; i<4; i++){
133
        const int offset= x_offset[i];
134
        const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
135
        const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
136
        const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
137
        const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
138

    
139
        block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
140
        block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
141
        block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
142
        block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
143
    }
144
}
145
#undef stride
146

    
147
static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
148
    const int qmul= svq3_dequant_coeff[qp];
149
    int i;
150
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
151

    
152
    if (dc) {
153
        dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
154
        block[0] = 0;
155
    }
156

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

    
163
        block[0 + 4*i]= z0 + z3;
164
        block[1 + 4*i]= z1 + z2;
165
        block[2 + 4*i]= z1 - z2;
166
        block[3 + 4*i]= z0 - z3;
167
    }
168

    
169
    for (i=0; i < 4; i++) {
170
        const int z0= 13*(block[i + 4*0] +    block[i + 4*2]);
171
        const int z1= 13*(block[i + 4*0] -    block[i + 4*2]);
172
        const int z2=  7* block[i + 4*1] - 17*block[i + 4*3];
173
        const int z3= 17* block[i + 4*1] +  7*block[i + 4*3];
174
        const int rr= (dc + 0x80000);
175

    
176
        dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
177
        dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
178
        dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
179
        dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
180
    }
181
}
182

    
183
static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
184
                                     int index, const int type) {
185

    
186
  static const uint8_t *const scan_patterns[4] =
187
  { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
188

    
189
  int run, level, sign, vlc, limit;
190
  const int intra = (3 * type) >> 2;
191
  const uint8_t *const scan = scan_patterns[type];
192

    
193
  for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
194
    for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
195

    
196
      if (vlc == INVALID_VLC)
197
        return -1;
198

    
199
      sign = (vlc & 0x1) - 1;
200
      vlc  = (vlc + 1) >> 1;
201

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

    
226
      if ((index += run) >= limit)
227
        return -1;
228

    
229
      block[scan[index]] = (level ^ sign) - sign;
230
    }
231

    
232
    if (type != 2) {
233
      break;
234
    }
235
  }
236

    
237
  return 0;
238
}
239

    
240
static inline void svq3_mc_dir_part (MpegEncContext *s,
241
                                     int x, int y, int width, int height,
242
                                     int mx, int my, int dxy,
243
                                     int thirdpel, int dir, int avg) {
244

    
245
  const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
246
  uint8_t *src, *dest;
247
  int i, emu = 0;
248
  int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
249

    
250
  mx += x;
251
  my += y;
252

    
253
  if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
254
      my < 0 || my >= (s->v_edge_pos - height - 1)) {
255

    
256
    if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
257
      emu = 1;
258
    }
259

    
260
    mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
261
    my = av_clip (my, -16, (s->v_edge_pos - height + 15));
262
  }
263

    
264
  /* form component predictions */
265
  dest = s->current_picture.data[0] + x + y*s->linesize;
266
  src  = pic->data[0] + mx + my*s->linesize;
267

    
268
  if (emu) {
269
    ff_emulated_edge_mc (s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
270
                         mx, my, s->h_edge_pos, s->v_edge_pos);
271
    src = s->edge_emu_buffer;
272
  }
273
  if(thirdpel)
274
    (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
275
  else
276
    (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
277

    
278
  if (!(s->flags & CODEC_FLAG_GRAY)) {
279
    mx     = (mx + (mx < (int) x)) >> 1;
280
    my     = (my + (my < (int) y)) >> 1;
281
    width  = (width  >> 1);
282
    height = (height >> 1);
283
    blocksize++;
284

    
285
    for (i=1; i < 3; i++) {
286
      dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
287
      src  = pic->data[i] + mx + my*s->uvlinesize;
288

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

    
302
static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
303

    
304
  int i, j, k, mx, my, dx, dy, x, y;
305
  MpegEncContext *const s = (MpegEncContext *) h;
306
  const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
307
  const int part_height = 16 >> ((unsigned) (size + 1) / 3);
308
  const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
309
  const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
310
  const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
311

    
312
  for (i=0; i < 16; i+=part_height) {
313
    for (j=0; j < 16; j+=part_width) {
314
      const int b_xy = (4*s->mb_x+(j>>2)) + (4*s->mb_y+(i>>2))*h->b_stride;
315
      int dxy;
316
      x = 16*s->mb_x + j;
317
      y = 16*s->mb_y + i;
318
      k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
319

    
320
      if (mode != PREDICT_MODE) {
321
        pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
322
      } else {
323
        mx = s->next_picture.motion_val[0][b_xy][0]<<1;
324
        my = s->next_picture.motion_val[0][b_xy][1]<<1;
325

    
326
        if (dir == 0) {
327
          mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
328
          my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
329
        } else {
330
          mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
331
          my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
332
        }
333
      }
334

    
335
      /* clip motion vector prediction to frame border */
336
      mx = av_clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
337
      my = av_clip (my, extra_width - 6*y, v_edge_pos - 6*y);
338

    
339
      /* get (optional) motion vector differential */
340
      if (mode == PREDICT_MODE) {
341
        dx = dy = 0;
342
      } else {
343
        dy = svq3_get_se_golomb (&s->gb);
344
        dx = svq3_get_se_golomb (&s->gb);
345

    
346
        if (dx == INVALID_VLC || dy == INVALID_VLC) {
347
          av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
348
          return -1;
349
        }
350
      }
351

    
352
      /* compute motion vector */
353
      if (mode == THIRDPEL_MODE) {
354
        int fx, fy;
355
        mx = ((mx + 1)>>1) + dx;
356
        my = ((my + 1)>>1) + dy;
357
        fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
358
        fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
359
        dxy= (mx - 3*fx) + 4*(my - 3*fy);
360

    
361
        svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
362
        mx += mx;
363
        my += my;
364
      } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
365
        mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
366
        my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
367
        dxy= (mx&1) + 2*(my&1);
368

    
369
        svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
370
        mx *= 3;
371
        my *= 3;
372
      } else {
373
        mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
374
        my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
375

    
376
        svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
377
        mx *= 6;
378
        my *= 6;
379
      }
380

    
381
      /* update mv_cache */
382
      if (mode != PREDICT_MODE) {
383
        int32_t mv = pack16to32(mx,my);
384

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

    
388
          if (part_width == 8 && j < 8) {
389
            *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
390
          }
391
        }
392
        if (part_width == 8 && j < 8) {
393
          *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
394
        }
395
        if (part_width == 4 || part_height == 4) {
396
          *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
397
        }
398
      }
399

    
400
      /* write back motion vectors */
401
      fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
402
    }
403
  }
404

    
405
  return 0;
406
}
407

    
408
static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
409
  int i, j, k, m, dir, mode;
410
  int cbp = 0;
411
  uint32_t vlc;
412
  int8_t *top, *left;
413
  MpegEncContext *const s = (MpegEncContext *) h;
414
  const int mb_xy = h->mb_xy;
415
  const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
416

    
417
  h->top_samples_available        = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
418
  h->left_samples_available        = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
419
  h->topright_samples_available        = 0xFFFF;
420

    
421
  if (mb_type == 0) {           /* SKIP */
422
    if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
423
      svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
424

    
425
      if (s->pict_type == FF_B_TYPE) {
426
        svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
427
      }
428

    
429
      mb_type = MB_TYPE_SKIP;
430
    } else {
431
      mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
432
      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
433
        return -1;
434
      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
435
        return -1;
436

    
437
      mb_type = MB_TYPE_16x16;
438
    }
439
  } else if (mb_type < 8) {     /* INTER */
440
    if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
441
      mode = THIRDPEL_MODE;
442
    } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
443
      mode = HALFPEL_MODE;
444
    } else {
445
      mode = FULLPEL_MODE;
446
    }
447

    
448
    /* fill caches */
449
    /* note ref_cache should contain here:
450
        ????????
451
        ???11111
452
        N??11111
453
        N??11111
454
        N??11111
455
    */
456

    
457
    for (m=0; m < 2; m++) {
458
      if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
459
        for (i=0; i < 4; i++) {
460
          *(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];
461
        }
462
      } else {
463
        for (i=0; i < 4; i++) {
464
          *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
465
        }
466
      }
467
      if (s->mb_y > 0) {
468
        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));
469
        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);
470

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

    
486
      if (s->pict_type != FF_B_TYPE)
487
        break;
488
    }
489

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

    
513
    mb_type = MB_TYPE_16x16;
514
  } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
515
    memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
516

    
517
    if (mb_type == 8) {
518
      if (s->mb_x > 0) {
519
        for (i=0; i < 4; i++) {
520
          h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
521
        }
522
        if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
523
          h->left_samples_available = 0x5F5F;
524
        }
525
      }
526
      if (s->mb_y > 0) {
527
        h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
528
        h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
529
        h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
530
        h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
531

    
532
        if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
533
          h->top_samples_available = 0x33FF;
534
        }
535
      }
536

    
537
      /* decode prediction codes for luma blocks */
538
      for (i=0; i < 16; i+=2) {
539
        vlc = svq3_get_ue_golomb (&s->gb);
540

    
541
        if (vlc >= 25){
542
          av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
543
          return -1;
544
        }
545

    
546
        left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
547
        top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
548

    
549
        left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
550
        left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
551

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

    
563
    write_back_intra_pred_mode (h);
564

    
565
    if (mb_type == 8) {
566
      check_intra4x4_pred_mode (h);
567

    
568
      h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
569
      h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
570
    } else {
571
      for (i=0; i < 4; i++) {
572
        memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
573
      }
574

    
575
      h->top_samples_available  = 0x33FF;
576
      h->left_samples_available = 0x5F5F;
577
    }
578

    
579
    mb_type = MB_TYPE_INTRA4x4;
580
  } else {                      /* INTRA16x16 */
581
    dir = i_mb_type_info[mb_type - 8].pred_mode;
582
    dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
583

    
584
    if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
585
      av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
586
      return -1;
587
    }
588

    
589
    cbp = i_mb_type_info[mb_type - 8].cbp;
590
    mb_type = MB_TYPE_INTRA16x16;
591
  }
592

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

    
611
  if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
612
    if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
613
      av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
614
      return -1;
615
    }
616

    
617
    cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
618
  }
619
  if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
620
    s->qscale += svq3_get_se_golomb (&s->gb);
621

    
622
    if (s->qscale > 31){
623
      av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
624
      return -1;
625
    }
626
  }
627
  if (IS_INTRA16x16(mb_type)) {
628
    if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
629
      av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
630
      return -1;
631
    }
632
  }
633

    
634
  if (cbp) {
635
    const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
636
    const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
637

    
638
    for (i=0; i < 4; i++) {
639
      if ((cbp & (1 << i))) {
640
        for (j=0; j < 4; j++) {
641
          k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
642
          h->non_zero_count_cache[ scan8[k] ] = 1;
643

    
644
          if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
645
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
646
            return -1;
647
          }
648
        }
649
      }
650
    }
651

    
652
    if ((cbp & 0x30)) {
653
      for (i=0; i < 2; ++i) {
654
        if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
655
          av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
656
          return -1;
657
        }
658
      }
659

    
660
      if ((cbp & 0x20)) {
661
        for (i=0; i < 8; i++) {
662
          h->non_zero_count_cache[ scan8[16+i] ] = 1;
663

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

    
673
  s->current_picture.mb_type[mb_xy] = mb_type;
674

    
675
  if (IS_INTRA(mb_type)) {
676
    h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
677
  }
678

    
679
  return 0;
680
}
681

    
682
static int svq3_decode_slice_header (H264Context *h) {
683
  MpegEncContext *const s = (MpegEncContext *) h;
684
  const int mb_xy = h->mb_xy;
685
  int i, header;
686

    
687
  header = get_bits (&s->gb, 8);
688

    
689
  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
690
    /* TODO: what? */
691
    av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
692
    return -1;
693
  } else {
694
    int length = (header >> 5) & 3;
695

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

    
698
    if (h->next_slice_index > s->gb.size_in_bits){
699
      av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
700
      return -1;
701
    }
702

    
703
    s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
704
    skip_bits(&s->gb, 8);
705

    
706
    if (h->svq3_watermark_key) {
707
        uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
708
        AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
709
    }
710
    if (length > 0) {
711
      memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
712
             &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
713
    }
714
  }
715

    
716
  if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
717
    av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
718
    return -1;
719
  }
720

    
721
  h->slice_type = golomb_to_pict_type[i];
722

    
723
  if ((header & 0x9F) == 2) {
724
    i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
725
    s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
726
  } else {
727
    skip_bits1 (&s->gb);
728
    s->mb_skip_run = 0;
729
  }
730

    
731
  h->slice_num = get_bits (&s->gb, 8);
732
  s->qscale = get_bits (&s->gb, 5);
733
  s->adaptive_quant = get_bits1 (&s->gb);
734

    
735
  /* unknown fields */
736
  skip_bits1 (&s->gb);
737

    
738
  if (h->unknown_svq3_flag) {
739
    skip_bits1 (&s->gb);
740
  }
741

    
742
  skip_bits1 (&s->gb);
743
  skip_bits (&s->gb, 2);
744

    
745
  while (get_bits1 (&s->gb)) {
746
    skip_bits (&s->gb, 8);
747
  }
748

    
749
  /* reset intra predictors and invalidate motion vector references */
750
  if (s->mb_x > 0) {
751
    memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
752
    memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
753
  }
754
  if (s->mb_y > 0) {
755
    memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
756

    
757
    if (s->mb_x > 0) {
758
      h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
759
    }
760
  }
761

    
762
  return 0;
763
}
764

    
765
static int svq3_decode_frame (AVCodecContext *avctx,
766
                              void *data, int *data_size,
767
                              const uint8_t *buf, int buf_size) {
768
  MpegEncContext *const s = avctx->priv_data;
769
  H264Context *const h = avctx->priv_data;
770
  int m, mb_type;
771
  unsigned char *extradata;
772
  unsigned int size;
773

    
774
  s->flags = avctx->flags;
775
  s->flags2 = avctx->flags2;
776
  s->unrestricted_mv = 1;
777

    
778
  if (!s->context_initialized) {
779
    s->width = avctx->width;
780
    s->height = avctx->height;
781
    h->halfpel_flag = 1;
782
    h->thirdpel_flag = 1;
783
    h->unknown_svq3_flag = 0;
784
    h->chroma_qp[0] = h->chroma_qp[1] = 4;
785

    
786
    if (MPV_common_init (s) < 0)
787
      return -1;
788

    
789
    h->b_stride = 4*s->mb_width;
790

    
791
    alloc_tables (h);
792

    
793
    /* prowl for the "SEQH" marker in the extradata */
794
    extradata = (unsigned char *)avctx->extradata;
795
    for (m = 0; m < avctx->extradata_size; m++) {
796
      if (!memcmp (extradata, "SEQH", 4))
797
        break;
798
      extradata++;
799
    }
800

    
801
    /* if a match was found, parse the extra data */
802
    if (extradata && !memcmp (extradata, "SEQH", 4)) {
803

    
804
      GetBitContext gb;
805

    
806
      size = AV_RB32(&extradata[4]);
807
      init_get_bits (&gb, extradata + 8, size*8);
808

    
809
      /* 'frame size code' and optional 'width, height' */
810
      if (get_bits (&gb, 3) == 7) {
811
        skip_bits (&gb, 12);
812
        skip_bits (&gb, 12);
813
      }
814

    
815
      h->halfpel_flag = get_bits1 (&gb);
816
      h->thirdpel_flag = get_bits1 (&gb);
817

    
818
      /* unknown fields */
819
      skip_bits1 (&gb);
820
      skip_bits1 (&gb);
821
      skip_bits1 (&gb);
822
      skip_bits1 (&gb);
823

    
824
      s->low_delay = get_bits1 (&gb);
825

    
826
      /* unknown field */
827
      skip_bits1 (&gb);
828

    
829
      while (get_bits1 (&gb)) {
830
        skip_bits (&gb, 8);
831
      }
832

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

    
847
          if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
848
              return -1;
849

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

    
870
  /* special case for last picture */
871
  if (buf_size == 0) {
872
    if (s->next_picture_ptr && !s->low_delay) {
873
      *(AVFrame *) data = *(AVFrame *) &s->next_picture;
874
      s->next_picture_ptr= NULL;
875
      *data_size = sizeof(AVFrame);
876
    }
877
    return 0;
878
  }
879

    
880
  init_get_bits (&s->gb, buf, 8*buf_size);
881

    
882
  s->mb_x = s->mb_y = h->mb_xy = 0;
883

    
884
  if (svq3_decode_slice_header (h))
885
    return -1;
886

    
887
  s->pict_type = h->slice_type;
888
  s->picture_number = h->slice_num;
889

    
890
  if(avctx->debug&FF_DEBUG_PICT_INFO){
891
      av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
892
      av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
893
      s->adaptive_quant, s->qscale, h->slice_num
894
      );
895
  }
896

    
897
  /* for hurry_up==5 */
898
  s->current_picture.pict_type = s->pict_type;
899
  s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
900

    
901
  /* Skip B-frames if we do not have reference frames. */
902
  if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE) return 0;
903
  /* Skip B-frames if we are in a hurry. */
904
  if (avctx->hurry_up && s->pict_type == FF_B_TYPE) return 0;
905
  /* Skip everything if we are in a hurry >= 5. */
906
  if (avctx->hurry_up >= 5) return 0;
907
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
908
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
909
     || avctx->skip_frame >= AVDISCARD_ALL)
910
      return 0;
911

    
912
  if (s->next_p_frame_damaged) {
913
    if (s->pict_type == FF_B_TYPE)
914
      return 0;
915
    else
916
      s->next_p_frame_damaged = 0;
917
  }
918

    
919
  if (frame_start (h) < 0)
920
    return -1;
921

    
922
  if (s->pict_type == FF_B_TYPE) {
923
    h->frame_num_offset = (h->slice_num - h->prev_frame_num);
924

    
925
    if (h->frame_num_offset < 0) {
926
      h->frame_num_offset += 256;
927
    }
928
    if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
929
      av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
930
      return -1;
931
    }
932
  } else {
933
    h->prev_frame_num = h->frame_num;
934
    h->frame_num = h->slice_num;
935
    h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
936

    
937
    if (h->prev_frame_num_offset < 0) {
938
      h->prev_frame_num_offset += 256;
939
    }
940
  }
941

    
942
  for(m=0; m<2; m++){
943
    int i;
944
    for(i=0; i<4; i++){
945
      int j;
946
      for(j=-1; j<4; j++)
947
        h->ref_cache[m][scan8[0] + 8*i + j]= 1;
948
      if(i<3)
949
        h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
950
    }
951
  }
952

    
953
  for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
954
    for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
955
      h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
956

    
957
      if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
958
          ((get_bits_count(&s->gb) & 7) == 0 || show_bits (&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
959

    
960
        skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
961
        s->gb.size_in_bits = 8*buf_size;
962

    
963
        if (svq3_decode_slice_header (h))
964
          return -1;
965

    
966
        /* TODO: support s->mb_skip_run */
967
      }
968

    
969
      mb_type = svq3_get_ue_golomb (&s->gb);
970

    
971
      if (s->pict_type == FF_I_TYPE) {
972
        mb_type += 8;
973
      } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
974
        mb_type += 4;
975
      }
976
      if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
977
        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
978
        return -1;
979
      }
980

    
981
      if (mb_type != 0) {
982
        hl_decode_mb (h);
983
      }
984

    
985
      if (s->pict_type != FF_B_TYPE && !s->low_delay) {
986
        s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
987
                        (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
988
      }
989
    }
990

    
991
    ff_draw_horiz_band(s, 16*s->mb_y, 16);
992
  }
993

    
994
  MPV_frame_end(s);
995

    
996
  if (s->pict_type == FF_B_TYPE || s->low_delay) {
997
    *(AVFrame *) data = *(AVFrame *) &s->current_picture;
998
  } else {
999
    *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1000
  }
1001

    
1002
  avctx->frame_number = s->picture_number - 1;
1003

    
1004
  /* Do not output the last pic after seeking. */
1005
  if (s->last_picture_ptr || s->low_delay) {
1006
    *data_size = sizeof(AVFrame);
1007
  }
1008

    
1009
  return buf_size;
1010
}
1011

    
1012

    
1013
AVCodec svq3_decoder = {
1014
    "svq3",
1015
    CODEC_TYPE_VIDEO,
1016
    CODEC_ID_SVQ3,
1017
    sizeof(H264Context),
1018
    decode_init,
1019
    NULL,
1020
    decode_end,
1021
    svq3_decode_frame,
1022
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1023
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),
1024
};