audio_class.c

NXP LPC系列AMR7的开发程序源码（LCD

        // Enable output
        SempCount = 0;
        SempEna   = TRUE;
      }
    }

    save = __get_interrupt_state();
    __disable_interrupt();
    Delta  += ReceievedBytes;
    __set_interrupt_state(save);

  }
  // Load speaker buffer
  pSpkDD->pDmaBuffer    = (pInt32U)pSpkData;
  pSpkDD->pDmaIsoPacket = &DmaSpkIsoPacket;
  USB_DmaRestartTransfer((USB_Endpoint_t)SpkEp,SpkDDInd);
  return(NULL);
}

/*************************************************************************
 * Function Name: FIQ_Handler
 * Parameters: none
 *
 * Return: none
 *
 * Description:
 *
 *************************************************************************/
__fiq __arm void FIQ_Handler (void)
{
static Int16U Data;
signed long long Tmp;
  // Set DAC
  I2STXFIFO = Data*0x10001;

  if (SempEna)
  {
    if(Delta > 1)
    {
      // Get next input sample
      Tmp = AudioSpkData[SempCount++];
      Delta   -= 2;
      // Correct pointer to sample buffer
      if(SempCount >= sizeof(AudioSpkData)/sizeof(Int16S))
      {
        SempCount = 0;
      }
      if(!AudioFeat1Mute && AudioSpkVolMul)
      {
        // Apply volume
        Tmp *= AudioSpkVolMul;
        if(Tmp >= 0x100000000)
        {
          Data = 0x7FFF;
        }
        else if (Tmp <= -0x100000000)
        {
          Data = 0x8000;
        }
        else
        {
          Data = (Tmp >> 16) & 0xFFFF;
        }
      }
      else
      {
        // set middle of range
        Data = 0;
      }
    }
    else
    {
      // Disable output stream after emptying the buffer
      SempEna = FALSE;
      SempPerCurrHold = SempPeriod;
      pSpkData = AudioSpkData;
    }
  }
  else
  {
    SempPerCurrHold = SempPeriod;
  }

  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
    {
      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
    {
      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
    {
      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
    {
      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))
    {
      // Request 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 *)UsbPass);
        }
        else if ((pAudioReqPacket->bRequest == REQUEST_GET_CUR) &&
                 (pAudioReqPacket->wLength.Word == 1))
        {
          // Read mute flag
          AudioBuf[0]  = AudioFeat1Mute;
          pAdioReqCtrl->Counter= 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void*)UsbPass);
        }
        break;
      case FU_VOLUME_CONTROL:
        if(pAudioReqPacket->bRequest & 0x80)
        {
          // Read different volume values
          if((pAudioReqPacket->wLength.Word == 2) &&
              AudioFeatureGetReg(pAudioReqPacket->bRequest,pAudioReqPacket->wIndex.Hi))
          {
            pAdioReqCtrl->Counter = 2;
            pAdioReqCtrl->pData = AudioBuf;
            return((void*)UsbPass);
          }
        }
        else if((pAudioReqPacket->bRequest == REQUEST_SET_CUR) &&
                (pAudioReqPacket->wLength.Word  == 2))
        {
          // Set volume value
          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 *)UsbPass);
        }
        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*)UsbPass);
          }
        }
        else
        {
          // Set channel
          AudioRequest  = pAudioReqPacket->bRequest;
          AudioId       = pAudioReqPacket->wIndex.Hi;
          AudioDataSize = pAudioReqPacket->wLength.Word;
          pAdioReqCtrl->Counter = 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void *)UsbPass);
        }
      }
    }
    return((void *)UsbFault);
  case UsbRecipientEndpoint:
    return((void *)UsbFault);
  }
  return((void *)UsbFault);
}

/*************************************************************************
 * Function Name: UsbClassAudioData
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: USB Class Audio Data receive
 *
 *************************************************************************/
void * UsbClassAudioData (void * pArg)
{
  if(AudioId == FeatUnit1Id)
  {
    switch (AudioCS)
    {
    case FU_MUTE_CONTROL:
      // Set mute flag
      if (AudioId == FeatUnit1Id)
      {
        AudioFeat1Mute = AudioBuf[0];
      }
      else
      {
        return((void*)UsbFault);
      }
      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];
        }
      }
      else
      {
        return((void*)UsbFault);
      }
      break;
    default:
      return((void*)UsbFault);
    }
  }
  else if (AudioId == SelUnit1ID)
  {
    // empty
  }
  else
  {
    return((void*)UsbFault);
  }
  return((void*)UsbPass);
}