Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 755bfeab

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 av_unused int unu0= t0;
187
    const av_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 = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
289
    my = av_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 = av_clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
365
      my = av_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
    */
484

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

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

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

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

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

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

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

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

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

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

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

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

    
591
    write_back_intra_pred_mode (h);
592

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
707
  return 0;
708
}
709

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
786
  return 0;
787
}
788

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

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

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

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

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

    
817
    alloc_tables (h);
818

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

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

    
830
      GetBitContext gb;
831

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
912
  if (frame_start (h) < 0)
913
    return -1;
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
      if(i<3)
942
        h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
943
    }
944
  }
945

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

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

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

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

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

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

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

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

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

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

    
986
  MPV_frame_end(s);
987

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

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

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

    
1001
  return buf_size;
1002
}
1003

    
1004

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