aud_atom.c

IBM source for pallas/vulcan/vesta

/* Stops (pauses) stream decoding at end of frame */
void aud_atom_stop()
{
  MT_DCR(AUD_CTRL2, MF_DCR(AUD_CTRL2) | DECOD_AUD_CTRL2_HD);
}

/* re-starts paused stream decoding */
void aud_atom_play()
{
  MT_DCR(AUD_CTRL2, MF_DCR(AUD_CTRL2) & ~DECOD_AUD_CTRL2_HD);
}

void aud_atom_mute(void)
{

    unsigned long reg;

    reg = MF_DCR(AUD_CTRL1) | DECOD_AUD_CTRL1_SOFT_MUTE;
    MT_DCR(AUD_CTRL1, reg);
    reg = MF_DCR(AUD_CTRL2) | DECOD_AUD_CTRL2_MUTE;
    MT_DCR(AUD_CTRL2, reg);
    _mute = 1;
    PDEBUG("mute\n");
}

void aud_atom_unmute(void)
{

    unsigned long reg;

    reg = MF_DCR(AUD_CTRL1) & (~DECOD_AUD_CTRL1_SOFT_MUTE);
    MT_DCR(AUD_CTRL1, reg);
    reg = MF_DCR(AUD_CTRL2) & (~DECOD_AUD_CTRL2_MUTE);
    MT_DCR(AUD_CTRL2, reg);
    _mute = 0;
    PDEBUG("unmute\n");
}

#ifdef DTS_ENABLE
/* LPCM tables */
#define A_LPCM_STAT_EMPH_MASK 0x8000

#define A_LPCM_STAT_BIT_MASK  0x00C0
#define A_LPCM_STAT_BIT_SHIFT 6
#define A_LPCM_STAT_BIT_16    0x0000
#define A_LPCM_STAT_BIT_20    0x0040
#define A_LPCM_STAT_BIT_24    0x0080
#define A_LPCM_STAT_BIT_INV   0x00C0

#define A_LPCM_STAT_FS_MASK   0x0030
#define A_LPCM_STAT_FS_SHIFT  4
#define A_LPCM_STAT_FS_48KHZ  0x0000
#define A_LPCM_STAT_FS_96KHZ  0x0010
#define A_LPCM_STAT_FS_INV    0x0020

#define A_LPCM_CHAN_MASK      0x0007

long lpcm_fs[] = { 48000, 96000, 0, 0 };
long lpcm_bit[] = { 16, 20, 24, 0 };

INT aud_atom_lpcm_status (audioStatus *pStatus)
{
  unsigned long astat;

  astat = pStatus->raw[2] >> 16;

  if (0 == (pStatus->sample_rate = 
	    lpcm_fs[(astat & A_LPCM_STAT_FS_MASK) >> A_LPCM_STAT_FS_SHIFT])) {
    return 0;
  }

  if (0 == (pStatus->bit_rate = 
	    lpcm_bit[(astat & A_LPCM_STAT_BIT_MASK) >> A_LPCM_STAT_BIT_SHIFT])) {
    return 0;
  }

  pStatus->bit_rate *= 
    pStatus->sample_rate * ((astat & A_LPCM_CHAN_MASK) + 1);

  return 1;
}

/* DTS tables  */
#define A_DTS_NBLKS ((pStatus->raw[2] & 0x007f0000) >> 16)
#define A_DTS_FSIZE  (pStatus->raw[2] & 0x00003fff)
#define A_DTS_FS    ((pStatus->raw[3] & 0x01e00000) >> 21)
#define A_DTS_RATE  ((pStatus->raw[3] & 0x001f0000) >> 16)
#define A_DTS_XTEND  (pStatus->raw[3] & 0x00000010)
#define A_DTS_XVAL  ((pStatus->raw[3] & 0x000000e0) >> 5)

long dts_fs[16] = {
  0, 8000, 16000, 32000,
  0,  0, 11025, 22050, 44100,
  0,  0, 12000, 24000, 48000,
  0,  0
};

long dts_rate[32] = {
   32000,   56000,   64000,   96000,  112000,  128000,  192000,  224000,
  256000,  320000,  384000,  448000,  512000,  576000,  640000,  768000,
  960000, 1024000, 1152000, 1280000, 1344000, 1408000, 1411200, 1472000,
 1536000, 1920000, 2048000, 3072000, 3840000,       0,       0,       0 
};

long dts_chan[16] = {
  0+1  /* A */,
  0+2  /* A+B dual mono */,
  0+2  /* L+R stereo    */,
  0+2  /* (L+R) + (L-R) sum-difference */,
  0+2  /* LT + RT left/right total */,
  0+3  /* C + L + R */,
  0+3  /* L + R + S */,
  0+4  /* C + L + R + S */,
  0+4  /* L + R + SL + SR */,
  0+5  /* C + L + R + SL + SR */,
  0+6  /* CL + CR + L + R + SL + SR */,
  0+6  /* C + L + R + LR + RR + OV  */,
  0+6  /* CF + CR + LF +RF + LF + RR */,
  0+7  /* CL + C + CR + L + R + SL + SR */,
  0+8  /* CL + CR + L + R + SL1 + SL2 + SR + SR2 */,
  0+8  /* CL + C + CR + L + R + SL + S + SR */,
}; /* values >= 16 are user-defined */

INT aud_atom_dts_status (audioStatus *pStatus)
{
  pStatus->bit_rate = dts_rate[A_DTS_RATE];
  pStatus->sample_rate = dts_fs[A_DTS_FS];
  if (A_DTS_XTEND) {
    if ((A_DTS_XVAL == 2) || (A_DTS_XVAL == 3))
      pStatus->sample_rate *= 2;
  }

  return 1;
}
#endif

/* UPCM tables */
unsigned long upcm_sample_rate[16] = {
  0, 16000, 22050, 24000,
  0, 32000, 44100, 48000,
  0,  8000, 11025, 12000,
  0, 64000, 88200, 96000
};

INT aud_atom_upcm_status (audioStatus *pStatus)
{
  unsigned long astat;
  int num_bits = 1;

  astat = MF_DCR(AUD_DSP_CTRL);

  pStatus->sample_rate = upcm_sample_rate[astat & 0x0f];
  
  switch (astat & AUD_DSP_PCM_BIT_MASK) {
  case AUD_DSP_PCM_16BIT:
    num_bits = 16;
    break;

  case AUD_DSP_PCM_8BIT:
    num_bits = 8;
    break;

  default:
    num_bits = 24;
  };

  if (!(astat & AUD_DSP_PCM_MONO)) num_bits *= 2;
  pStatus->bit_rate = pStatus->sample_rate * num_bits;

  return 1;
}

/* Dolby AC3 status tables */
unsigned long ac3_sample_rate[4] =  { 48000, 44100, 32000, 0};
unsigned long ac3_bit_rate[32] = {
  32,  40,  48,  56,  64,  80,  96, 112,
 128, 160, 192, 224, 256, 320, 384, 448,
 512, 576, 640
};
#if 0
int ac3_num_channel = {
  2 /* 1+1 */, 1 /* mono */, 2 /* stereo */, 3 /* LCR */, 
  3 /* LRS */, 4 /* LCRS */, 4 /* LRLsRs */, 5 /* LCRLsRs */
}
#endif

INT aud_atom_ac3_status (audioStatus *pStatus)
{
  int i;
  unsigned long astat;

  astat = pStatus->raw[2];

  /* Lookup current sample rate */
  pStatus->sample_rate = ac3_sample_rate[(astat >> 16) & 0x03];

  /* Lookup current bit rate */
  i = (astat >> 23) & 0x1f;
  pStatus->bit_rate = (i > 18) ? -1 : ac3_bit_rate[i];

  return 1;
}

/* MPEG status tables */
unsigned long mpeg_sample_rate[4] = { 44100, 48000, 32000, 0};
unsigned long mpeg_bit_rate[2][3][16] = {
  {    /* ID == 0 (LSF) */
    {   0,  32,  48,  56,  64,  80,  96, 112, /* Layer I   */
	128, 144, 160, 176, 192, 224, 256, -1}, 
    {   0,   8,  16,  24,  32,  40,  48,  56, /* Layer II  */
	 64,  80,  96, 112, 128, 144, 160, -1}, 
    {   0,   8,  16,  24,  32,  40,  48,  56, /* Layer III */
	 64,  80,  96, 112, 128, 144, 160, -1}, 
  },
  {    /* ID == 1 */
    {   0,  32,  64,  96, 128, 160, 192, 224, /* Layer I   */
	256, 288, 320, 352, 384, 416, 448, -1}, 
    {   0,  32,  48,  56,  64,  80,  96, 112, /* Layer II  */
	128, 160, 192, 224, 256, 320, 384, -1}, 
    {   0,  32,  40,  48,  56,  64,  80,  96, /* Layer III */
	112, 128, 160, 192, 224, 256, 320, -1}
  }
};

INT aud_atom_mpeg_status (audioStatus *pStatus)
{
  unsigned long astat, astat1;
  int layer, id;

  astat = pStatus->raw[2];
  astat1 = pStatus->raw[3];
  layer = ((astat >> 17) & 0x03) ^ 0x03;
  id = (astat >> 19) & 0x01;

  if (layer == 3) return 0; /* if invalid layer, exit */

  /* Lookup current sample rate */
  pStatus->sample_rate = mpeg_sample_rate[((astat >> 10) & 0x3)];
  
  if (id == 0)
    pStatus->sample_rate /= 2;

  /* Lookup current bit rate */
  pStatus->bit_rate = 
    mpeg_bit_rate[id][layer][(astat >> 12) & 0x0f];
    
  return 1;
}

INT aud_atom_get_status(unsigned long *aud_status_mem_ptr,
			audioStatus *pStatus)
{
  int i;

  /* Get and store audio status register */
  pStatus->dsp_status = MF_DCR(AUD_DSP_STATUS);

  if (!(pStatus->dsp_status & 0x02)) { /* check if valid play */
    pStatus->bit_rate = 0;
    pStatus->sample_rate = 0;
    for (i = 0; i < (64 / sizeof(unsigned long)); i++)
      pStatus->raw[i] = 0;

    return 0;
  }

  /* Get and store raw status from status memory area */
  for (i = 0; i < (64 / sizeof(unsigned long)); i++)
    pStatus->raw[i] = *aud_status_mem_ptr++;

  /* call appropriate decode status generation subroutine */
  switch (pStatus->stream_decode_type) {
  case AUD_MODE_STB_PCM:
    return aud_atom_upcm_status(pStatus);

  case AUD_MODE_AC3:
    return aud_atom_ac3_status(pStatus);

#ifdef DTS_ENABLE
  case AUD_MODE_DTS:
    return aud_atom_dts_status(pStatus);

  case AUD_MODE_LPCM:
    return aud_atom_lpcm_status(pStatus);
#endif

  case AUD_MODE_STB_MPEG:
    return aud_atom_mpeg_status(pStatus);
  }

  return 0;
}

INT aud_atom_get_mute_state()
{
    return _mute;
}

void aud_atom_get_vol(AUDVOL* pVol)
{
    unsigned long val;
    unsigned long reg;

    val = MF_DCR(AUD_ATTEN_VAL_FRONT);
    reg = val & 0x0000003F;
    pVol->frontright = reg;
    reg = (val >> 8) & 0x0000003F;
    pVol->frontleft = reg;

    val = MF_DCR(AUD_ATTEN_VAL_REAR);
    reg = val & 0x0000003F;
    pVol->rearright = reg;
    reg = (val >> 8) & 0x0000003F;
    pVol->rearleft = reg;

    val = MF_DCR(AUD_ATTEN_VAL_CENTER);
    reg = val & 0x0000003F;
    pVol->lfe = reg;
    reg = (val >> 8) & 0x0000003F;
    pVol->center = reg;
}

void aud_atom_set_vol(AUDVOL *pAudVol)
{
    unsigned long reg1;
    unsigned long reg;
    unsigned long val;

    reg1 = pAudVol->frontleft;
    reg = pAudVol->frontright;

    if (reg1 > 63)
        reg1 = 63;

    if (reg > 63)
        reg = 63;

    val = ((reg1 & 0x0000003F) << 8) | (reg & 0x0000003F);

    MT_DCR(AUD_ATTEN_VAL_FRONT, val);

    reg1 = pAudVol->rearleft;
    reg = pAudVol->rearright;

    if (reg1 > 63)
        reg1 = 63;

    if (reg > 63)
        reg = 63;

    val = ((reg1 & 0x0000003F) << 8) | (reg & 0x0000003F);

    MT_DCR(AUD_ATTEN_VAL_REAR, val);

    reg1 = pAudVol->center;
    reg = pAudVol->lfe;

    if (reg1 > 63)
        reg1 = 63;

    if (reg > 63)
        reg = 63;

    val = ((reg1 & 0x0000003F) << 8) | (reg & 0x0000003F);

    MT_DCR(AUD_ATTEN_VAL_CENTER, val);
}

void aud_atom_set_channel(audChannel_t channel)
{
    unsigned long reg;

    reg = MF_DCR(AUD_CTRL1) & (~DECOD_AUD_CTRL1_CHANNEL_MASK);

    switch (channel)
    {

        case AUD_CHANNEL_STEREO:
            MT_DCR(AUD_CTRL1, reg | DECOD_AUD_CTRL1_STEREO);
            break;

        case AUD_CHANNEL_MONOLEFT:
            MT_DCR(AUD_CTRL1, reg | DECOD_AUD_CTRL1_MONO_LEFT);
            break;

        case AUD_CHANNEL_MONORIGHT:
            MT_DCR(AUD_CTRL1, reg | DECOD_AUD_CTRL1_MONO_RIGHT);
            break;
    }
}