scal_dec_frame.c

C写的MPEG4音频源代码(G.723/G.729)

              int          *diff_control, 
              Info         *p_sbinfo,
              int           numDiffBands,
              int        shortDiffWidth,
              int           is_decoder
              )
{
  int sbk, diffBand,x;
  int dc_decoded[8][128];
  short diffBandWidth[200];
  double doubleZero=0.0;
  int numDiffBandsPerSbk;
  int g;

  if (p_sbinfo->islong){
    numDiffBandsPerSbk=numDiffBands;
    diffBandWidth[0]= p_sbinfo->bk_sfb_top[0];  
    for (x=1;x< p_sbinfo->sfb_per_bk;x++){
      if  (p_sbinfo->bk_sfb_top[x]==0)
        CommonExit(-1,"\ninternal FSS error");
      diffBandWidth[x]= p_sbinfo->bk_sfb_top[x] - p_sbinfo->bk_sfb_top[x-1];
    }
  } else {
    numDiffBandsPerSbk=1;
    diffBandWidth[0]= shortDiffWidth;
  }

  g=0;
  for( sbk=0; sbk<p_sbinfo->nsbk; sbk++ ) {
    for( diffBand=0; diffBand<numDiffBandsPerSbk; diffBand++ ) {
      dc_decoded[sbk][diffBand] = diff_control[g];
      g++;
    }
  }

  for( sbk=0; sbk<p_sbinfo->nsbk; sbk++ ) {
    int offset = sbk*p_sbinfo->bins_per_sbk[sbk];
    int sum    = 0;
    for( diffBand=0; diffBand<numDiffBandsPerSbk; diffBand++ ) {
      if( dc_decoded[sbk][diffBand] == 0 ) {
        if( is_decoder ) {
          vadd ( &p_core[offset], &p_rest[offset], &p_out[offset], 1, 1, 1, diffBandWidth[diffBand] ); 
        }
      } else {
        vcopy( &p_rest[offset], &p_out[offset], 1, 1, diffBandWidth[diffBand] ); 
        if( !is_decoder ) {
          vcopy( &doubleZero , &p_core[offset], 0, 1, diffBandWidth[diffBand] ); 
        }
      }
      offset += diffBandWidth[diffBand];
      sum    += diffBandWidth[diffBand];
    }
    vcopy( &p_rest[offset], &p_out[offset], 1, 1, p_sbinfo->bins_per_sbk[sbk]-sum ); 
    vcopy( &doubleZero ,   &p_core[offset], 0, 1, p_sbinfo->bins_per_sbk[sbk]-sum ); 
  }
}

static void FSSwitchSt( double  p_core[],/* bands of this spec is mult by 2 if ms is off */ 
                        double  p_rest[], 
                        double  p_out[], 
                        int*    diff_control, 
                        int     diffContrBands,
                        Info*   p_sbinfo,
                        int     msMask[8][60],
                        int     channel )
{
  int sbk, sfb;
  int dc_decoded[8][128];
  short sfbWidth[200];
  double doubleZero=0.0;

  sfbWidth[0]= p_sbinfo->sbk_sfb_top[0][0];  
  for (sfb=1;sfb< p_sbinfo->sfb_per_sbk[0];sfb++){
    if  (p_sbinfo->sbk_sfb_top[0][sfb]==0)
      CommonExit(-1,"\ninternal FSS error");
    sfbWidth[sfb]= p_sbinfo->sbk_sfb_top[0][sfb] - p_sbinfo->sbk_sfb_top[0][sfb-1];
  }
  
  if (p_sbinfo->islong){
    for( sfb=0; sfb<p_sbinfo->sfb_per_sbk[0]; sfb++ ) {
      if (sfb<diffContrBands) {
        dc_decoded[0][sfb] = diff_control[sfb];
      }else {
        dc_decoded[0][sfb] =1;
      }
    }
  } else {
    /* see "correction  for short" */
    for( sbk=0; sbk<p_sbinfo->nsbk; sbk++ ) {
      for( sfb=0; sfb<p_sbinfo->sfb_per_sbk[0]; sfb++ ) {
        if (sfb<diffContrBands) {
          if ((msMask[sbk][sfb]==1)&&(channel==1)){
            /* side channel never uses diffencoding */
            dc_decoded[sbk][sfb] = 1;
          } else {                          
            if ((msMask[sbk][sfb]==1)&&(channel==0)) {
              /* M channel : always diff encoding if there is no celp or tvq core */
              dc_decoded[sbk][sfb] = 0;
            } else {
              /* L,R channel : use diff flag from bitstream */
              dc_decoded[sbk][sfb] = diff_control[sbk];
            }
          }
        }else {
          dc_decoded[sbk][sfb] =1;
        }
      }
    }
  }

  for( sbk=0; sbk<p_sbinfo->nsbk; sbk++ ) {
    int offset = sbk*p_sbinfo->bins_per_sbk[sbk];
    int sum    = 0;  
    
    for( sfb=0; sfb<p_sbinfo->sfb_per_sbk[sbk]; sfb++  ) {
      /* build combined L/R spectrum */
      if( (msMask[sbk][sfb] == 0 ) ) {
        if(  dc_decoded[sbk][sfb] == 0 ) {
          vadd ( &p_core[offset], &p_rest[offset], &p_out[offset], 1, 1, 1, sfbWidth[sfb] ); 
        } else {
          vcopy( &p_rest[offset], &p_out[offset], 1, 1, sfbWidth[sfb] ); 
        }
      } else {
      /* build combined M spectrum */
        if( channel == 0 ) {
          vadd ( &p_core[offset], &p_rest[offset], &p_out[offset], 1, 1, 1, sfbWidth[sfb] ); 
        } else {
          vcopy( &p_rest[offset], &p_out[offset], 1, 1, sfbWidth[sfb] ); 
        }
      }
      offset += sfbWidth[sfb];
      sum    += sfbWidth[sfb];
    }
    vcopy( &p_rest[offset], &p_out[offset], 1, 1, p_sbinfo->bins_per_sbk[sbk]-sum ); 
    vcopy( &doubleZero ,   &p_core[offset], 0, 1, p_sbinfo->bins_per_sbk[sbk]-sum ); 
  }
}

static void FSSwitchStwCore( double  p_core[],/* bands of this spec is mult by 2 if ms is off */ 
                        double  p_rest[], 
                        double  p_out[], 
                        int*    diff_control, 
                        int*    diff_controlLR, 
                        int     diffContrBands,
                        Info*   p_sbinfo,
                        int     msMask[8][60],
                        int     channel )
{
  int sbk, sfb;
  int dc_decoded[8][128];
  short sfbWidth[200];
  double doubleZero=0.0;

  sfbWidth[0]= p_sbinfo->sbk_sfb_top[0][0];  
  for (sfb=1;sfb< p_sbinfo->sfb_per_sbk[0];sfb++){
    if  (p_sbinfo->sbk_sfb_top[0][sfb]==0)
      CommonExit(-1,"\ninternal FSS error");
    sfbWidth[sfb]= p_sbinfo->sbk_sfb_top[0][sfb] - p_sbinfo->sbk_sfb_top[0][sfb-1];
  }
  
  if (p_sbinfo->islong){
    for( sfb=0; sfb<p_sbinfo->sfb_per_sbk[0]; sfb++ ) {
      if (sfb<diffContrBands) {
        dc_decoded[0][sfb] = diff_controlLR[sfb]; 
      }else {
        dc_decoded[0][sfb] =1;
      }
    }
  } else {
    diffContrBands=120; /* some huge number , actually wrong, but corrected below: */
    /* see "correction  for short" */
    for( sbk=0; sbk<p_sbinfo->nsbk; sbk++ ) {
      for( sfb=0; sfb<p_sbinfo->sfb_per_sbk[0]; sfb++ ) {
        if (sfb<diffContrBands) {
          if ((msMask[sbk][sfb]==1)&&(channel==1)){
            /* side channel never uses diffencoding */
            dc_decoded[sbk][sfb] = 1;
          } else {                          
            /* L,R or M channel : use diff flag from bitstream */
            if ((msMask[sbk][sfb]==1)&&(channel==0)) {
              /* M channel: */ 
              dc_decoded[sbk][sfb] = diff_control[sbk];
            } else {
              /* L and R channel */
              dc_decoded[sbk][sfb] = diff_controlLR[sbk];
            }
          }
        }else {
          /* all above lower layer bandwith does not use diff spec */
          dc_decoded[sbk][sfb] =1;
        }
      }
    }
  }
  for( sbk=0; sbk<p_sbinfo->nsbk; sbk++ ) {
    int offset = sbk*p_sbinfo->bins_per_sbk[sbk];
    int sum    = 0;  
    
    for( sfb=0; sfb<p_sbinfo->sfb_per_sbk[sbk]; sfb++  ) {
      /* build combined L/R spectrum */
      if( (msMask[sbk][sfb] == 0 ) ) {
        if(  dc_decoded[sbk][sfb] == 0 ) {
          vadd ( &p_core[offset], &p_rest[offset], &p_out[offset], 1, 1, 1, sfbWidth[sfb] ); 
        } else {
          vcopy( &p_rest[offset], &p_out[offset], 1, 1, sfbWidth[sfb] ); 
        }
      }      else  {
        /* build combined M spectrum */
        if( (channel == 0) && (dc_decoded[sbk][sfb] == 0)) {
          vadd ( &p_core[offset], &p_rest[offset], &p_out[offset], 1, 1, 1, sfbWidth[sfb] ); 
        } else {
          vcopy( &p_rest[offset], &p_out[offset], 1, 1, sfbWidth[sfb] ); 
        }
      }
      offset += sfbWidth[sfb];
      sum    += sfbWidth[sfb];
    }
    vcopy( &p_rest[offset], &p_out[offset], 1, 1, p_sbinfo->bins_per_sbk[sbk]-sum ); 
    vcopy( &doubleZero ,   &p_core[offset], 0, 1, p_sbinfo->bins_per_sbk[sbk]-sum ); 
  }
  /*correction  for short: diff encoding only up top diff_Short_lines see Table 6.12 */
  if (p_sbinfo->islong==0){
    for( sbk=0; sbk<p_sbinfo->nsbk; sbk++ ) {
      int offset = sbk*p_sbinfo->bins_per_sbk[sbk]+p_sbinfo->shortFssWidth;
      int count = p_sbinfo->bins_per_sbk[sbk]-p_sbinfo->shortFssWidth;
      vcopy( &p_rest[offset], &p_out[offset], 1, 1, count );      
    }
  }
}


static void  decodeDiffCtrl(
                     BsBitStream * fixed_stream, 
                     int diffControl[ ],
                     int *decodedBits, 
                     int fssGroups)
{
  unsigned long int   ultmp, fssIdx, diffControlTmp;
  int fssG,sfb;
  for (sfb=0;sfb<60;sfb++){
    diffControl[sfb]=0;
  }
  sfb=0;
  for (fssG=0;fssG<fssGroups;fssG++){
    diffControlTmp=0;
    BsGetBit( fixed_stream, &ultmp, 2 );
    *decodedBits += 2;
    fssIdx=ultmp;
    switch (ultmp){
    case 0 : diffControlTmp |=0;
      break;
    case 1 : diffControlTmp |=15;
      break;
    default :
      BsGetBit( fixed_stream, &ultmp, 2 );
      *decodedBits += 2;
      fssIdx= (fssIdx<<2)| ultmp;
      switch (fssIdx){
      case  8:  diffControlTmp |=7;
        break;
      case  9:  diffControlTmp |=8;
        break;
      default:
        BsGetBit( fixed_stream, &ultmp, 1 );
        *decodedBits += 1;
        fssIdx= (fssIdx<<1)| ultmp;
        switch (fssIdx) {
        case 20:
        case 21:
        case 22:
        case 23:
        case 24:
        case 25:
          diffControlTmp |= (fssIdx-19);
          break;
        case 26:
        case 27:
        case 28:
        case 29:
        case 30:
        case 31:
          diffControlTmp |= (fssIdx-17);
          break;
        default:
          CommonExit(-1,"\nfssdecode error");
        }
        break;
      }
    }
    diffControl[sfb+3]= ((diffControlTmp & 0x1)!=0);
    diffControl[sfb+2]= ((diffControlTmp & 0x2)!=0);
    diffControl[sfb+1]= ((diffControlTmp & 0x4)!=0);
    diffControl[sfb+0]= ((diffControlTmp & 0x8)!=0);
    sfb +=4;      
  }
}

static int decode_grouping( int grouping, short region_len[] )
{
  int i, rlen, mask;

  int no_short_reg = 0;

  mask = 1 << ( 8-2 );
  rlen = 1;  /* min. length of first group is '1' */
  for( i = 1; i<8; i++ ) {
    if( (grouping & mask) == 0) {
      *region_len++ = rlen;
      no_short_reg++;
      rlen = 0;
    }
    rlen++;
    mask >>= 1;
  }
  *region_len = rlen;
  no_short_reg++;

  return( no_short_reg );
}






static void getModeFromOD(OBJECT_DESCRIPTOR *od,int *lowRateChannelPresent,
                   int *layNumChan,
                   int *lastAacLay,
                   int *firstStLay, 
                   enum CORE_CODEC* coreCoderIndex,
                   int *commonWindow)
{
  
  int nEsNumber, i, aac=0, nAacLay = 0;
  int nLowRateChan = 0;
  int audioDecType;
  int nFirstStereo = -1;
  int tfType;
  nEsNumber   = od->streamCount.value;
  *coreCoderIndex=NO_CORE;
  for (i= 0; i< nEsNumber; i++)
    {
      audioDecType = od->ESDescriptor[i]->DecConfigDescr.audioSpecificConfig.audioDecoderType.value;
      layNumChan[i] = od->ESDescriptor[i]->DecConfigDescr.audioSpecificConfig.channelConfiguration.value;
    switch (audioDecType)
      {
      case 0:
        if (( layNumChan[i] ) == 2 && (nFirstStereo < 0))
          nFirstStereo = i;
        tfType=od->ESDescriptor[i]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.TFCodingType.value;
        switch (tfType) {
        case 0:
          nAacLay++;
          aac=1;
          break;
        case 1:
          nAacLay++;
          aac=1;
          break;
        case 2:
          nLowRateChan++;
          *coreCoderIndex=NTT_TVQ;          
          break;
        case 3:
          CommonExit(-1,"tfDecoderType not implemented");
          break;
        default :
          CommonExit(-1,"tfDecoderType not implemented");
          break;
        }          
        break;
      case 1: /* CELP core */
        nLowRateChan++;
        *coreCoderIndex=CC_CELP_MPEG4;          
        break;
      default:
        CommonExit(-1,"audioDecoderType not implemented");
        break;
      }
    switch (od->ESDescriptor[i]->DecConfigDescr.audioSpecificConfig.channelConfiguration.value ) 
      {
      case 1 :
        commonWindow[i]=0;
        break;
      case 2 :