getpic.cc

ac3的解码程序

      if (SNRMBAinc==1){     /* not skipped */
        macroblock_modes(&SNRmb_type, &dummy, &dummy,
          &dummy, &dummy, &dummy, &dummy, &dummy,
          &SNRdct_type);

        if (SNRmb_type & MB_PATTERN) dct_type = SNRdct_type;

        if (SNRmb_type & MB_QUANT){
          qs = input->getbits(5);
          quant_scale = qscale_type ? non_linear_mquant_table[qs] : qs<<1;
        }

        /* macroblock_pattern */
        if (SNRmb_type & MB_PATTERN)
        {
          SNRcbp = getCBP();

          if (chroma_format==CHROMA422)
            SNRcbp = (SNRcbp<<2) | input->getbits(2); /* coded_block_pattern_1 */
          else if (chroma_format==CHROMA444)
            SNRcbp = (SNRcbp<<6) | input->getbits(6); /* coded_block_pattern_2 */
        }
        else
          SNRcbp = 0;

        /* decode blocks */
        clearblock(0,blk_cnt);
        for (comp=0; comp<blk_cnt; comp++)
        {

          if (SNRcbp & (1<<(blk_cnt-1-comp)))
            getmpg2interblock(comp);
        }
      }
      else /* SNRMBAinc!=1: skipped macroblock */
      {
        clearblock(0,blk_cnt);
      }

//      ld = &base;
    }
#endif

    /* pixel coordinates of top left corner of current macroblock */
    bx = 16*(MBA%mb_width);
    by = 16*(MBA/mb_width);

    /* motion compensation */
    if (!(mb_type & MB_INTRA))
      reconstruct(bx,by,mb_type,motion_type,PMV,mv_field_sel,dmvector,
                  stwtype);

#ifdef ENHANCEMENT
    if (scalable_mode==SC_DP) ld = &base;
#endif

    /* copy or add block data into picture */
    for (comp=0; comp<blk_cnt; comp++){
      if ((cbp|SNRcbp) & (1<<(blk_cnt-1-comp))){
#ifdef ENHANCEMENT
        if (twostreams && enhan.scalable_mode==SC_SNR &&
            SNRcbp & (1<<(blk_cnt-1-comp)))
          sumblock(comp); /* add SNR enhancement layer data to base layer */
#endif
        /* inverse DCT */
//        if (sparse[comp])
//           j_rev_dct_sparse(block[comp]);
//        else {
#ifdef HAVE_MMX
  	  IDCT_mmx(block[comp]);
#else
          idct->conversion(block[comp]);
#endif
//        }
        addblock(comp,bx,by,dct_type,(mb_type & MB_INTRA)==0);
      }
    }

    /* advance to next macroblock */
    MBA++;
    MBAinc--;

#ifdef ENHANCEMENT
    if (twostreams && enhan.scalable_mode==SC_SNR){
      SNRMBA++;
      SNRMBAinc--;
    }
#endif
  }
}


void LayerData::macroblock_modes(int *pmb_type, int *pstwtype, int *pstwclass,
  int *pmotion_type, int *pmv_count, int *pmv_format, int *pdmv, int *pmvscale,
  int *pdct_type)
{
  int mb_type;
  int stwtype, stwcode, stwclass;
  int motion_type(0), mv_count, mv_format, dmv, mvscale;
  int dct_type;
  static unsigned char stwc_table[3][4]
    = { {6,3,7,4}, {2,1,5,4}, {2,5,7,4} };
  static unsigned char stwclass_table[9]
    = {0, 1, 2, 1, 1, 2, 3, 3, 4};

  /* get macroblock_type */
  mb_type = getMBtype();

  if (fault) return;

  /* get spatial_temporal_weight_code */
  if (mb_type & MB_WEIGHT)
  {
    if (stwc_table_index==0)
      stwtype = 4;
    else
    {
      stwcode = input->getbits(2);
      stwtype = stwc_table[stwc_table_index-1][stwcode];
    }
  }
  else
    stwtype = (mb_type & MB_CLASS4) ? 8 : 0;

  /* derive spatial_temporal_weight_class (Table 7-18) */
  stwclass = stwclass_table[stwtype];

  /* get frame/field motion type */
  if (mb_type & (MB_FORWARD|MB_BACKWARD)){
    if (pict_struct==FRAME_PICTURE){ /* frame_motion_type */
      motion_type = frame_pred_dct ? MC_FRAME : input->getbits(2);
#ifdef TRACE
      if (!frame_pred_dct && trace){
        printf("frame_motion_type (");
        printbits(motion_type,2,2);
        printf("): %s\n",motion_type==MC_FIELD?"Field":
                         motion_type==MC_FRAME?"Frame":
                         motion_type==MC_DMV?"Dual_Prime":"Invalid");
      }
#endif
    }
    else { /* field_motion_type */
      motion_type = input->getbits(2);
#ifdef TRACE
      if (trace){
        printf("field_motion_type (");
        printbits(motion_type,2,2);
        printf("): %s\n",motion_type==MC_FIELD?"Field":
                         motion_type==MC_16X8?"16x8 MC":
                         motion_type==MC_DMV?"Dual_Prime":"Invalid");
      }
#endif
    }
  }
  else if ((mb_type & MB_INTRA) && conceal_mv)
  {
    /* concealment motion vectors */
    motion_type = (pict_struct==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
  }

  /* derive mv_count, mv_format and dmv, (table 6-17, 6-18) */
  if (pict_struct==FRAME_PICTURE)
  {
    mv_count = (motion_type==MC_FIELD && stwclass<2) ? 2 : 1;
    mv_format = (motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
  }
  else
  {
    mv_count = (motion_type==MC_16X8) ? 2 : 1;
    mv_format = MV_FIELD;
  }

  dmv = (motion_type==MC_DMV); /* dual prime */

  /* field mv predictions in frame pictures have to be scaled */
  mvscale = ((mv_format==MV_FIELD) && (pict_struct==FRAME_PICTURE));

  /* get dct_type (frame DCT / field DCT) */
  dct_type = (pict_struct==FRAME_PICTURE)
             && (!frame_pred_dct)
             && (mb_type & (MB_PATTERN|MB_INTRA))
             ? input->getbits(1)
             : 0;

#ifdef TRACE
  if (trace  && (pict_struct==FRAME_PICTURE)
             && (!frame_pred_dct)
             && (mb_type & (MB_PATTERN|MB_INTRA)))
    printf("dct_type (%d): %s\n",dct_type,dct_type?"Field":"Frame");
#endif

  /* return values */
  *pmb_type = mb_type;
  *pstwtype = stwtype;
  *pstwclass = stwclass;
  *pmotion_type = motion_type;
  *pmv_count = mv_count;
  *pmv_format = mv_format;
  *pdmv = dmv;
  *pmvscale = mvscale;
  *pdct_type = dct_type;
}


/* set block to zero */
void LayerData::clearblock(int comp,int size){
  sparse[comp] = 1;
  memset(block[comp],0,sizeof(short)*64*size);
}


#ifdef ENHANCEMENT
/* add SNR enhancement layer block data to base layer */

void LayerData::sumblock(int comp){
  short *bp1, *bp2;

  bp1 = block[comp];
#ifdef ENHANCEMANT
  bp2 = enhan.block[comp];
#endif
  for (int i=0; i<64; i++) *bp1++ += *bp2++;
}
#endif

/* limit coefficients to -2048..2047 */

/* move/add 8x8-Block from block[comp] to refframe */

void LayerData::addblock(int comp, int bx, int by, int dct_type, int addflag){
  int cc,i, iincr;
  unsigned char *rfp;
  short *bp;
  int spar = sparse[comp];
#ifndef HAVE_MMX
  unsigned char *clp2=display->getClpTable();

  if (!addflag) clp2 += 128;
#endif

  cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */

  if (cc==0){   /* luminance */

    if (pict_struct==FRAME_PICTURE)
      if (dct_type){
        /* field DCT coding */
        rfp = newframe[0]
              + coded_picture_width*(by+((comp&2)>>1)) + bx + ((comp&1)<<3);
        iincr = (coded_picture_width<<1);
      }
      else{
        /* frame DCT coding */
        rfp = newframe[0]
              + coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
        iincr = coded_picture_width;
      }
    else {
      /* field picture */
      rfp = newframe[0]
            + (coded_picture_width<<1)*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
      iincr = (coded_picture_width<<1);
    }
  }
  else {
    /* chrominance */

    /* scale coordinates */
    if (chroma_format!=CHROMA444)  bx >>= 1;
    if (chroma_format==CHROMA420)  by >>= 1;
    if (pict_struct==FRAME_PICTURE){
      if (dct_type && (chroma_format!=CHROMA420)){
        /* field DCT coding */
        rfp = newframe[cc]
              + chrom_width*(by+((comp&2)>>1)) + bx + (comp&8);
        iincr = (chrom_width<<1);
      }
      else {
        /* frame DCT coding */
        rfp = newframe[cc]
              + chrom_width*(by+((comp&2)<<2)) + bx + (comp&8);
        iincr = chrom_width;
      }
    }
    else {
      /* field picture */
      rfp = newframe[cc]
            + (chrom_width<<1)*(by+((comp&2)<<2)) + bx + (comp&8);
      iincr = (chrom_width<<1);
    }
  }

  bp = block[comp];

  if (addflag) {
#ifdef HAVE_MMX
    if (spar) {
       __asm__ __volatile__(
            "movq       (%2),%%mm6\n"  /* 4 blockvals */
            "pxor       %%mm4,%%mm4\n"
            "punpcklwd  %%mm6,%%mm6\n"
            "punpcklwd  %%mm6,%%mm6\n"
            ".align 8\n"
            "1:"
                "movq       (%1),  %%mm0\n"     /* 8 rindex1 */
                "movq       %%mm0, %%mm2\n"
                "punpcklbw  %%mm4, %%mm0\n"
                "punpckhbw  %%mm4, %%mm2\n"
                "paddw      %%mm6, %%mm0\n"
                "paddw      %%mm6, %%mm2\n"

                "packuswb   %%mm2, %%mm0\n"
                "movq       %%mm0, (%1)\n"

                "leal       (%1,%3), %1\n"
              "loop       1b\n"
              :              /* scr   dest */
              : "c" (8),"r" (rfp), "r" (bp), "r" (iincr)
                );
    }
    else {
       __asm__ __volatile__(
         "pxor    %%mm4,%%mm4\n"

         ".align 8\n"
         "1:"
           "movq       (%2), %%mm0\n"   /* 8 rfp 0 1 2 3 4 5 6 7*/
           "movq       (%1), %%mm6\n"   /* 4 blockvals 0 1 2 3 */

           "movq       %%mm0, %%mm2\n"
           "movq       8(%1), %%mm5\n"  /* 4 blockvals 0 1 2 3 */
           "punpcklbw  %%mm4, %%mm0\n"  /* 0 2 4 6 */
           "punpckhbw  %%mm4, %%mm2\n"  /* 1 3 5 7 */

           "paddw      %%mm6, %%mm0\n"
           "paddw      %%mm5, %%mm2\n"
           "packuswb   %%mm2, %%mm0\n"

           "addl       $16, %1\n"
           "movq       %%mm0, (%2)\n"

           "leal       (%2,%3), %2\n"
         "loop       1b\n"
         :              /* scr   dest */
         : "c" (8),"r" (bp), "r" (rfp), "r" (iincr)
       );

//      add_block_mmx(rfp,bp,iincr);
    }
#else
    for (i=0; i<8; i++){
      rfp[0] = clp2[bp[0] + rfp[0]];
      rfp[1] = clp2[bp[1] + rfp[1]];
      rfp[2] = clp2[bp[2] + rfp[2]];
      rfp[3] = clp2[bp[3] + rfp[3]];
      rfp[4] = clp2[bp[4] + rfp[4]];
      rfp[5] = clp2[bp[5] + rfp[5]];
      rfp[6] = clp2[bp[6] + rfp[6]];
      rfp[7] = clp2[bp[7] + rfp[7]];
      rfp+= iincr;
      bp += 8;
    }
#endif
  }
  else {
#ifdef HAVE_MMX
     if (spar) {
            __asm__ __volatile__(
            "movd       (%2),           %%mm0\n"                // " 0 0 0  v1"
            "punpcklwd  %%mm0,          %%mm0\n"    // " 0 0 v1 v1"
            "punpcklwd  %%mm0,          %%mm0\n"
            "paddw      MMX_128,        %%mm0\n"
            "packuswb   %%mm0,          %%mm0\n"
            "leal       (%0,%1,2),      %%eax\n"

            "movq        %%mm0,         (%0, %1)\n"
            "movq        %%mm0,         (%%eax)\n"
            "leal        (%%eax,%1,2),  %0\n"
            "movq        %%mm0,         (%%eax, %1)\n"

            "movq        %%mm0,         (%0)\n"
            "leal        (%0,%1,2),     %%eax\n"
            "movq        %%mm0,         (%0, %1)\n"

            "movq        %%mm0,         (%%eax)\n"
            "movq        %%mm0,         (%%eax, %1)\n"
            :
            : "D" (rfp), "c" (iincr), "b" (bp)
            : "eax");
    }
    else {

       __asm__ __volatile__(
            "movq        MMX_128,%%mm4\n"
            ".align 8\n"
            "1:"
              "movq      (%1),   %%mm0\n"
              "movq      8(%1),  %%mm1\n"
              "paddw     %%mm4,  %%mm0\n"

              "movq      16(%1), %%mm2\n"
              "paddw     %%mm4,  %%mm1\n"

              "movq      24(%1), %%mm3\n"
              "paddw     %%mm4,  %%mm2\n"

              "packuswb  %%mm1,  %%mm0\n"
              "paddw     %%mm4,  %%mm3\n"

              "addl $32, %1\n"
              "packuswb  %%mm3,  %%mm2\n"

              "movq   %%mm0, (%2)\n"

              "movq   %%mm2, (%2,%3)\n"

              "leal       (%2,%3,2), %2\n"
            "loop       1b\n"
            :
            : "c" (4), "r" (bp), "r" (rfp), "r" (iincr)
        );

//      set_block_mmx(rfp,bp,iincr);
    }
#else
    for (i=0; i<8; i++){
      rfp[0] = clp2[bp[0]];
      rfp[1] = clp2[bp[1]];
      rfp[2] = clp2[bp[2]];
      rfp[3] = clp2[bp[3]];
      rfp[4] = clp2[bp[4]];
      rfp[5] = clp2[bp[5]];
      rfp[6] = clp2[bp[6]];
      rfp[7] = clp2[bp[7]];
      rfp+= iincr;
      bp += 8;
    }
#endif
  }
}