config.c

语音压缩算法

  }
    
  cw = 0;			    /* changed later */
    
  /* front elements, center out */
  elp = &pcp->front;
  /* count number of leading SCE's */
  for (i=0, j=elp->num_ele; i<j; i++) {
    if (elp->ele_is_cpe[i])
      break;
    mip->nfsce++;
  }
  for (i=0, j=elp->num_ele; i<j; i++) {
    cpe = elp->ele_is_cpe[i];
    tag = elp->ele_tag[i];
    if (enter_chn(cpe, tag, 'f', cw, mip) < 0)
      return(-1);
  }
    
  /* side elements, left to right then front to back */
  elp = &pcp->side;
  for (i=0, j=elp->num_ele; i<j; i++) {
    cpe = elp->ele_is_cpe[i];
    tag = elp->ele_tag[i];
    if (enter_chn(cpe, tag, 's', cw, mip) < 0)
      return(-1);
  }
	  
  /* back elements, outside to center */
  elp = &pcp->back;
  for (i=0, j=elp->num_ele; i<j; i++) {
    cpe = elp->ele_is_cpe[i];
    tag = elp->ele_tag[i];
    if (enter_chn(cpe, tag, 'b', cw, mip) < 0)
      return(-1);
  }
    
  /* lfe elements */
  elp = &pcp->lfe;
  for (i=0, j=elp->num_ele; i<j; i++) {
    cpe = elp->ele_is_cpe[i];
    tag = elp->ele_tag[i];
    if (enter_chn(cpe, tag, 'l', cw, mip) < 0)
      return(-1);
  }
        
  /* coupling channel elements */
  elp = &pcp->coupling;
  for (i=0, j=elp->num_ele; i<j; i++)
    mip->cch_tag[i] = elp->ele_tag[i];
  mip->ncch = j;
    
  /* mono mixdown elements */
  mxp = &pcp->mono_mix;
  if (mxp->present) {
    fprintf(stderr,"Unanticipated mono mixdown channel\n");
    return(-1);
  }
    
  /* stereo mixdown elements */
  mxp = &pcp->stereo_mix;
  if (mxp->present) {
    fprintf(stderr,"Unanticipated stereo mixdown channel\n");
    return(-1);
  }
    
  /* matrix mixdown elements */
  mxp = &pcp->matrix_mix;
  if (mxp->present) {
    fprintf(stderr,"Unanticipated matrix mixdown channel\n");
    return(-1);
  }
    
  /* save to check future consistency */
  check_mc_info(&mc_info, 1, hEpInfo, hResilience);

  return 1;
}

/* translate prog config or default config 
 * into to multi-channel info structure
 *  returns index of channel in MC_Info
 */
int enter_chn ( int      cpe, 
                int      tag, 
                char     position, 
                int      common_window, 
                MC_Info* mip)
{
  int nch, cidx=0;
  Ch_Info *cip;

  nch = (cpe == 1) ? 2 : 1;
    
  switch (position) {
    /* use configuration already in MC_Info, but now common_window is valid */
  case 0:
    cidx = ch_index(mip, cpe, tag);
    if (common_window) {
      mip->ch_info[cidx].widx = cidx;	/* window info is left */
      mip->ch_info[cidx+1].widx = cidx;
    }
    else {
      mip->ch_info[cidx].widx = cidx;	/* each has window info */
      mip->ch_info[cidx+1].widx = cidx+1;
    }
    return cidx;
	
    /* build configuration */
  case 'f':
    if (mip->nfch + nch > FChans) {
      fprintf(stderr,"Unanticipated front channel\n");
      return -1;
    }
    if (mip->nfch == 0) {
      /* consider case of center channel */
      if (FCenter) {
        if (cpe) {
          /* has center speaker but center channel missing */
          cidx = 0 + 1;
          mip->nfch = 1 + nch;
        }
        else {
          if (mip->nfsce & 1) {
            /* has center speaker and this is center channel */
            /* odd number of leading SCE's */
            cidx = 0;
            mip->nfch = nch;
          }
          else {
            /* has center speaker but center channel missing */
            /* even number of leading SCE's */
            /* (Note that in implicit congiguration
             * channel to speaker mapping may be wrong 
             * for first block while count of SCE's prior
             * to first CPE is being make. However first block
             * is not written so it doesn't matter.
             * Second block will be correct.
             */
            cidx = 0 + 1;
            mip->nfch = 1 + nch;
          }
        }
      }
      else {
        if (cpe) {
          /* no center speaker and center channel missing */
          cidx = 0;
          mip->nfch = nch;
        }
        else {
          /* no center speaker so this is left channel */
          cidx = 0;
          mip->nfch = nch;
        }
      }
    }
    else {
      cidx = mip->nfch;
      mip->nfch += nch;
    }
    break;
  case 's':
    if (mip->nsch + nch > SChans)  {
      fprintf(stderr,"Unanticipated side channel\n");
      return -1;
    }
    cidx = FChans + mip->nsch;
    mip->nsch += nch;
    break;
  case 'b':
    if (mip->nbch + nch > BChans) {
      fprintf(stderr,"Unanticipated back channel\n");
      return -1;
    }
    cidx = FChans + SChans + mip->nbch;
    mip->nbch += nch;
    break;
  case 'l':
    if (mip->nlch + nch > LChans) {
      fprintf(stderr,"Unanticipated LFE channel\n");
      return -1;
    }
    cidx = FChans + SChans + BChans + mip->nfch;
    mip->nlch += nch;
    break;
  default:
    CommonExit(1,"enter_chn");
  }
  mip->nch += nch;

  if (cpe == 0) {
    /* SCE */
    cip = &mip->ch_info[cidx];
    cip->present = 1;
    cip->tag = tag;
    cip->cpe = 0;
    cip->common_window = common_window;
    cip->widx = cidx;
    mip->nch = cidx + 1;
  }
  else {
    /* CPE */
    /* left */
    cip = &mip->ch_info[cidx];
    cip->present = 1;
    cip->tag = tag;
    cip->cpe = 1;
    cip->common_window = common_window;
    cip->ch_is_left = 1;
    cip->paired_ch = cidx+1;
    /* right */
    cip = &mip->ch_info[cidx+1];
    cip->present = 1;
    cip->tag = tag;
    cip->cpe = 1;
    cip->common_window = common_window;
    cip->ch_is_left = 0;
    cip->paired_ch = cidx;
    if (common_window) {
      mip->ch_info[cidx].widx = cidx;	/* window info is left */
      mip->ch_info[cidx+1].widx = cidx;
    }
    else {
      mip->ch_info[cidx].widx = cidx;	/* each has window info */
      mip->ch_info[cidx+1].widx = cidx+1;
    }
    mip->nch = cidx + 2;
  }
    
  return cidx;
}

static char
default_position(MC_Info *mip, int id)
{
  static int first_cpe = 0;

  if (mip->nch < FChans) {
    if (id == ID_CPE)
      /* here is the first CPE */
      first_cpe = 1;
    else if ( (bno==0) && !first_cpe )
      /* count number of SCE prior to first CPE in first block */
      mip->nfsce++;
    return('f');
  }
  else if  (mip->nch < FChans+SChans) {
    return('s');
  }
  else if  (mip->nch < FChans+SChans+BChans) {
    return('b');
  }
    
  return 0;
}

/* retrieve appropriate channel index for the program
 * and decoder configuration
 */
int
chn_config(int id, int tag, int common_window, MC_Info *mip)
{
  int cpe, cidx=0;
  char position;
    
  /* channel index to position mapping for 5.1 configuration is
   *  0	center
   *  1	left  front
   *  2	right front
   *  3	left surround
   *  4	right surround
   *  5	lfe
   */

  cpe = (id == ID_CPE) ? 1 : 0;
    
  if (default_config) {
    switch (id) {
    case ID_SCE:
    case ID_CPE:
      if ((position = default_position(mip, id)) == 0) {
        CommonExit(1,"Unanticipated channel\n");
      }
      cidx = enter_chn(cpe, tag, position, common_window, mip);
      break;
    case ID_LFE:
      cidx = enter_chn(cpe, tag, 'l', common_window, mip);
      break;
    }
  }
  else {	
    cidx = enter_chn(cpe, tag, 0, common_window, mip);
  }	

  return cidx;	    /* index of chn in mc_info */
}

/* 
 * check continuity of configuration from one
 * block to next
 */
void
reset_mc_info(MC_Info *mip)
{
  int i;
  Ch_Info *p;

  /* only reset for implicit configuration */
  if (default_config) {
    /* reset channel counts */
    mip->nch = 0;
    mip->nfch = 0;
    mip->nsch = 0;
    mip->nbch = 0;
    mip->nlch = 0;
    mip->ncch = 0;
    if (bno==0)
      /* reset prior to first block scan only! */
      mip->nfsce = 0;
    for (i=0; i<Chans; i++) {
      p = &mip->ch_info[i];
      p->present = 0;
      p->cpe = 0;
      p->ch_is_left = 0;
      p->paired_ch = 0;
      p->is_present = 0;
      p->widx = 0;
      p->ncch = 0;
    }
  }
}


void check_mc_info ( MC_Info*          mip, 
                     int               new_config, 
                     HANDLE_EP_INFO    hEpInfo,
                     HANDLE_RESILIENCE hResilience )
{
  int            i;
  int            nch;
  unsigned char  err = 0;
  Ch_Info*       s;
  Ch_Info*       p;
  static MC_Info save_mc_info;

  mc_info.mcInfoCorrectFlag = 1;
  if (new_config) {
    memcpy ( &save_mc_info, mip, sizeof(MC_Info) );
  }
  else {
    nch = save_mc_info.nch;
    /* check this block's configuration */
    for ( i = 0; i < nch; i++) {
      s = &save_mc_info.ch_info[i];
      p = &mip->ch_info[i];
      if ( (s->present       != p->present)
           || (s->cpe        != p->cpe)        
           || (s->ch_is_left != p->ch_is_left) 
           || (s->paired_ch  != p->paired_ch) ) {
        err = 1;
      }
    }
  }
  if (err) {
      fprintf(stderr, "Channel configuration inconsistency\n");
      for (i=0; i<nch; i++) {
        s = &save_mc_info.ch_info[i];
        p = &mip->ch_info[i];
        fprintf(stderr, "Channel %d\n", i);
        fprintf(stderr, "present    %d %d\n", s->present,  p->present);
        fprintf(stderr, "cpe        %d %d\n", s->cpe,  p->cpe);
        fprintf(stderr, "ch_is_left %d %d\n", s->ch_is_left,  p->ch_is_left);
        fprintf(stderr, "paired_ch  %d %d\n", s->paired_ch,  p->paired_ch);
        fprintf(stderr, "\n");
      }
      CommonExit(1,"check_mc_info");
  }
}


/* given cpe and tag,
 *  returns channel index of SCE or left chn in CPE
 */
int
ch_index(MC_Info *mip, int cpe, int tag)
{
  int ch;
    
  for (ch=0; ch<mip->nch; ch++) {

    if (!(mip->ch_info[ch].present))
      continue;

    if ( (mip->ch_info[ch].cpe == cpe) && 
         (mip->ch_info[ch].tag == tag) )
      return ch;
  }
    
  /* no match, so channel is not in this program
   *	dummy up the ch_info structure so rest of chn will parse
   */
  if (XChans > 0) {
    ch = Chans - XChans;	/* left scratch channel */
    mip->ch_info[ch].cpe = cpe;
    mip->ch_info[ch].ch_is_left = 1;
    mip->ch_info[ch].widx = ch;
    if (cpe) {
      mip->ch_info[ch].paired_ch = ch+1;
      mip->ch_info[ch+1].ch_is_left = 0;
      mip->ch_info[ch+1].paired_ch = ch;
    }
  }
  else {
    ch = -1;		/* error, no scratch space */
  }
    
  return ch;
}