Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 4cfbf61b

History | View | Annotate | Download (21.3 KB)

1
/*
2
 * Copyright (c) 2003 The FFmpeg Project.
3
 *
4
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2 of the License, or (at your option) any later version.
8
 *
9
 * This library is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library; if not, write to the Free Software
16
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 *
18
 *
19
 * How to use this decoder:
20
 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
21
 * have stsd atoms to describe media trak properties. A stsd atom for a
22
 * video trak contains 1 or more ImageDescription atoms. These atoms begin
23
 * with the 4-byte length of the atom followed by the codec fourcc. Some
24
 * decoders need information in this atom to operate correctly. Such
25
 * is the case with SVQ3. In order to get the best use out of this decoder,
26
 * the calling app must make the SVQ3 ImageDescription atom available
27
 * via the AVCodecContext's extradata[_size] field:
28
 *
29
 * AVCodecContext.extradata = pointer to ImageDescription, first characters 
30
 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
31
 * AVCodecContext.extradata_size = size of ImageDescription atom memory 
32
 * buffer (which will be the same as the ImageDescription atom size field 
33
 * from the QT file, minus 4 bytes since the length is missing)
34
 *
35
 * You will know you have these parameters passed correctly when the decoder
36
 * correctly decodes this file:
37
 *  ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
38
 *
39
 */
40
 
41
/**
42
 * @file svq3.c
43
 * svq3 decoder.
44
 */
45

    
46
#define FULLPEL_MODE  1 
47
#define HALFPEL_MODE  2 
48
#define THIRDPEL_MODE 3
49
 
50
/* dual scan (from some older h264 draft)
51
 o-->o-->o   o
52
         |  /|
53
 o   o   o / o
54
 | / |   |/  |
55
 o   o   o   o
56
   / 
57
 o-->o-->o-->o
58
*/
59
static const uint8_t svq3_scan[16]={
60
 0+0*4, 1+0*4, 2+0*4, 2+1*4,
61
 2+2*4, 3+0*4, 3+1*4, 3+2*4,
62
 0+1*4, 0+2*4, 1+1*4, 1+2*4,
63
 0+3*4, 1+3*4, 2+3*4, 3+3*4,
64
};
65

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

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

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

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

    
107

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

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

    
123
        temp[4*i+0]= z0+z3;
124
        temp[4*i+1]= z1+z2;
125
        temp[4*i+2]= z1-z2;
126
        temp[4*i+3]= z0-z3;
127
    }
128

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

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

    
144
static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
145
    const int qmul= svq3_dequant_coeff[qp];
146
    int i;
147
    uint8_t *cm = cropTbl + MAX_NEG_CROP;
148

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

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

    
160
        block[0 + 4*i]= z0 + z3;
161
        block[1 + 4*i]= z1 + z2;
162
        block[2 + 4*i]= z1 - z2;
163
        block[3 + 4*i]= z0 - z3;
164
    }
165

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

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

    
180
static void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
181
    LOAD_TOP_EDGE    
182
    LOAD_LEFT_EDGE    
183
    const __attribute__((unused)) int unu0= t0;
184
    const __attribute__((unused)) int unu1= l0;
185

    
186
    src[0+0*stride]=(l1 + t1)>>1;
187
    src[1+0*stride]=
188
    src[0+1*stride]=(l2 + t2)>>1;
189
    src[2+0*stride]=
190
    src[1+1*stride]=
191
    src[0+2*stride]=
192
    src[3+0*stride]=
193
    src[2+1*stride]=
194
    src[1+2*stride]=
195
    src[0+3*stride]=
196
    src[3+1*stride]=
197
    src[2+2*stride]=
198
    src[1+3*stride]=
199
    src[3+2*stride]=
200
    src[2+3*stride]=
201
    src[3+3*stride]=(l3 + t3)>>1;
202
}
203

    
204
static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
205
    pred16x16_plane_compat_c(src, stride, 1);
206
}
207

    
208
static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
209
                                     int index, const int type) {
210

    
211
  static const uint8_t *const scan_patterns[4] =
212
  { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
213

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

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

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

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

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

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

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

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

    
262
  return 0;
263
}
264

    
265
static inline void svq3_mc_dir_part (MpegEncContext *s, int x, int y,
266
                                     int width, int height, int mx, int my, int dxy, int thirdpel) {
267
  uint8_t *src, *dest;
268
  int i, emu = 0;
269
  int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
270

    
271
  mx += x;
272
  my += y;
273
  
274
  if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
275
      my < 0 || my >= (s->v_edge_pos - height - 1)) {
276

    
277
    if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
278
      emu = 1;
279
    }
280

    
281
    mx = clip (mx, -16, (s->h_edge_pos - width  + 15));
282
    my = clip (my, -16, (s->v_edge_pos - height + 15));
283
  }
284

    
285
  /* form component predictions */
286
  dest = s->current_picture.data[0] + x + y*s->linesize;
287
  src  = s->last_picture.data[0] + mx + my*s->linesize;
288

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

    
299
  if (!(s->flags & CODEC_FLAG_GRAY)) {
300
    mx           = (mx + (mx < (int) x)) >> 1;
301
    my           = (my + (my < (int) y)) >> 1;
302
    width  = (width  >> 1);
303
    height = (height >> 1);
304
    blocksize++;
305

    
306
    for (i=1; i < 3; i++) {
307
      dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
308
      src  = s->last_picture.data[i] + mx + my*s->uvlinesize;
309

    
310
      if (emu) {
311
        ff_emulated_edge_mc (s, src, s->uvlinesize, (width + 1), (height + 1),
312
                             mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
313
        src = s->edge_emu_buffer;
314
      }
315
      if(thirdpel)
316
        s->dsp.put_tpel_pixels_tab[dxy](dest, src, s->uvlinesize, width, height);
317
      else
318
        s->dsp.put_pixels_tab[blocksize][dxy](dest, src, s->uvlinesize, height);
319
    }
320
  }
321
}
322

    
323
static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
324
  int cbp, dir, mode, mx, my, dx, dy, x, y, part_width, part_height;
325
  int i, j, k, l, m;
326
  uint32_t vlc;
327
  int8_t *top, *left;
328
  MpegEncContext *const s = (MpegEncContext *) h;
329
  const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
330
  const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
331

    
332
  h->top_samples_available        = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
333
  h->left_samples_available        = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
334
  h->topright_samples_available        = 0xFFFF;
335

    
336
  if (mb_type == 0) {                /* SKIP */
337
    svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0);
338

    
339
    cbp = 0;
340
    mb_type = MB_TYPE_SKIP;
341
  } else if (mb_type < 8) {        /* INTER */
342
    if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) {
343
      mode = THIRDPEL_MODE;
344
    } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) {
345
      mode = HALFPEL_MODE;
346
    } else {
347
      mode = FULLPEL_MODE;
348
    }
349

    
350
    /* fill caches */
351
    /* note ref_cache[0] should contain here:
352
        ????????
353
        ???11111
354
        N??11111
355
        N??11111
356
        N??11111
357
        N
358
    */
359
    
360
    if (s->mb_x > 0) {
361
      for (i=0; i < 4; i++) {
362
        *(uint32_t *) h->mv_cache[0][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - 1 + i*h->b_stride];
363
      }
364
    } else {
365
      for (i=0; i < 4; i++) {
366
        *(uint32_t *) h->mv_cache[0][scan8[0] - 1 + i*8] = 0;
367
      }
368
    }
369
    if (s->mb_y > 0) {
370
      memcpy (h->mv_cache[0][scan8[0] - 1*8], s->current_picture.motion_val[0][b_xy - h->b_stride], 4*2*sizeof(int16_t));
371
      memset (&h->ref_cache[0][scan8[0] - 1*8], 1, 4);
372

    
373
      if (s->mb_x < (s->mb_width - 1)) {
374
        *(uint32_t *) h->mv_cache[0][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - h->b_stride + 4];
375
        h->ref_cache[0][scan8[0] + 4 - 1*8] = 1;
376
      }else
377
        h->ref_cache[0][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
378
      if (s->mb_x > 0) {
379
        *(uint32_t *) h->mv_cache[0][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - h->b_stride - 1];
380
        h->ref_cache[0][scan8[0] - 1 - 1*8] = 1;
381
      }else
382
        h->ref_cache[0][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
383
    }else
384
      memset (&h->ref_cache[0][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
385

    
386
    /* decode motion vector(s) and form prediction(s) */
387
    part_width  = ((mb_type & 5) == 5) ? 4 : 8 << (mb_type & 1);
388
    part_height = 16 >> ((unsigned) mb_type / 3);
389

    
390
    for (i=0; i < 16; i+=part_height) {
391
      for (j=0; j < 16; j+=part_width) {
392
        int dxy;
393
        x = 16*s->mb_x + j;
394
        y = 16*s->mb_y + i;
395
        k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
396

    
397
        pred_motion (h, k, (part_width >> 2), 0, 1, &mx, &my);
398

    
399
        /* clip motion vector prediction to frame border */
400
        mx = clip (mx, -6*x, 6*(s->h_edge_pos - part_width  - x));
401
        my = clip (my, -6*y, 6*(s->v_edge_pos - part_height - y));
402

    
403
        /* get motion vector differential */
404
        dy = svq3_get_se_golomb (&s->gb);
405
        dx = svq3_get_se_golomb (&s->gb);
406

    
407
        if (dx == INVALID_VLC || dy == INVALID_VLC) {
408
          return -1;
409
        }
410
        /* compute motion vector */
411
        if (mode == THIRDPEL_MODE) {
412
          int fx, fy;
413
          mx = ((mx + 1)>>1) + dx;
414
          my = ((my + 1)>>1) + dy;
415
          fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
416
          fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
417
          dxy= (mx - 3*fx) + 4*(my - 3*fy);
418

    
419
          svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1);
420
          mx += mx;
421
          my += my;
422
        } else if (mode == HALFPEL_MODE) {
423
          mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
424
          my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
425
          dxy= (mx&1) + 2*(my&1);
426

    
427
          svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0);
428
          mx *= 3;
429
          my *= 3;
430
        } else {
431
          assert(mode == FULLPEL_MODE);
432
          mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
433
          my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
434

    
435
          svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0);
436
          mx *= 6;
437
          my *= 6;
438
        }
439

    
440
        /* update mv_cache */
441
        fill_rectangle(h->mv_cache[0][scan8[k]], part_width>>2, part_height>>2, 8, pack16to32(mx,my), 4);
442
      }
443
    }
444

    
445
    for (i=0; i < 4; i++) {
446
      memcpy (s->current_picture.motion_val[0][b_xy + i*h->b_stride], h->mv_cache[0][scan8[0] + 8*i], 4*2*sizeof(int16_t));
447
    }
448

    
449
    if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48)
450
      return -1;
451

    
452
    cbp = golomb_to_inter_cbp[vlc];
453
    mb_type = MB_TYPE_16x16;
454
  } else if (mb_type == 8) {        /* INTRA4x4 */
455
    memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
456

    
457
    if (s->mb_x > 0) {
458
      for (i=0; i < 4; i++) {
459
        h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
460
      }
461
    }
462
    if (s->mb_y > 0) {
463
      h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
464
      h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
465
      h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
466
      h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
467
    }
468

    
469
    /* decode prediction codes for luma blocks */
470
    for (i=0; i < 16; i+=2) {
471
      vlc = svq3_get_ue_golomb (&s->gb);
472

    
473
      if (vlc >= 25)
474
        return -1;
475

    
476
      left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
477
      top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
478

    
479
      left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
480
      left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
481

    
482
      if (left[1] == -1 || left[2] == -1)
483
        return -1;
484
    }
485

    
486
    write_back_intra_pred_mode (h);
487
    check_intra4x4_pred_mode (h);
488

    
489
    if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48)
490
      return -1;
491

    
492
    cbp = golomb_to_intra4x4_cbp[vlc];
493
    mb_type = MB_TYPE_INTRA4x4;
494
  } else {                        /* INTRA16x16 */
495
    dir = i_mb_type_info[mb_type - 8].pred_mode;
496
    dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
497

    
498
    if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1)
499
      return -1;
500

    
501
    cbp = i_mb_type_info[mb_type - 8].cbp;
502
    mb_type = MB_TYPE_INTRA16x16;
503
  }
504

    
505
  if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
506
    for (i=0; i < 4; i++) {
507
      memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
508
    }
509
  }
510
  if (!IS_INTRA4x4(mb_type)) {
511
    memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
512
  }
513
  if (!IS_SKIP(mb_type)) {
514
    memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
515
    s->dsp.clear_blocks(h->mb);
516
  }
517

    
518
  if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
519
    s->qscale += svq3_get_se_golomb (&s->gb);
520

    
521
    if (s->qscale > 31)
522
      return -1;
523
  }
524
  if (IS_INTRA16x16(mb_type)) {
525
    if (svq3_decode_block (&s->gb, h->mb, 0, 0))
526
      return -1;
527
  }
528

    
529
  if (!IS_SKIP(mb_type) && cbp) {
530
    l = IS_INTRA16x16(mb_type) ? 1 : 0;
531
    m = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
532

    
533
    for (i=0; i < 4; i++) {
534
      if ((cbp & (1 << i))) {
535
        for (j=0; j < 4; j++) {
536
          k = l ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
537
          h->non_zero_count_cache[ scan8[k] ] = 1;
538

    
539
          if (svq3_decode_block (&s->gb, &h->mb[16*k], l, m))
540
            return -1;
541
        }
542
      }
543
    }
544

    
545
    if ((cbp & 0x30)) {
546
      for (i=0; i < 2; ++i) {
547
        if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3))
548
          return -1;
549
      }
550

    
551
      if ((cbp & 0x20)) {
552
        for (i=0; i < 8; i++) {
553
          h->non_zero_count_cache[ scan8[16+i] ] = 1;
554

    
555
          if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1))
556
            return -1;
557
        }
558
      }
559
    }
560
  }
561

    
562
  s->current_picture.mb_type[mb_xy] = mb_type;
563

    
564
  if (IS_INTRA(mb_type)) {
565
    h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
566
  }
567

    
568
  return 0;
569
}
570

    
571
static int svq3_decode_frame (AVCodecContext *avctx,
572
                              void *data, int *data_size,
573
                              uint8_t *buf, int buf_size) {
574
  MpegEncContext *const s = avctx->priv_data;
575
  H264Context *const h = avctx->priv_data;
576
  int i;
577

    
578
  s->flags = avctx->flags;
579
  
580
  if (!s->context_initialized) {
581
    s->width = avctx->width;
582
    s->height = avctx->height;
583
    h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
584
    h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
585
    h->halfpel_flag = 1;
586
    h->thirdpel_flag = 1;
587
    h->chroma_qp = 4;
588

    
589
    if (MPV_common_init (s) < 0)
590
      return -1;
591

    
592
    h->b_stride = 4*s->mb_width;
593

    
594
    alloc_tables (h);
595
  }
596
  
597
  s->low_delay= 1;  
598
  
599
  if (avctx->extradata && avctx->extradata_size >= 0x63
600
      && !memcmp (avctx->extradata, "SVQ3", 4)) {
601

    
602
    uint8_t *stsd = (uint8_t *) avctx->extradata + 0x62;
603

    
604
    if ((*stsd >> 5) != 7 || avctx->extradata_size >= 0x66) {
605

    
606
      if ((*stsd >> 5) == 7) {
607
        stsd += 3;        /* skip width, height (12 bits each) */
608
      }
609

    
610
      h->halfpel_flag = (*stsd >> 4) & 1;
611
      h->thirdpel_flag = (*stsd >> 3) & 1;
612
    }
613
  }
614

    
615
  if ((buf[0] & 0x9F) != 1) {
616
    /* TODO: what? */
617
    fprintf (stderr, "unsupported header (%02X)\n", buf[0]);
618
    return -1;
619
  } else {
620
    int length = (buf[0] >> 5) & 3;
621
    int offset = 0;
622

    
623
    for (i=0; i < length; i++) {
624
      offset = (offset << 8) | buf[i + 1];
625
    }
626

    
627
    if (buf_size < (offset + length + 1) || length == 0)
628
      return -1;
629

    
630
    memcpy (&buf[2], &buf[offset + 2], (length - 1));
631
  }
632

    
633
  init_get_bits (&s->gb, &buf[2], 8*(buf_size - 2));
634

    
635
  if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3)
636
    return -1;
637

    
638
  s->pict_type = golomb_to_pict_type[i];
639

    
640
  /* unknown fields */
641
  get_bits (&s->gb, 1);
642
  get_bits (&s->gb, 8);
643

    
644
  s->qscale = get_bits (&s->gb, 5);
645
  s->adaptive_quant = get_bits (&s->gb, 1);
646

    
647
  /* unknown fields */
648
  get_bits (&s->gb, 1);
649
  get_bits (&s->gb, 1);
650
  get_bits (&s->gb, 2);
651

    
652
  while (get_bits (&s->gb, 1)) {
653
    get_bits (&s->gb, 8);
654
  }
655
  
656
  if(avctx->debug&FF_DEBUG_PICT_INFO){
657
      printf("%c hpel:%d, tpel:%d aqp:%d qp:%d\n", 
658
      av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
659
      s->adaptive_quant, s->qscale
660
      );
661
  }
662

    
663
  /* B-frames are not supported */
664
  if (s->pict_type == B_TYPE/* && avctx->hurry_up*/)
665
    return buf_size;
666

    
667
  frame_start (h);
668

    
669
  for(i=0; i<4; i++){
670
    int j;
671
    for(j=-1; j<4; j++)
672
      h->ref_cache[0][scan8[0] + 8*i + j]= 1;
673
    h->ref_cache[0][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
674
  }
675
  
676
  for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
677
    for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
678
      int mb_type = svq3_get_ue_golomb (&s->gb);
679

    
680
      if (s->pict_type == I_TYPE) {
681
        mb_type += 8;
682
      }
683
      if (mb_type > 32 || svq3_decode_mb (h, mb_type)) {
684
        fprintf (stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
685
        return -1;
686
      }
687

    
688
      if (mb_type != 0) {
689
        hl_decode_mb (h);
690
      }
691
    }
692

    
693
    ff_draw_horiz_band(s, 16*s->mb_y, 16);
694
  }
695

    
696
  *(AVFrame *) data = *(AVFrame *) &s->current_picture;
697
  *data_size = sizeof(AVFrame);
698

    
699
  MPV_frame_end(s);
700
  
701
  return buf_size;
702
}
703

    
704

    
705
AVCodec svq3_decoder = {
706
    "svq3",
707
    CODEC_TYPE_VIDEO,
708
    CODEC_ID_SVQ3,
709
    sizeof(H264Context),
710
    decode_init,
711
    NULL,
712
    decode_end,
713
    svq3_decode_frame,
714
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
715
};