dyn_cross.c

ISO mp3 sources (distribution 10) Layer 1/2/3, C Source, 512 k Sources of the Mpeg 1,2 layer 1,2

	break;
 case 10: 
	if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
	    bit_alloc[T4[sbgr]][min_sb] = 1;
	break;
 case 11: 
	if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
	    bit_alloc[T3[sbgr]][min_sb] = 1;
	if(min_ch == R0 && bit_alloc[R0][min_sb] != 0)
	    bit_alloc[T4[sbgr]][min_sb] = 1;
	break;
 case 12: 
	if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
	    bit_alloc[T4[sbgr]][min_sb] = 1;
	if(min_ch == L0 && bit_alloc[L0][min_sb] != 0)
	    bit_alloc[T3[sbgr]][min_sb] = 1;
	break;
 case 13: 
	if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0) 
	    bit_alloc[T2[sbgr]][min_sb] = 1;
	if(min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0)
	    bit_alloc[T4[sbgr]][min_sb] = 1;
	break;
 case 14: 
	if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) {
	    bit_alloc[T3[sbgr]][min_sb] = 1;
	    bit_alloc[T4[sbgr]][min_sb] = 1;
	}
	break;
 case 15: 
	fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
	fflush(stderr);
	exit(0);
	break;
    }	    /* switch.. */
}
else if (fr_ps->config == 310 || fr_ps->config == 220)
{
    /* 3/1 and 2/2 */
    switch(fr_ps->header->dyn_cross[sbgr]) {
  case 0:	
	break;
  case 1: 
	if(min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0)
	    bit_alloc[T3[sbgr]][min_sb] = 1;
	break;
  case 2: 
	if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
	    bit_alloc[T2[sbgr]][min_sb] = 1;
	break;
  case 3: 
	if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0) 
	    bit_alloc[T2[sbgr]][min_sb] = 1;
	if(min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0) 
	    bit_alloc[T3[sbgr]][min_sb] = 1;
	break;
  case 4: 
	if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
	    bit_alloc[T3[sbgr]][min_sb] = 1;
	break;
 default: 
	fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
	fflush(stderr);
	exit(0);
	break;
    }	    /* switch.. */
}
else if (fr_ps->config == 300 || fr_ps->config == 302 || fr_ps->config == 210)
{
    /* 3/0 (+2/0) and 2/1 */
    switch(fr_ps->header->dyn_cross[sbgr]) {
  case 0:	
	break;
  case 1: 
	if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
	    bit_alloc[T2[sbgr]][min_sb] = 1;
	break;
 default: 
	fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
	fflush(stderr);
	exit(0);
	break;
    }	    /* switch.. */
    if (fr_ps->header->dyn_second_stereo[sbgr])
	if(min_ch == T4outof[sbgr] && bit_alloc[T4outof[sbgr]][min_sb] != 0)
	    bit_alloc[T4[sbgr]][min_sb] = 1;
}
else if (fr_ps->config == 202)
{
    if (fr_ps->header->dyn_second_stereo[sbgr])
	if(min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0)
	    bit_alloc[T3[sbgr]][min_sb] = 1;
}
else if (fr_ps->config == 102)
{
    if (fr_ps->header->dyn_second_stereo[sbgr])
	if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
	    bit_alloc[T2[sbgr]][min_sb] = 1;
}
}

#ifdef Augmentation_7ch
void choose_dyn_aug (
	frame_params	*fr_ps, 
	    /* in:  fr_ps->header->dyn_cross[sbgr] 
	     *	    fr_ps->alloc
	     */
	int		min_ch,				/* in */
	int		min_sb,				/* in */
	int		sbgr, 				/* in */
	unsigned int	bit_alloc[CHANMAX3][SBLIMIT])	/* out */
{
/*  global parameters
 *  in:	T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS]
 */
    layer *info  = fr_ps->header;
    int dynx_T2 = !dyn_ch (fr_ps, sbgr, 2);
    int dynx_T3 = !dyn_ch (fr_ps, sbgr, 3);
    int dynx_T4 = !dyn_ch (fr_ps, sbgr, 4);
    int T5T0 = L0, T6T0 = L0, T6T1 = R0;
    
    if (info->aug_tc_alloc[sbgr] == 4 || info->aug_tc_alloc[sbgr] == 5)
    	if (fr_ps->header->dyn_cross_LR == 0)
	    T6T1 = L0;
	else
	    T6T0 = R0;
    else if (info->aug_tc_alloc[sbgr] == 6 || info->aug_tc_alloc[sbgr] == 7)
        if (info->dyn_cross_LR)
	    T5T0 = R0;

    /* 5/2 */
    switch (fr_ps->header->aug_dyn_cross[sbgr])
    {
    case 0:	
	  break;
    case 1: 
	  if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0)
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
    case 2: 
	  if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
	      (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
    case 3: 
	  if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
	      (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
    case 4: 
	  if (min_ch == T5[sbgr] && bit_alloc[T5[sbgr]][min_sb] != 0)
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
    case 5: 
	  if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  break;
    case 6: 
	  if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0) 
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
    case 7: 
	  if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
	      (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
    case 8: 
	  if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
	      (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
    case 9: 
	  if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0)
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if (min_ch == T6T0 && bit_alloc[T6T0][min_sb] != 0)
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   case 10: 
	  if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
	      (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  break;
   case 11: 
	  if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
	      (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0)
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   case 12: 
	  if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
	      (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   case 13: 
	  if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
	      (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
	      (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   case 14: 
	  if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
	      (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  break;
   case 15: 
	  if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
	      (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0)
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   case 16: 
	  if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
	      (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
	      (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   case 17: 
	  if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
	      (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = 1;
	  if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
	      (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
	      bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   case 18:
	  if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
	      (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
	      bit_alloc[T5[sbgr]][min_sb] = bit_alloc[T6[sbgr]][min_sb] = 1;
	  break;
   default: 
	  fprintf (stderr, "FORBIDDEN AUG_DYN_CROSS!!!!!\n");
	  fflush (stderr);
	  exit (1);
	  break;
    }
}
#endif


/************************************************************************
 *
 * scfsi_calc_dyn    
 *
 * Version 1.0	    94/07/07	Andreas Silzle, IRT
 *
 * Calculating the scale factor select information of one channel 
 * without changing the scale factors.
 *
 ************************************************************************/

void scfsi_calc_dyn (
	unsigned int	scalar_dyn[][3][SBLIMIT],   /* in/out */
	int		ch, 			    /* in */
	int		sblimit,		    /* in */ 
	unsigned int	scfsi_dyn[][SBLIMIT]) 	    /* out */
{
    int	    sb;
    
    for (sb = 0; sb < sblimit; sb++)
    {
	/* If the subbands are coded only with SCF's, they must be accurate. */
	/* 1993-02-19 and 1994-03-17 shn */
	/* 4 patterns are possible: 0: ABC, 1: AAB, 2: AAA, 3: ABB */
	if ((scalar_dyn[ch][0][sb] != scalar_dyn[ch][1][sb]) &&
	    (scalar_dyn[ch][1][sb] != scalar_dyn[ch][2][sb]))
	    scfsi_dyn[ch][sb] = 0;
	else
	if ((scalar_dyn[ch][0][sb] == scalar_dyn[ch][1][sb]) &&
	    (scalar_dyn[ch][1][sb] != scalar_dyn[ch][2][sb]))
	    scfsi_dyn[ch][sb] = 1;
	else
	if ((scalar_dyn[ch][0][sb] == scalar_dyn[ch][1][sb]) &&
	    (scalar_dyn[ch][1][sb] == scalar_dyn[ch][2][sb]))
	    scfsi_dyn[ch][sb] = 2;
	else
	    scfsi_dyn[ch][sb] = 3;
    }	/* for (sb.. */
}

/************************************************************************
 *
 * scfsi_calc    
 *
 * Version 1.0	    94/07/07	Andreas Silzle, IRT
 *
 * Calculating the scale factor select information of one channel. 
 *
 * route: II_transmission_pattern (Layer II only)
 *
 * PURPOSE:For a given subband, determines whether to send 1, 2, or
 * all 3 of the scalefactors, and fills in the scalefactor
 * select information accordingly
 *
 * SEMANTICS:  The subbands and channels are classified based on how much
 * the scalefactors changes over its three values (corresponding
 * to the 3 sets of 12 samples per subband).  The classification
 * will send 1 or 2 scalefactors instead of three if the scalefactors
 * do not change much.  The scalefactor select information,
 * #scfsi#, is filled in accordingly.
 *
 ************************************************************************/

void scfsi_calc (
	unsigned int	scalar[][3][SBLIMIT], 	/* in/out */
	int		ch, 			/* in */
	int		sblimit,		/* in */ 
	unsigned int	scfsi[][SBLIMIT]) 	/* out */
{
    int dscf[2];
    int class[2], sb, j;
    static int pattern[5][5] = {
	0x123, 0x122, 0x122, 0x133, 0x123,
	0x113, 0x111, 0x111, 0x444, 0x113,
	0x111, 0x111, 0x111, 0x333, 0x113,
	0x222, 0x222, 0x222, 0x333, 0x123,
	0x123, 0x122, 0x122, 0x133, 0x123    };

    for (sb = 0; sb < sblimit; sb++)
    {
	dscf[0] = (scalar[ch][0][sb] - scalar[ch][1][sb]);
	dscf[1] = (scalar[ch][1][sb] - scalar[ch][2][sb]);
	for (j=0; j<2; j++)
	{
	    if (dscf[j] <= -3)
		class[j] = 0;
	    else if (dscf[j] > -3 && dscf[j] < 0)
		class[j] = 1;
	    else if (dscf[j] == 0)
		class[j] = 2;
	    else if (dscf[j] > 0 && dscf[j] < 3)
		class[j] = 3;
	    else 
		class[j] = 4;
	}
	switch (pattern[class[0]][class[1]])
	{
	case 0x123 :
	    scfsi[ch][sb] = 0;
	    break;
	case 0x122 :
	    scfsi[ch][sb] = 3;
	    scalar[ch][2][sb] = scalar[ch][1][sb];
	    break;
	case 0x133 :
	    scfsi[ch][sb] = 3;
	    scalar[ch][1][sb] = scalar[ch][2][sb];
	    break;
	case 0x113 :
	    scfsi[ch][sb] = 1;
	    scalar[ch][1][sb] = scalar[ch][0][sb];
	    break;
	case 0x111 :
	    scfsi[ch][sb] = 2;
	    scalar[ch][1][sb] = scalar[ch][2][sb] = scalar[ch][0][sb];
	    break;
	case 0x222 :
	    scfsi[ch][sb] = 2;
	    scalar[ch][0][sb] = scalar[ch][2][sb] = scalar[ch][1][sb];
	    break;
	case 0x333 :
	    scfsi[ch][sb] = 2;
	    scalar[ch][0][sb] = scalar[ch][1][sb] = scalar[ch][2][sb];
	    break;
	case 0x444 :
	    scfsi[ch][sb] = 2;
	    if (scalar[ch][0][sb] > scalar[ch][2][sb])
		scalar[ch][0][sb] = scalar[ch][2][sb];
	    scalar[ch][1][sb] = scalar[ch][2][sb] = scalar[ch][0][sb];
	}	/* switch */
    }		/* for (sb.. */
}

/************************************************************************
 *
 * scf_calc    
 *
 * Calculating the scale factor for one channel.
 *
 * Version 1.0	    94/07/07	Andreas Silzle, IRT
 *
 * route: II_scale_factor_calc() 
 *
 * PURPOSE:For each subband, calculate the scale factor for each set
 * of the 12 subband samples
 *
 * SEMANTICS:  Pick the scalefactor #multiple[]# just larger than the
 * absolute value of the peak subband sample of 12 samples,
 * and store the corresponding scalefactor index in #scalar#.
 *
 * Layer II has three sets of 12-subband samples for a given
 * subband.
 *
 ************************************************************************/

void scf_calc (
	double		sample[][3][SCALE_BLOCK][SBLIMIT], /* in */
	int		sblimit,		/* in */
	int		ch,			/* in */
	unsigned int	scf[][3][SBLIMIT])	/* out */ 
{
/* global variables: 
 * double multiple[64] 
 */
    int	    sb, smp, sufr, r;
    double  s[SBLIMIT];

    for (sufr=0; sufr<3; sufr++)
    {
	for (sb=0; sb<sblimit; sb++)
	    for (smp=1, s[sb] = mod(sample[ch][sufr][0][sb]); 
		    smp<SCALE_BLOCK; smp++)
		if (mod(sample[ch][sufr][smp][sb]) > s[sb])
		    s[sb] = mod(sample[ch][sufr][smp][sb]);

	for (sb=0; sb<sblimit; sb++)
	    for (r=SCALE_RANGE-1, scf[ch][sufr][sb]=0; r>=0; r--)
		if (s[sb] < multiple[r])
		{                       /* <= changed to <, 1992-11-06 shn*/
		    scf[ch][sufr][sb] = r;
		    break;
		}
    }   /* for (sufr.. */
}