Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 55fde95e

History | View | Annotate | Download (32.1 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
 * How to use this decoder:
22
 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
23
 * have stsd atoms to describe media trak properties. A stsd atom for a
24
 * video trak contains 1 or more ImageDescription atoms. These atoms begin
25
 * with the 4-byte length of the atom followed by the codec fourcc. Some
26
 * decoders need information in this atom to operate correctly. Such
27
 * is the case with SVQ3. In order to get the best use out of this decoder,
28
 * the calling app must make the SVQ3 ImageDescription atom available
29
 * via the AVCodecContext's extradata[_size] field:
30
 *
31
 * AVCodecContext.extradata = pointer to ImageDescription, first characters
32
 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
33
 * AVCodecContext.extradata_size = size of ImageDescription atom memory
34
 * buffer (which will be the same as the ImageDescription atom size field
35
 * from the QT file, minus 4 bytes since the length is missing)
36
 *
37
 * You will know you have these parameters passed correctly when the decoder
38
 * correctly decodes this file:
39
 *  ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
40
 *
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 void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
184
    LOAD_TOP_EDGE
185
    LOAD_LEFT_EDGE
186
    const __attribute__((unused)) int unu0= t0;
187
    const __attribute__((unused)) int unu1= l0;
188

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

    
207
static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
208
    pred16x16_plane_compat_c(src, stride, 1);
209
}
210

    
211
static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
212
                                     int index, const int type) {
213

    
214
  static const uint8_t *const scan_patterns[4] =
215
  { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
216

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

    
221
  for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
222
    for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
223

    
224
      if (vlc == INVALID_VLC)
225
        return -1;
226

    
227
      sign = (vlc & 0x1) - 1;
228
      vlc  = (vlc + 1) >> 1;
229

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

    
254
      if ((index += run) >= limit)
255
        return -1;
256

    
257
      block[scan[index]] = (level ^ sign) - sign;
258
    }
259

    
260
    if (type != 2) {
261
      break;
262
    }
263
  }
264

    
265
  return 0;
266
}
267

    
268
static inline void svq3_mc_dir_part (MpegEncContext *s,
269
                                     int x, int y, int width, int height,
270
                                     int mx, int my, int dxy,
271
                                     int thirdpel, int dir, int avg) {
272

    
273
  const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
274
  uint8_t *src, *dest;
275
  int i, emu = 0;
276
  int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
277

    
278
  mx += x;
279
  my += y;
280

    
281
  if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
282
      my < 0 || my >= (s->v_edge_pos - height - 1)) {
283

    
284
    if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
285
      emu = 1;
286
    }
287

    
288
    mx = clip (mx, -16, (s->h_edge_pos - width  + 15));
289
    my = clip (my, -16, (s->v_edge_pos - height + 15));
290
  }
291

    
292
  /* form component predictions */
293
  dest = s->current_picture.data[0] + x + y*s->linesize;
294
  src  = pic->data[0] + mx + my*s->linesize;
295

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

    
306
  if (!(s->flags & CODEC_FLAG_GRAY)) {
307
    mx     = (mx + (mx < (int) x)) >> 1;
308
    my     = (my + (my < (int) y)) >> 1;
309
    width  = (width  >> 1);
310
    height = (height >> 1);
311
    blocksize++;
312

    
313
    for (i=1; i < 3; i++) {
314
      dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
315
      src  = pic->data[i] + mx + my*s->uvlinesize;
316

    
317
      if (emu) {
318
        ff_emulated_edge_mc (s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
319
                             mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
320
        src = s->edge_emu_buffer;
321
      }
322
      if(thirdpel)
323
        (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
324
      else
325
        (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
326
    }
327
  }
328
}
329

    
330
static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
331

    
332
  int i, j, k, mx, my, dx, dy, x, y;
333
  MpegEncContext *const s = (MpegEncContext *) h;
334
  const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
335
  const int part_height = 16 >> ((unsigned) (size + 1) / 3);
336
  const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
337
  const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
338
  const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
339

    
340
  for (i=0; i < 16; i+=part_height) {
341
    for (j=0; j < 16; j+=part_width) {
342
      const int b_xy = (4*s->mb_x+(j>>2)) + (4*s->mb_y+(i>>2))*h->b_stride;
343
      int dxy;
344
      x = 16*s->mb_x + j;
345
      y = 16*s->mb_y + i;
346
      k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
347

    
348
      if (mode != PREDICT_MODE) {
349
        pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
350
      } else {
351
        mx = s->next_picture.motion_val[0][b_xy][0]<<1;
352
        my = s->next_picture.motion_val[0][b_xy][1]<<1;
353

    
354
        if (dir == 0) {
355
          mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
356
          my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
357
        } else {
358
          mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
359
          my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
360
        }
361
      }
362

    
363
      /* clip motion vector prediction to frame border */
364
      mx = clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
365
      my = clip (my, extra_width - 6*y, v_edge_pos - 6*y);
366

    
367
      /* get (optional) motion vector differential */
368
      if (mode == PREDICT_MODE) {
369
        dx = dy = 0;
370
      } else {
371
        dy = svq3_get_se_golomb (&s->gb);
372
        dx = svq3_get_se_golomb (&s->gb);
373

    
374
        if (dx == INVALID_VLC || dy == INVALID_VLC) {
375
          av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
376
          return -1;
377
        }
378
      }
379

    
380
      /* compute motion vector */
381
      if (mode == THIRDPEL_MODE) {
382
        int fx, fy;
383
        mx = ((mx + 1)>>1) + dx;
384
        my = ((my + 1)>>1) + dy;
385
        fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
386
        fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
387
        dxy= (mx - 3*fx) + 4*(my - 3*fy);
388

    
389
        svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
390
        mx += mx;
391
        my += my;
392
      } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
393
        mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
394
        my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
395
        dxy= (mx&1) + 2*(my&1);
396

    
397
        svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
398
        mx *= 3;
399
        my *= 3;
400
      } else {
401
        mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
402
        my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
403

    
404
        svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
405
        mx *= 6;
406
        my *= 6;
407
      }
408

    
409
      /* update mv_cache */
410
      if (mode != PREDICT_MODE) {
411
        int32_t mv = pack16to32(mx,my);
412

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

    
416
          if (part_width == 8 && j < 8) {
417
            *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
418
          }
419
        }
420
        if (part_width == 8 && j < 8) {
421
          *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
422
        }
423
        if (part_width == 4 || part_height == 4) {
424
          *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
425
        }
426
      }
427

    
428
      /* write back motion vectors */
429
      fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
430
    }
431
  }
432

    
433
  return 0;
434
}
435

    
436
static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
437
  int i, j, k, m, dir, mode;
438
  int cbp = 0;
439
  uint32_t vlc;
440
  int8_t *top, *left;
441
  MpegEncContext *const s = (MpegEncContext *) h;
442
  const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
443
  const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
444

    
445
  h->top_samples_available        = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
446
  h->left_samples_available        = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
447
  h->topright_samples_available        = 0xFFFF;
448

    
449
  if (mb_type == 0) {           /* SKIP */
450
    if (s->pict_type == P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
451
      svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
452

    
453
      if (s->pict_type == B_TYPE) {
454
        svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
455
      }
456

    
457
      mb_type = MB_TYPE_SKIP;
458
    } else {
459
      mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
460
      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
461
        return -1;
462
      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
463
        return -1;
464

    
465
      mb_type = MB_TYPE_16x16;
466
    }
467
  } else if (mb_type < 8) {     /* INTER */
468
    if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) {
469
      mode = THIRDPEL_MODE;
470
    } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) {
471
      mode = HALFPEL_MODE;
472
    } else {
473
      mode = FULLPEL_MODE;
474
    }
475

    
476
    /* fill caches */
477
    /* note ref_cache should contain here:
478
        ????????
479
        ???11111
480
        N??11111
481
        N??11111
482
        N??11111
483
        N
484
    */
485

    
486
    for (m=0; m < 2; m++) {
487
      if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
488
        for (i=0; i < 4; i++) {
489
          *(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];
490
        }
491
      } else {
492
        for (i=0; i < 4; i++) {
493
          *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
494
        }
495
      }
496
      if (s->mb_y > 0) {
497
        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));
498
        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);
499

    
500
        if (s->mb_x < (s->mb_width - 1)) {
501
          *(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];
502
          h->ref_cache[m][scan8[0] + 4 - 1*8] =
503
                  (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
504
                   h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
505
        }else
506
          h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
507
        if (s->mb_x > 0) {
508
          *(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];
509
          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;
510
        }else
511
          h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
512
      }else
513
        memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
514

    
515
      if (s->pict_type != B_TYPE)
516
        break;
517
    }
518

    
519
    /* decode motion vector(s) and form prediction(s) */
520
    if (s->pict_type == P_TYPE) {
521
      if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
522
        return -1;
523
    } else {        /* B_TYPE */
524
      if (mb_type != 2) {
525
        if(svq3_mc_dir (h, 0, mode, 0, 0) < 0)
526
          return -1;
527
      } else {
528
        for (i=0; i < 4; i++) {
529
          memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
530
        }
531
      }
532
      if (mb_type != 1) {
533
        if(svq3_mc_dir (h, 0, mode, 1, (mb_type == 3)) < 0)
534
          return -1;
535
      } else {
536
        for (i=0; i < 4; i++) {
537
          memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
538
        }
539
      }
540
    }
541

    
542
    mb_type = MB_TYPE_16x16;
543
  } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
544
    memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
545

    
546
    if (mb_type == 8) {
547
      if (s->mb_x > 0) {
548
        for (i=0; i < 4; i++) {
549
          h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
550
        }
551
        if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
552
          h->left_samples_available = 0x5F5F;
553
        }
554
      }
555
      if (s->mb_y > 0) {
556
        h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
557
        h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
558
        h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
559
        h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
560

    
561
        if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
562
          h->top_samples_available = 0x33FF;
563
        }
564
      }
565

    
566
      /* decode prediction codes for luma blocks */
567
      for (i=0; i < 16; i+=2) {
568
        vlc = svq3_get_ue_golomb (&s->gb);
569

    
570
        if (vlc >= 25){
571
          av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
572
          return -1;
573
        }
574

    
575
        left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
576
        top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
577

    
578
        left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
579
        left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
580

    
581
        if (left[1] == -1 || left[2] == -1){
582
          av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
583
          return -1;
584
        }
585
      }
586
    } else {    /* mb_type == 33, DC_128_PRED block type */
587
      for (i=0; i < 4; i++) {
588
        memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
589
      }
590
    }
591

    
592
    write_back_intra_pred_mode (h);
593

    
594
    if (mb_type == 8) {
595
      check_intra4x4_pred_mode (h);
596

    
597
      h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
598
      h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
599
    } else {
600
      for (i=0; i < 4; i++) {
601
        memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
602
      }
603

    
604
      h->top_samples_available  = 0x33FF;
605
      h->left_samples_available = 0x5F5F;
606
    }
607

    
608
    mb_type = MB_TYPE_INTRA4x4;
609
  } else {                      /* INTRA16x16 */
610
    dir = i_mb_type_info[mb_type - 8].pred_mode;
611
    dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
612

    
613
    if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
614
      av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
615
      return -1;
616
    }
617

    
618
    cbp = i_mb_type_info[mb_type - 8].cbp;
619
    mb_type = MB_TYPE_INTRA16x16;
620
  }
621

    
622
  if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
623
    for (i=0; i < 4; i++) {
624
      memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
625
    }
626
    if (s->pict_type == B_TYPE) {
627
      for (i=0; i < 4; i++) {
628
        memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
629
      }
630
    }
631
  }
632
  if (!IS_INTRA4x4(mb_type)) {
633
    memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
634
  }
635
  if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
636
    memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
637
    s->dsp.clear_blocks(h->mb);
638
  }
639

    
640
  if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
641
    if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
642
      av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
643
      return -1;
644
    }
645

    
646
    cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
647
  }
648
  if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
649
    s->qscale += svq3_get_se_golomb (&s->gb);
650

    
651
    if (s->qscale > 31){
652
      av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
653
      return -1;
654
    }
655
  }
656
  if (IS_INTRA16x16(mb_type)) {
657
    if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
658
      av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
659
      return -1;
660
    }
661
  }
662

    
663
  if (cbp) {
664
    const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
665
    const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
666

    
667
    for (i=0; i < 4; i++) {
668
      if ((cbp & (1 << i))) {
669
        for (j=0; j < 4; j++) {
670
          k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
671
          h->non_zero_count_cache[ scan8[k] ] = 1;
672

    
673
          if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
674
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
675
            return -1;
676
          }
677
        }
678
      }
679
    }
680

    
681
    if ((cbp & 0x30)) {
682
      for (i=0; i < 2; ++i) {
683
        if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
684
          av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
685
          return -1;
686
        }
687
      }
688

    
689
      if ((cbp & 0x20)) {
690
        for (i=0; i < 8; i++) {
691
          h->non_zero_count_cache[ scan8[16+i] ] = 1;
692

    
693
          if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1)){
694
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
695
            return -1;
696
          }
697
        }
698
      }
699
    }
700
  }
701

    
702
  s->current_picture.mb_type[mb_xy] = mb_type;
703

    
704
  if (IS_INTRA(mb_type)) {
705
    h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
706
  }
707

    
708
  return 0;
709
}
710

    
711
static int svq3_decode_slice_header (H264Context *h) {
712
  MpegEncContext *const s = (MpegEncContext *) h;
713
  const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
714
  int i, header;
715

    
716
  header = get_bits (&s->gb, 8);
717

    
718
  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
719
    /* TODO: what? */
720
    av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
721
    return -1;
722
  } else {
723
    int length = (header >> 5) & 3;
724

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

    
727
    if (h->next_slice_index > s->gb.size_in_bits){
728
      av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
729
      return -1;
730
    }
731

    
732
    s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
733
    skip_bits(&s->gb, 8);
734

    
735
    if (length > 0) {
736
      memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
737
             &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
738
    }
739
  }
740

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

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

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

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

    
760
  /* unknown fields */
761
  get_bits1 (&s->gb);
762

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

    
767
  get_bits1 (&s->gb);
768
  get_bits (&s->gb, 2);
769

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

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

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

    
787
  return 0;
788
}
789

    
790
static int svq3_decode_frame (AVCodecContext *avctx,
791
                              void *data, int *data_size,
792
                              uint8_t *buf, int buf_size) {
793
  MpegEncContext *const s = avctx->priv_data;
794
  H264Context *const h = avctx->priv_data;
795
  int m, mb_type;
796
  unsigned char *extradata;
797
  unsigned int size;
798

    
799
  s->flags = avctx->flags;
800
  s->flags2 = avctx->flags2;
801
  s->unrestricted_mv = 1;
802

    
803
  if (!s->context_initialized) {
804
    s->width = avctx->width;
805
    s->height = avctx->height;
806
    h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
807
    h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
808
    h->halfpel_flag = 1;
809
    h->thirdpel_flag = 1;
810
    h->unknown_svq3_flag = 0;
811
    h->chroma_qp = 4;
812

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

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

    
818
    alloc_tables (h);
819

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

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

    
831
      GetBitContext gb;
832

    
833
      size = BE_32(&extradata[4]);
834
      init_get_bits (&gb, extradata + 8, size*8);
835

    
836
      /* 'frame size code' and optional 'width, height' */
837
      if (get_bits (&gb, 3) == 7) {
838
        get_bits (&gb, 12);
839
        get_bits (&gb, 12);
840
      }
841

    
842
      h->halfpel_flag = get_bits1 (&gb);
843
      h->thirdpel_flag = get_bits1 (&gb);
844

    
845
      /* unknown fields */
846
      get_bits1 (&gb);
847
      get_bits1 (&gb);
848
      get_bits1 (&gb);
849
      get_bits1 (&gb);
850

    
851
      s->low_delay = get_bits1 (&gb);
852

    
853
      /* unknown field */
854
      get_bits1 (&gb);
855

    
856
      while (get_bits1 (&gb)) {
857
        get_bits (&gb, 8);
858
      }
859

    
860
      h->unknown_svq3_flag = get_bits1 (&gb);
861
      avctx->has_b_frames = !s->low_delay;
862
    }
863
  }
864

    
865
  /* special case for last picture */
866
  if (buf_size == 0) {
867
    if (s->next_picture_ptr && !s->low_delay) {
868
      *(AVFrame *) data = *(AVFrame *) &s->next_picture;
869
      *data_size = sizeof(AVFrame);
870
    }
871
    return 0;
872
  }
873

    
874
  init_get_bits (&s->gb, buf, 8*buf_size);
875

    
876
  s->mb_x = s->mb_y = 0;
877

    
878
  if (svq3_decode_slice_header (h))
879
    return -1;
880

    
881
  s->pict_type = h->slice_type;
882
  s->picture_number = h->slice_num;
883

    
884
  if(avctx->debug&FF_DEBUG_PICT_INFO){
885
      av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
886
      av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
887
      s->adaptive_quant, s->qscale
888
      );
889
  }
890

    
891
  /* for hurry_up==5 */
892
  s->current_picture.pict_type = s->pict_type;
893
  s->current_picture.key_frame = (s->pict_type == I_TYPE);
894

    
895
  /* skip b frames if we dont have reference frames */
896
  if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
897
  /* skip b frames if we are in a hurry */
898
  if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
899
  /* skip everything if we are in a hurry >= 5 */
900
  if (avctx->hurry_up >= 5) return 0;
901
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
902
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
903
     || avctx->skip_frame >= AVDISCARD_ALL)
904
      return 0;
905

    
906
  if (s->next_p_frame_damaged) {
907
    if (s->pict_type == B_TYPE)
908
      return 0;
909
    else
910
      s->next_p_frame_damaged = 0;
911
  }
912

    
913
  frame_start (h);
914

    
915
  if (s->pict_type == B_TYPE) {
916
    h->frame_num_offset = (h->slice_num - h->prev_frame_num);
917

    
918
    if (h->frame_num_offset < 0) {
919
      h->frame_num_offset += 256;
920
    }
921
    if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
922
      av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
923
      return -1;
924
    }
925
  } else {
926
    h->prev_frame_num = h->frame_num;
927
    h->frame_num = h->slice_num;
928
    h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
929

    
930
    if (h->prev_frame_num_offset < 0) {
931
      h->prev_frame_num_offset += 256;
932
    }
933
  }
934

    
935
  for(m=0; m<2; m++){
936
    int i;
937
    for(i=0; i<4; i++){
938
      int j;
939
      for(j=-1; j<4; j++)
940
        h->ref_cache[m][scan8[0] + 8*i + j]= 1;
941
      h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
942
    }
943
  }
944

    
945
  for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
946
    for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
947

    
948
      if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
949
          ((get_bits_count(&s->gb) & 7) == 0 || show_bits (&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
950

    
951
        skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
952
        s->gb.size_in_bits = 8*buf_size;
953

    
954
        if (svq3_decode_slice_header (h))
955
          return -1;
956

    
957
        /* TODO: support s->mb_skip_run */
958
      }
959

    
960
      mb_type = svq3_get_ue_golomb (&s->gb);
961

    
962
      if (s->pict_type == I_TYPE) {
963
        mb_type += 8;
964
      } else if (s->pict_type == B_TYPE && mb_type >= 4) {
965
        mb_type += 4;
966
      }
967
      if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
968
        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
969
        return -1;
970
      }
971

    
972
      if (mb_type != 0) {
973
        hl_decode_mb (h);
974
      }
975

    
976
      if (s->pict_type != B_TYPE && !s->low_delay) {
977
        s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
978
                        (s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
979
      }
980
    }
981

    
982
    ff_draw_horiz_band(s, 16*s->mb_y, 16);
983
  }
984

    
985
  MPV_frame_end(s);
986

    
987
  if (s->pict_type == B_TYPE || s->low_delay) {
988
    *(AVFrame *) data = *(AVFrame *) &s->current_picture;
989
  } else {
990
    *(AVFrame *) data = *(AVFrame *) &s->last_picture;
991
  }
992

    
993
  avctx->frame_number = s->picture_number - 1;
994

    
995
  /* dont output the last pic after seeking */
996
  if (s->last_picture_ptr || s->low_delay) {
997
    *data_size = sizeof(AVFrame);
998
  }
999

    
1000
  return buf_size;
1001
}
1002

    
1003

    
1004
AVCodec svq3_decoder = {
1005
    "svq3",
1006
    CODEC_TYPE_VIDEO,
1007
    CODEC_ID_SVQ3,
1008
    sizeof(H264Context),
1009
    decode_init,
1010
    NULL,
1011
    decode_end,
1012
    svq3_decode_frame,
1013
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1014
};