audio_class.c

包含了NXP众多的MCU的例子程序

__fiq __arm void fiq_handler (void)
{
static union _Val
{
  Int32S Data;
  struct
  {
    Int16U DataLo;
    Int16S DataHi;
  };
} Val = {0x02000000};

union _Val MicTemp;

  // Set DAC
  DACR_bit.VALUE = Val.DataHi;

  if (SempEna)
  {
    if(Delta > 1)
    {
      // Get next input sample
      Val.Data = AudioSpkData[SempCount++];
      Delta   -= 2;
      // Correct pointer to sample buffer
      if(SempCount >= sizeof(AudioSpkData)/sizeof(Int16U))
      {
        SempCount = 0;
      }
      if(!AudioFeat1Mute && AudioSpkVolMul)
      {
        // Apply volume
        Val.Data   *= AudioSpkVolMul;
        // Add offset
        Val.DataHi += 0x200;
        // Check for overflow and correct value
        if(Val.DataHi < 0)
        {
          Val.DataHi = 0;
        }
        else if(Val.DataHi > 0x3FF)
        {
          Val.DataHi = 0x3FF;
        }
      }
      else
      {
        // set middle of range
        Val.DataHi = 0x200;
      }
    }
    else
    {
      // Disabe output stream after emptying the buffer
      SempEna = FALSE;
      SempPerCurrHold = SempPeriod;
      pSpkData = AudioSpkData;
    }
  }
  else
  {
    SempPerCurrHold = SempPeriod;
  }

  if(MicEna)
  {
    if(!AudioFeat2Mute && AudioMicVolMul)
    {
      // Get ADC sample and remove offset
      MicTemp.Data  = AD0GDR_bit.RESULT - 0x200;
      // Start conversion
      AD0CR_bit.START = 1;
      // Add volume
      MicTemp.Data *= AudioMicVolMul;
      // check for overflow and correct the result
      if(MicTemp.DataHi < -511)
      {
        MicTemp.Data = -511 * 65536;
      }
      else if(MicTemp.DataHi > 511)
      {
        MicTemp.Data = 511 * 65536;
      }
      // Scale to 16bit
      MicTemp.Data <<= 6;
    }
    else
    {
      // set middle of range
      MicTemp.DataHi = 0;
    }
    // write to output buffer
    *pMicData++ = MicTemp.DataHi;
  }

  T0MR0 = SempPerCurrHold;
  T0IR  = T0IR;
}

/*************************************************************************
 * Function Name: AudioFeatureGetReg
 * Parameters:  Int32U CS, Int32U Id
 *
 * Return: Boolean
 *
 * Description:
 *
 *************************************************************************/
static Boolean AudioFeatureGetReg (Int32U CS, Int32U Id)
{
  switch (CS)
  {
  case REQUEST_GET_CUR:
    // Load current value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (AudioFeat1Vol>>8)& 0xFF;
      AudioBuf[0] =  AudioFeat1Vol    & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (AudioFeat2Vol>>8)& 0xFF;
      AudioBuf[0] =  AudioFeat2Vol    & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  case REQUEST_GET_MIN:
    // Load minimum value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (Feat1MinVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat1MinVol      & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (Feat2MinVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat2MinVol      & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  case REQUEST_GET_MAX:
    // Load maximum value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (Feat1MaxVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat1MaxVol      & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (Feat2MaxVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat2MaxVol      & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  case REQUEST_GET_RES:
    // Load resolution value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (Feat1ResVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat1ResVol      & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (Feat2ResVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat2ResVol      & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  default:
    return(FALSE);
  }
  return(TRUE);
}

/*************************************************************************
 * Function Name: UsbClassAudioRequest
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: USB Class Audio Requests
 *
 *************************************************************************/
void * UsbClassAudioRequest (void * pArg)
{
UsbEpCtrl_t * pAdioReqCtrl = (UsbEpCtrl_t *) pArg;
UsbSetupPacket_t * pAudioReqPacket = (UsbSetupPacket_t *)pAdioReqCtrl->pData;
  // Validate Request
  switch (pAudioReqPacket->mRequestType.Recipient)
  {
  case UsbRecipientInterface:
    // Feature Unit requests only imlement for interface 0
    if ((pAudioReqPacket->wIndex.Word == (FeatUnit1Id << 8)) ||
        (pAudioReqPacket->wIndex.Word == (FeatUnit2Id << 8)))
    {
      // Requset type
      switch (pAudioReqPacket->wValue.Hi)
      {
      case FU_MUTE_CONTROL:
        if ((pAudioReqPacket->bRequest == REQUEST_SET_CUR) &&
            (pAudioReqPacket->wLength.Word == 1))
        {
          // Set mute flag
          AudioRequest  = pAudioReqPacket->bRequest;
          AudioId       = pAudioReqPacket->wIndex.Hi;
          AudioCS       = pAudioReqPacket->wValue.Hi;
          AudioCN       = pAudioReqPacket->wValue.Lo;
          AudioDataSize = pAudioReqPacket->wLength.Word;
          pAdioReqCtrl->Counter= 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void *)UsbUserReceivePacket);
        }
        else if ((pAudioReqPacket->bRequest == REQUEST_GET_CUR) &&
                 (pAudioReqPacket->wLength.Word == 1))
        {
          // Read mute flag
          if(pAudioReqPacket->wIndex.Hi == FeatUnit1Id)
          {
            AudioBuf[0]  = AudioFeat1Mute;
          }
          else
          {
            AudioBuf[0]  = AudioFeat2Mute;
          }
          pAdioReqCtrl->Counter= 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void*)UsbUserSendPacket);
        }
        break;
      case FU_VOLUME_CONTROL:
        if(pAudioReqPacket->bRequest & 0x80)
        {
          // Read differnt volume valules
          if((pAudioReqPacket->wLength.Word == 2) &&
              AudioFeatureGetReg(pAudioReqPacket->bRequest,pAudioReqPacket->wIndex.Hi))
          {
            pAdioReqCtrl->Counter = 2;
            pAdioReqCtrl->pData = AudioBuf;
            return((void*)UsbUserSendPacket);
          }
        }
        else if((pAudioReqPacket->bRequest == REQUEST_SET_CUR) &&
                (pAudioReqPacket->wLength.Word  == 2))
        {
          // Set volume valule
          AudioRequest  = pAudioReqPacket->bRequest;
          AudioId       = pAudioReqPacket->wIndex.Hi;
          AudioCS       = pAudioReqPacket->wValue.Hi;
          AudioCN       = pAudioReqPacket->wValue.Lo;
          AudioDataSize = pAudioReqPacket->wLength.Word;
          pAdioReqCtrl->Counter = 2;
          pAdioReqCtrl->pData = AudioBuf;
          return((void *)UsbUserReceivePacket);
        }
        break;
      }
    }
    // Selector Unit requests only imlement for interface 0
    else if (pAudioReqPacket->wIndex.Word == (SelUnit1ID << 8))
    {
      if(pAudioReqPacket->wValue.Word == 0)
      {
        // Read different selector unit values
        if(pAudioReqPacket->bRequest & 0x80)
        {
          if(pAudioReqPacket->wLength.Word == 1)
          {
            AudioBuf[0] = 1;
            pAdioReqCtrl->Counter = 1;
            pAdioReqCtrl->pData = AudioBuf;
            return((void*)UsbUserSendPacket);
          }
        }
        else
        {
          // Set channel
          AudioRequest  = pAudioReqPacket->bRequest;
          AudioId       = pAudioReqPacket->wIndex.Hi;
          AudioDataSize = pAudioReqPacket->wLength.Word;
          pAdioReqCtrl->Counter = 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void *)UsbUserReceivePacket);
        }
      }
    }
    return((void *)UsbUserStallCtrlEp);
  case UsbRecipientEndpoint:
    return((void *)UsbUserStallCtrlEp);
  }
  return((void *)UsbUserStallCtrlEp);
}

/*************************************************************************
 * Function Name: UsbClassAudioData
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: USB Class Audio Data receive
 *
 *************************************************************************/
void * UsbClassAudioData (void * pArg)
{
  if((AudioId == FeatUnit1Id) ||
     (AudioId == FeatUnit2Id))
  {
    switch (AudioCS)
    {
    case FU_MUTE_CONTROL:
      // Set mute flag
      if (AudioId == FeatUnit1Id)
      {
        AudioFeat1Mute = AudioBuf[0];
      }
      else if (AudioId == FeatUnit2Id)
      {
        AudioFeat2Mute = AudioBuf[0];
      }
      else
      {
        return((void*)UsbUserStallCtrlEp);
      }
      break;
    case FU_VOLUME_CONTROL:
      // Set volume value
      if (AudioId == FeatUnit1Id)
      {
        AudioFeat1Vol = AudioBuf[0] + ((Int16U)AudioBuf[1]<<8);
        if((Int16U)AudioFeat1Vol == MinVol)
        {
          AudioSpkVolMul = 0;
        }
        else
        {
          if (AudioFeat1Vol < (Int16S)Feat1MinVol)
          {
            AudioFeat1Vol = Feat1MinVol;
          }
          else if(AudioFeat1Vol > (Int16S)Feat1MaxVol)
          {
            AudioFeat1Vol = Feat1MaxVol;
          }
          // -48dB - +6dB multiply
          AudioSpkVolMul = (VolumeMul[((AudioFeat1Vol>>8)+0x30) & 0x3F]) >> 6;
        }
      }
      else if (AudioId == FeatUnit2Id)
      {
        AudioFeat2Vol = AudioBuf[0] + ((Int16U)AudioBuf[1]<<8);
        if((Int16U)AudioFeat2Vol == MinVol)
        {
          AudioMicVolMul = 0;
        }
        else
        {
          if (AudioFeat2Vol < (Int16S)Feat2MinVol)
          {
            AudioFeat2Vol = Feat2MinVol;
          }
          else if(AudioFeat2Vol > (Int16S)Feat2MaxVol)
          {
            AudioFeat2Vol = Feat2MaxVol;
          }
          // -48dB - +6dB multiply
          AudioMicVolMul = VolumeMul[((AudioFeat2Vol>>8)+0x30) & 0x3F];
        }
      }
      else
      {
        return((void*)UsbUserStallCtrlEp);
      }
      break;
    default:
      return((void*)UsbUserStallCtrlEp);
    }
  }
  else if (AudioId == SelUnit1ID)
  {
    // empty
  }
  else
  {
    return((void*)UsbUserStallCtrlEp);
  }
  return((void*)UsbUserSendAckn);
}