svq3.c 32.1 KB
Newer Older
1 2 3
/*
 * Copyright (c) 2003 The FFmpeg Project.
 *
4 5 6
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
7 8
 * modify it under the terms of the GNU Lesser General Public
 * 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 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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
 */

/*
22 23
 * How to use this decoder:
 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24 25 26 27 28 29
 * have stsd atoms to describe media trak properties. A stsd atom for a
 * video trak contains 1 or more ImageDescription atoms. These atoms begin
 * with the 4-byte length of the atom followed by the codec fourcc. Some
 * decoders need information in this atom to operate correctly. Such
 * is the case with SVQ3. In order to get the best use out of this decoder,
 * the calling app must make the SVQ3 ImageDescription atom available
30 31
 * via the AVCodecContext's extradata[_size] field:
 *
32
 * AVCodecContext.extradata = pointer to ImageDescription, first characters
33
 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34 35
 * AVCodecContext.extradata_size = size of ImageDescription atom memory
 * buffer (which will be the same as the ImageDescription atom size field
36 37 38 39 40
 * from the QT file, minus 4 bytes since the length is missing)
 *
 * You will know you have these parameters passed correctly when the decoder
 * correctly decodes this file:
 *  ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41
 */
42

43 44 45 46 47
/**
 * @file svq3.c
 * svq3 decoder.
 */

48 49
#define FULLPEL_MODE  1
#define HALFPEL_MODE  2
Michael Niedermayer's avatar
Michael Niedermayer committed
50
#define THIRDPEL_MODE 3
51
#define PREDICT_MODE  4
52

Michael Niedermayer's avatar
Michael Niedermayer committed
53 54 55 56 57 58
/* dual scan (from some older h264 draft)
 o-->o-->o   o
         |  /|
 o   o   o / o
 | / |   |/  |
 o   o   o   o
59
   /
Michael Niedermayer's avatar
Michael Niedermayer committed
60 61
 o-->o-->o-->o
*/
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
static const uint8_t svq3_scan[16]={
 0+0*4, 1+0*4, 2+0*4, 2+1*4,
 2+2*4, 3+0*4, 3+1*4, 3+2*4,
 0+1*4, 0+2*4, 1+1*4, 1+2*4,
 0+3*4, 1+3*4, 2+3*4, 3+3*4,
};

static const uint8_t svq3_pred_0[25][2] = {
  { 0, 0 },
  { 1, 0 }, { 0, 1 },
  { 0, 2 }, { 1, 1 }, { 2, 0 },
  { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
  { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
  { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
  { 2, 4 }, { 3, 3 }, { 4, 2 },
  { 4, 3 }, { 3, 4 },
  { 4, 4 }
};

static const int8_t svq3_pred_1[6][6][5] = {
  { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
    { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
  { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
    { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
  { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
    { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
  { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
    { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
  { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
    { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
  { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
    { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
};

static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
    { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
  { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
    { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
};

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


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

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

        temp[4*i+0]= z0+z3;
        temp[4*i+1]= z1+z2;
        temp[4*i+2]= z1-z2;
        temp[4*i+3]= z0-z3;
    }

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

        block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
        block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
        block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
        block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
    }
}
#undef stride

static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
    const int qmul= svq3_dequant_coeff[qp];
    int i;
150
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183

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

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

        block[0 + 4*i]= z0 + z3;
        block[1 + 4*i]= z1 + z2;
        block[2 + 4*i]= z1 - z2;
        block[3 + 4*i]= z0 - z3;
    }

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

        dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
        dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
        dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
        dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
    }
}

static void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
184 185
    LOAD_TOP_EDGE
    LOAD_LEFT_EDGE
186 187
    const av_unused int unu0= t0;
    const av_unused int unu1= l0;
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204

    src[0+0*stride]=(l1 + t1)>>1;
    src[1+0*stride]=
    src[0+1*stride]=(l2 + t2)>>1;
    src[2+0*stride]=
    src[1+1*stride]=
    src[0+2*stride]=
    src[3+0*stride]=
    src[2+1*stride]=
    src[1+2*stride]=
    src[0+3*stride]=
    src[3+1*stride]=
    src[2+2*stride]=
    src[1+3*stride]=
    src[3+2*stride]=
    src[2+3*stride]=
    src[3+3*stride]=(l3 + t3)>>1;
205
}
206 207 208 209 210 211

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

static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
212
                                     int index, const int type) {
213 214 215 216 217 218 219 220 221 222 223 224

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

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

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

      if (vlc == INVALID_VLC)
225
        return -1;
226 227 228 229 230

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

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

      if ((index += run) >= limit)
255
        return -1;
256 257 258 259 260 261 262 263 264 265 266 267

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

    if (type != 2) {
      break;
    }
  }

  return 0;
}

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
278 279
  mx += x;
  my += y;
280

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

    if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
      emu = 1;
    }

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

  /* form component predictions */
  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 300
    src = s->edge_emu_buffer;
  }
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 308
    mx     = (mx + (mx < (int) x)) >> 1;
    my     = (my + (my < (int) y)) >> 1;
309 310
    width  = (width  >> 1);
    height = (height >> 1);
311
    blocksize++;
312 313 314

    for (i=1; i < 3; i++) {
      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 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {

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

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

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

        if (dir == 0) {
          mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
          my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
        } else {
          mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
          my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
        }
361 362 363
      }

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

      /* get (optional) motion vector differential */
      if (mode == PREDICT_MODE) {
369
        dx = dy = 0;
370
      } else {
371 372
        dy = svq3_get_se_golomb (&s->gb);
        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 377
          return -1;
        }
378 379 380 381
      }

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

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

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

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

      /* update mv_cache */
      if (mode != PREDICT_MODE) {
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
        int32_t mv = pack16to32(mx,my);

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

          if (part_width == 8 && j < 8) {
            *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
          }
        }
        if (part_width == 8 && j < 8) {
          *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
        }
        if (part_width == 4 || part_height == 4) {
          *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
        }
426 427 428 429 430 431 432 433 434 435
      }

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

  return 0;
}

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

445 446 447
  h->top_samples_available        = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
  h->left_samples_available        = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
  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 452
      svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);

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

      mb_type = MB_TYPE_16x16;
    }
467
  } else if (mb_type < 8) {     /* INTER */
468
    if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
Michael Niedermayer's avatar
Michael Niedermayer committed
469
      mode = THIRDPEL_MODE;
470
    } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
Michael Niedermayer's avatar
Michael Niedermayer committed
471
      mode = HALFPEL_MODE;
472
    } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
473
      mode = FULLPEL_MODE;
474 475 476
    }

    /* fill caches */
477
    /* note ref_cache should contain here:
Michael Niedermayer's avatar
Michael Niedermayer committed
478 479 480 481 482 483
        ????????
        ???11111
        N??11111
        N??11111
        N??11111
    */
484

485 486
    for (m=0; m < 2; m++) {
      if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
487 488 489
        for (i=0; i < 4; i++) {
          *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
        }
490
      } else {
491 492 493
        for (i=0; i < 4; i++) {
          *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
        }
494
      }
495
      if (s->mb_y > 0) {
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
        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));
        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);

        if (s->mb_x < (s->mb_width - 1)) {
          *(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];
          h->ref_cache[m][scan8[0] + 4 - 1*8] =
                  (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
                   h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
        }else
          h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
        if (s->mb_x > 0) {
          *(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];
          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;
        }else
          h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
Michael Niedermayer's avatar
Michael Niedermayer committed
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 521
      if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
        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 528 529
        for (i=0; i < 4; i++) {
          memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
        }
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 536 537
        for (i=0; i < 4; i++) {
          memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
        }
538
      }
539 540 541
    }

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

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

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

565 566
      /* decode prediction codes for luma blocks */
      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 575
        left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
        top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
576

577 578
        left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
        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 594 595 596 597 598 599 600 601 602 603 604 605

    if (mb_type == 8) {
      check_intra4x4_pred_mode (h);

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

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

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

612 613
    if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
      av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
614
      return -1;
615
    }
616 617 618 619 620 621 622 623 624

    cbp = i_mb_type_info[mb_type - 8].cbp;
    mb_type = MB_TYPE_INTRA16x16;
  }

  if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
    for (i=0; i < 4; i++) {
      memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
    }
625 626
    if (s->pict_type == B_TYPE) {
      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 632 633
  }
  if (!IS_INTRA4x4(mb_type)) {
    memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
  }
634
  if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
Michael Niedermayer's avatar
Michael Niedermayer committed
635 636
    memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
    s->dsp.clear_blocks(h->mb);
637 638
  }

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

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

650 651
    if (s->qscale > 31){
      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 657
    if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
      av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
658
      return -1;
659
    }
660 661
  }

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

    for (i=0; i < 4; i++) {
      if ((cbp & (1 << i))) {
668 669 670
        for (j=0; j < 4; j++) {
          k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
          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 681
      }
    }

    if ((cbp & 0x30)) {
      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 690
        for (i=0; i < 8; i++) {
          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 702 703 704 705 706 707 708 709
      }
    }
  }

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

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

  return 0;
}

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

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

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

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

726 727
    if (h->next_slice_index > s->gb.size_in_bits){
      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 737 738 739
             &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
    }
  }

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

  h->slice_type = golomb_to_pict_type[i];

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

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

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

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

766 767
  skip_bits1 (&s->gb);
  skip_bits (&s->gb, 2);
768 769

  while (get_bits1 (&s->gb)) {
770
    skip_bits (&s->gb, 8);
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
  }

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

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

  return 0;
}

789
static int svq3_decode_frame (AVCodecContext *avctx,
790 791
                              void *data, int *data_size,
                              uint8_t *buf, int buf_size) {
792 793
  MpegEncContext *const s = avctx->priv_data;
  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 801
  s->unrestricted_mv = 1;

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

    if (MPV_common_init (s) < 0)
      return -1;

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

817 818
    alloc_tables (h);

819 820 821 822 823 824 825
    /* prowl for the "SEQH" marker in the extradata */
    extradata = (unsigned char *)avctx->extradata;
    for (m = 0; m < avctx->extradata_size; m++) {
      if (!memcmp (extradata, "SEQH", 4))
        break;
      extradata++;
    }
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 836
      /* 'frame size code' and optional 'width, height' */
      if (get_bits (&gb, 3) == 7) {
837 838
        skip_bits (&gb, 12);
        skip_bits (&gb, 12);
839 840
      }

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

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

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

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

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

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

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

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

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

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
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",
Michael Niedermayer's avatar
Michael Niedermayer committed
885
      av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
Michael Niedermayer's avatar
Michael Niedermayer committed
886 887 888
      s->adaptive_quant, s->qscale
      );
  }
889

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

Diego Biurrun's avatar
Diego Biurrun committed
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;
Diego Biurrun's avatar
Diego Biurrun committed
896
  /* Skip B-frames if we are in a hurry. */
897
  if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
Diego Biurrun's avatar
Diego Biurrun committed
898
  /* Skip everything if we are in a hurry >= 5. */
899
  if (avctx->hurry_up >= 5) return 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
900 901 902 903
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
     || avctx->skip_frame >= AVDISCARD_ALL)
      return 0;
904 905 906 907 908 909 910

  if (s->next_p_frame_damaged) {
    if (s->pict_type == B_TYPE)
      return 0;
    else
      s->next_p_frame_damaged = 0;
  }
911

912 913
  if (frame_start (h) < 0)
    return -1;
914

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

    if (h->frame_num_offset < 0) {
      h->frame_num_offset += 256;
    }
    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 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
      return -1;
    }
  } else {
    h->prev_frame_num = h->frame_num;
    h->frame_num = h->slice_num;
    h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);

    if (h->prev_frame_num_offset < 0) {
      h->prev_frame_num_offset += 256;
    }
  }

  for(m=0; m<2; m++){
    int i;
    for(i=0; i<4; i++){
      int j;
      for(j=-1; j<4; j++)
940
        h->ref_cache[m][scan8[0] + 8*i + j]= 1;
941 942
      if(i<3)
        h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
943
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
944
  }
945

946 947
  for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
    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 953
        skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
        s->gb.size_in_bits = 8*buf_size;
954

955 956
        if (svq3_decode_slice_header (h))
          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 970
        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
        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 979
        s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
                        (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 989 990 991 992 993 994 995

  if (s->pict_type == B_TYPE || s->low_delay) {
    *(AVFrame *) data = *(AVFrame *) &s->current_picture;
  } else {
    *(AVFrame *) data = *(AVFrame *) &s->last_picture;
  }

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

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

1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
  return buf_size;
}


AVCodec svq3_decoder = {
    "svq3",
    CODEC_TYPE_VIDEO,
    CODEC_ID_SVQ3,
    sizeof(H264Context),
    decode_init,
    NULL,
    decode_end,
    svq3_decode_frame,
1014
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1015
};