Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq3.c @ 5509bffa

History | View | Annotate | Download (32 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
          av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
374
          return -1;
375
        }
376
      }
377

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

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

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

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

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

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

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

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

    
431
  return 0;
432
}
433

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
590
    write_back_intra_pred_mode (h);
591

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
706
  return 0;
707
}
708

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
785
  return 0;
786
}
787

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

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

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

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

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

    
816
    alloc_tables (h);
817

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

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

    
829
      GetBitContext gb;
830

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
911
  frame_start (h);
912

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

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

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

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

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

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

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

    
952
        if (svq3_decode_slice_header (h))
953
          return -1;
954

    
955
        /* TODO: support s->mb_skip_run */
956
      }
957

    
958
      mb_type = svq3_get_ue_golomb (&s->gb);
959

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

    
970
      if (mb_type != 0) {
971
        hl_decode_mb (h);
972
      }
973

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

    
980
    ff_draw_horiz_band(s, 16*s->mb_y, 16);
981
  }
982

    
983
  MPV_frame_end(s);
984

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

    
991
  avctx->frame_number = s->picture_number - 1;
992

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

    
998
  return buf_size;
999
}
1000

    
1001

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