Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 8a01fc47

History | View | Annotate | Download (29.6 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
#define PREDICT_MODE  4
50
 
51
/* dual scan (from some older h264 draft)
52
 o-->o-->o   o
53
         |  /|
54
 o   o   o / o
55
 | / |   |/  |
56
 o   o   o   o
57
   / 
58
 o-->o-->o-->o
59
*/
60
static const uint8_t svq3_scan[16]={
61
 0+0*4, 1+0*4, 2+0*4, 2+1*4,
62
 2+2*4, 3+0*4, 3+1*4, 3+2*4,
63
 0+1*4, 0+2*4, 1+1*4, 1+2*4,
64
 0+3*4, 1+3*4, 2+3*4, 3+3*4,
65
};
66

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

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

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

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

    
108

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
263
  return 0;
264
}
265

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

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

    
276
  mx += x;
277
  my += y;
278
  
279
  if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
280
      my < 0 || my >= (s->v_edge_pos - height - 1)) {
281

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

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

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

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

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

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

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

    
328
static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
329

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

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

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

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

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

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

    
372
        if (dx == INVALID_VLC || dy == INVALID_VLC) {
373
          return -1;
374
        }
375
      }
376

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

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

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

    
401
        svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
402
        mx *= 6;
403
        my *= 6;
404
      }
405

    
406
      /* update mv_cache */
407
      if (mode != PREDICT_MODE) {
408
        int32_t mv = pack16to32(mx,my);
409

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

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

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

    
430
  return 0;
431
}
432

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

    
442
  h->top_samples_available        = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
443
  h->left_samples_available        = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
444
  h->topright_samples_available        = 0xFFFF;
445

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

    
450
      if (s->pict_type == B_TYPE) {
451
        svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
452
      }
453

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

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

    
473
    /* fill caches */
474
    /* note ref_cache should contain here:
475
        ????????
476
        ???11111
477
        N??11111
478
        N??11111
479
        N??11111
480
        N
481
    */
482
    
483
    for (m=0; m < 2; m++) {
484
      if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
485
        for (i=0; i < 4; i++) {
486
          *(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];
487
        }
488
      } else {
489
        for (i=0; i < 4; i++) {
490
          *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
491
        }
492
      }
493
      if (s->mb_y > 0) {
494
        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));
495
        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);
496

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

    
512
      if (s->pict_type != B_TYPE)
513
        break;
514
    }
515

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

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

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

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

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

    
567
        if (vlc >= 25)
568
          return -1;
569

    
570
        left        = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
571
        top        = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
572

    
573
        left[1]        = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
574
        left[2]        = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
575

    
576
        if (left[1] == -1 || left[2] == -1)
577
          return -1;
578
      }
579
    } else {        /* mb_type == 33, DC_128_PRED block type */
580
      for (i=0; i < 4; i++) {
581
        memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
582
      }
583
    }
584

    
585
    write_back_intra_pred_mode (h);
586

    
587
    if (mb_type == 8) {
588
      check_intra4x4_pred_mode (h);
589

    
590
      h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
591
      h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
592
    } else {
593
      for (i=0; i < 4; i++) {
594
        memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
595
      }
596

    
597
      h->top_samples_available  = 0x33FF;
598
      h->left_samples_available = 0x5F5F;
599
    }
600

    
601
    mb_type = MB_TYPE_INTRA4x4;
602
  } else {                        /* INTRA16x16 */
603
    dir = i_mb_type_info[mb_type - 8].pred_mode;
604
    dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
605

    
606
    if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1)
607
      return -1;
608

    
609
    cbp = i_mb_type_info[mb_type - 8].cbp;
610
    mb_type = MB_TYPE_INTRA16x16;
611
  }
612

    
613
  if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
614
    for (i=0; i < 4; i++) {
615
      memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
616
    }
617
    if (s->pict_type == B_TYPE) {
618
      for (i=0; i < 4; i++) {
619
        memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
620
      }
621
    }
622
  }
623
  if (!IS_INTRA4x4(mb_type)) {
624
    memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
625
  }
626
  if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
627
    memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
628
    s->dsp.clear_blocks(h->mb);
629
  }
630

    
631
  if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
632
    if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48)
633
      return -1;
634

    
635
    cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
636
  }
637
  if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
638
    s->qscale += svq3_get_se_golomb (&s->gb);
639

    
640
    if (s->qscale > 31)
641
      return -1;
642
  }
643
  if (IS_INTRA16x16(mb_type)) {
644
    if (svq3_decode_block (&s->gb, h->mb, 0, 0))
645
      return -1;
646
  }
647

    
648
  if (cbp) {
649
    const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
650
    const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
651

    
652
    for (i=0; i < 4; i++) {
653
      if ((cbp & (1 << i))) {
654
        for (j=0; j < 4; j++) {
655
          k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
656
          h->non_zero_count_cache[ scan8[k] ] = 1;
657

    
658
          if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type))
659
            return -1;
660
        }
661
      }
662
    }
663

    
664
    if ((cbp & 0x30)) {
665
      for (i=0; i < 2; ++i) {
666
        if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3))
667
          return -1;
668
      }
669

    
670
      if ((cbp & 0x20)) {
671
        for (i=0; i < 8; i++) {
672
          h->non_zero_count_cache[ scan8[16+i] ] = 1;
673

    
674
          if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1))
675
            return -1;
676
        }
677
      }
678
    }
679
  }
680

    
681
  s->current_picture.mb_type[mb_xy] = mb_type;
682

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

    
687
  return 0;
688
}
689

    
690
static int svq3_decode_slice_header (H264Context *h) {
691
  MpegEncContext *const s = (MpegEncContext *) h;
692
  const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
693
  int i, header;
694

    
695
  header = get_bits (&s->gb, 8);
696

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

    
704
    h->next_slice_index = s->gb.index + 8*show_bits (&s->gb, 8*length) + 8*length;
705

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

    
711
    s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
712
    s->gb.index += 8;
713

    
714
    if (length > 0) {
715
      memcpy ((uint8_t *) &s->gb.buffer[s->gb.index >> 3],
716
             &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
717
    }
718
  }
719

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

    
725
  h->slice_type = golomb_to_pict_type[i];
726

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

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

    
739
  /* unknown fields */
740
  get_bits1 (&s->gb);
741

    
742
  if (h->unknown_svq3_flag) {
743
    get_bits1 (&s->gb);
744
  }
745

    
746
  get_bits1 (&s->gb);
747
  get_bits (&s->gb, 2);
748

    
749
  while (get_bits1 (&s->gb)) {
750
    get_bits (&s->gb, 8);
751
  }
752

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

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

    
766
  return 0;
767
}
768

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

    
778
  s->flags = avctx->flags;
779
  s->flags2 = avctx->flags2;
780
  s->unrestricted_mv = 1;
781

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

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

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

    
797
    alloc_tables (h);
798

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

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

    
810
      GetBitContext gb;
811

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

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

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

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

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

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

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

    
839
      h->unknown_svq3_flag = get_bits1 (&gb);
840
      avctx->has_b_frames = !s->low_delay;
841
    }
842
  }
843

    
844
  /* special case for last picture */
845
  if (buf_size == 0) {
846
    if (s->next_picture_ptr && !s->low_delay) {
847
      *(AVFrame *) data = *(AVFrame *) &s->next_picture;
848
      *data_size = sizeof(AVFrame);
849
    }
850
    return 0;
851
  }
852

    
853
  init_get_bits (&s->gb, buf, 8*buf_size);
854

    
855
  s->mb_x = s->mb_y = 0;
856

    
857
  if (svq3_decode_slice_header (h))
858
    return -1;
859

    
860
  s->pict_type = h->slice_type;
861
  s->picture_number = h->slice_num;
862

    
863
  if(avctx->debug&FF_DEBUG_PICT_INFO){
864
      av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n", 
865
      av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
866
      s->adaptive_quant, s->qscale
867
      );
868
  }
869

    
870
  /* for hurry_up==5 */
871
  s->current_picture.pict_type = s->pict_type;
872
  s->current_picture.key_frame = (s->pict_type == I_TYPE);
873

    
874
  /* skip b frames if we dont have reference frames */
875
  if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
876
  /* skip b frames if we are in a hurry */
877
  if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
878
  /* skip everything if we are in a hurry >= 5 */
879
  if (avctx->hurry_up >= 5) return 0;
880

    
881
  if (s->next_p_frame_damaged) {
882
    if (s->pict_type == B_TYPE)
883
      return 0;
884
    else
885
      s->next_p_frame_damaged = 0;
886
  }
887

    
888
  frame_start (h);
889

    
890
  if (s->pict_type == B_TYPE) {
891
    h->frame_num_offset = (h->slice_num - h->prev_frame_num);
892

    
893
    if (h->frame_num_offset < 0) {
894
      h->frame_num_offset += 256;
895
    }
896
    if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
897
      av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
898
      return -1;
899
    }
900
  } else {
901
    h->prev_frame_num = h->frame_num;
902
    h->frame_num = h->slice_num;
903
    h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
904

    
905
    if (h->prev_frame_num_offset < 0) {
906
      h->prev_frame_num_offset += 256;
907
    }
908
  }
909

    
910
  for(m=0; m<2; m++){
911
    int i;
912
    for(i=0; i<4; i++){
913
      int j;
914
      for(j=-1; j<4; j++)
915
        h->ref_cache[m][scan8[0] + 8*i + j]= 1;
916
      h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
917
    }
918
  }
919
  
920
  for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
921
    for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
922

    
923
      if ( (s->gb.index + 7) >= s->gb.size_in_bits &&
924
          ((s->gb.index & 7) == 0 || show_bits (&s->gb, (-s->gb.index & 7)) == 0)) {
925

    
926
        s->gb.index = h->next_slice_index;
927
        s->gb.size_in_bits = 8*buf_size;
928

    
929
        if (svq3_decode_slice_header (h))
930
          return -1;
931

    
932
        /* TODO: support s->mb_skip_run */
933
      }
934

    
935
      mb_type = svq3_get_ue_golomb (&s->gb);
936

    
937
      if (s->pict_type == I_TYPE) {
938
        mb_type += 8;
939
      } else if (s->pict_type == B_TYPE && mb_type >= 4) {
940
        mb_type += 4;
941
      }
942
      if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
943
        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
944
        return -1;
945
      }
946

    
947
      if (mb_type != 0) {
948
        hl_decode_mb (h);
949
      }
950

    
951
      if (s->pict_type != B_TYPE && !s->low_delay) {
952
        s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
953
                        (s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
954
      }
955
    }
956

    
957
    ff_draw_horiz_band(s, 16*s->mb_y, 16);
958
  }
959

    
960
  MPV_frame_end(s);
961

    
962
  if (s->pict_type == B_TYPE || s->low_delay) {
963
    *(AVFrame *) data = *(AVFrame *) &s->current_picture;
964
  } else {
965
    *(AVFrame *) data = *(AVFrame *) &s->last_picture;
966
  }
967

    
968
  avctx->frame_number = s->picture_number - 1;
969

    
970
  /* dont output the last pic after seeking */
971
  if (s->last_picture_ptr || s->low_delay) {
972
    *data_size = sizeof(AVFrame);
973
  }
974

    
975
  return buf_size;
976
}
977

    
978

    
979
AVCodec svq3_decoder = {
980
    "svq3",
981
    CODEC_TYPE_VIDEO,
982
    CODEC_ID_SVQ3,
983
    sizeof(H264Context),
984
    decode_init,
985
    NULL,
986
    decode_end,
987
    svq3_decode_frame,
988
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
989
};