mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
0ad3017df7
1. move btif and A2DP source code from project directory to bluetooth directory; 2. some updates of audio source code;
389 lines
11 KiB
C
389 lines
11 KiB
C
/*
|
|
* ESPRSSIF MIT License
|
|
*
|
|
* Copyright (c) 2015 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
|
|
*
|
|
* Permission is hereby granted for use on ESPRESSIF SYSTEMS ESP8266 only, in which case,
|
|
* it is free of charge, to any person obtaining a copy of this software and associated
|
|
* documentation files (the "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
|
|
* to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all copies or
|
|
* substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include "MediaHal.h"
|
|
#include "audio_log.h"
|
|
#include "driver/gpio.h"
|
|
#include "esp_types.h"
|
|
//#include "inc/Vs10xx.h"
|
|
#include "AP80/Ap80xx.h"
|
|
#include "EspAudioCom.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "MyString.h"
|
|
#include "ES8388.h"
|
|
|
|
// 2---ES8388
|
|
// 1---AP8048
|
|
// 0---VS1053
|
|
|
|
#define PA_POINT_PWR 25 // GPIO25
|
|
#define AP_POINT_PWR 26 // GPIO26
|
|
|
|
#define CODECTYPE 1
|
|
static char* LOGPRE = "[mediaHal Err]";
|
|
static char* LOGPRD = "[mediaHal Info]";
|
|
|
|
|
|
static MediaState mediaStatus = 0;
|
|
static uint32_t mediaVol = 50;
|
|
|
|
void mediaHalInit(void)
|
|
{
|
|
#if CODECTYPE==0
|
|
VS_Init();
|
|
VS_Sine_Test();
|
|
VS_HD_Reset();
|
|
VS_Soft_Reset();
|
|
VS_Set_All();
|
|
#elif CODECTYPE==1
|
|
// AP8048 PWRKEY
|
|
gpio_config_t io_conf;
|
|
memset(&io_conf, 0, sizeof(io_conf));
|
|
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO26_U, FUNC_GPIO26_GPIO26);
|
|
SET_PERI_REG_MASK(PERIPHS_IO_MUX_GPIO26_U, FUN_PU);
|
|
|
|
io_conf.pin_bit_mask = GPIO_SEL_26;
|
|
io_conf.mode = GPIO_MODE_OUTPUT;
|
|
io_conf.intr_type = GPIO_PIN_INTR_DISABLE ;
|
|
gpio_config(&io_conf);
|
|
gpio_set_level(AP_POINT_PWR, 0x01); // Enable the AP80 powerkey
|
|
|
|
// PA PWR
|
|
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO25_U, FUNC_GPIO25_GPIO25);
|
|
SET_PERI_REG_MASK(PERIPHS_IO_MUX_GPIO25_U, FUN_PU);
|
|
gpio_set_level(PA_POINT_PWR, 0x01);
|
|
|
|
apInit();
|
|
#elif CODECTYPE==2
|
|
ES8388_init();
|
|
|
|
#endif
|
|
mediaStatus = MediaState_Initialized;
|
|
LOGI("mediaHalInit ok");
|
|
}
|
|
|
|
MediaErr mediaHalDataRead(uint8_t *dat, int *len)
|
|
{
|
|
if ((NULL == dat)
|
|
/*|| (MediaState_Playing != mediaStatus)*/) {
|
|
printf("%s,[func]%s,MediaState is not playing[%x]\r\n", LOGPRE, __func__, mediaStatus);
|
|
return MediaErr_ParaError;
|
|
}
|
|
uint32_t ret = 0;
|
|
#if CODECTYPE==0
|
|
ret = VS_Send_MusicData(dat);
|
|
#elif CODECTYPE==1
|
|
ret = apMicReadData(dat, (uint16_t*)len);
|
|
#endif
|
|
if (ret != MediaErr_NoError) {
|
|
printf("%s,[func]%s,Send data to codec failed,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
return MediaErr_CodecError;
|
|
} else {
|
|
return MediaErr_NoError;
|
|
}
|
|
}
|
|
|
|
MediaErr mediaHalDataWrite(uint8_t *dat, int len)
|
|
{
|
|
if ((NULL == dat)
|
|
|| (MediaState_Playing != mediaStatus)) {
|
|
printf("%s,[func]%s,MediaState is not playing[%x]\r\n", LOGPRE, __func__, mediaStatus);
|
|
return MediaErr_ParaError;
|
|
}
|
|
uint32_t ret = 0;
|
|
#if CODECTYPE==0
|
|
ret = VS_Send_MusicData(dat);
|
|
#elif CODECTYPE==1
|
|
ret = apSendData(dat, len);
|
|
#endif
|
|
if (ret != MediaErr_NoError) {
|
|
printf("%s,[func]%s,Send data to codec failed,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
return MediaErr_CodecError;
|
|
} else {
|
|
return MediaErr_NoError;
|
|
}
|
|
}
|
|
|
|
void mediaHalReset(void)
|
|
{
|
|
// VS_HD_Reset();
|
|
//VS_Soft_Reset();
|
|
}
|
|
|
|
MediaErr mediaHalPlay(EspAudioMeidaType type)
|
|
{
|
|
uint32_t ret = 0;
|
|
#if CODECTYPE==0
|
|
VS_Restart_Play(); //
|
|
VS_Reset_DecodeTime(); //
|
|
VS_SPI_SpeedHigh();
|
|
#else
|
|
if ((MediaState_Initialized == mediaStatus)
|
|
|| (MediaState_Stoped == mediaStatus)) {
|
|
if (EspAudioMeidaType_Aac == type) {
|
|
ret = apPlayStart("radio", sizeof("radio"), AAC_DECODER);
|
|
} else if (EspAudioMeidaType_Mp3 == type) {
|
|
ret = apPlayStart("radio", sizeof("radio"), MP3_DECODER);
|
|
} else if (EspAudioMeidaType_Wav == type) {
|
|
ret = apPlayStart("radio", sizeof("radio"), WAV_DECODER);
|
|
} else if (EspAudioMeidaType_Flac == type) {
|
|
ret = apPlayStart("radio", sizeof("radio"), FLAC_DECODER);
|
|
} else if (EspAudioMeidaType_Opus == type) {
|
|
ret = apPlayStart("radio", sizeof("radio"), OPUS_DECODER);
|
|
} else if (EspAudioMeidaType_Pcm == type) {
|
|
ret = apPlayStart("radio", sizeof("radio"), PCM_DECODER);
|
|
}
|
|
else {
|
|
printf("%s,[func]%s,Music type[%d] does not support\r\n", LOGPRE, __func__, type);
|
|
}
|
|
} else {
|
|
apPlayResume();
|
|
}
|
|
|
|
printf("%s,[func]%s, mediaStatus=%d\r\n", LOGPRD, __func__, mediaStatus);
|
|
#endif
|
|
mediaStatus = MediaState_Playing;
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
MediaErr mediaHalPause(void)
|
|
{
|
|
uint32_t ret = 0;
|
|
if (MediaState_Playing == mediaStatus) {
|
|
apPlayPause();
|
|
mediaStatus = MediaState_Paused;
|
|
}
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
printf("%s,[func]%s,mediaStatus=%d\r\n", LOGPRD, __func__, mediaStatus);
|
|
return ret;
|
|
}
|
|
|
|
MediaErr mediaHalStop(void)
|
|
{
|
|
|
|
uint32_t ret = 0;
|
|
#if CODECTYPE==0
|
|
VS_Cancel();
|
|
#elif CODECTYPE==1
|
|
|
|
apPlayStop();
|
|
#endif
|
|
mediaStatus = MediaState_Stoped;
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MediaErr mediaHalVolumeSet(uint8_t value)
|
|
{
|
|
uint32_t ret = 0;
|
|
uint32_t tmp = value;
|
|
LOGD("volmue=%d", tmp);
|
|
|
|
#if CODECTYPE==0
|
|
vsset.mvol = value;
|
|
mediaVol = vsset.mvol;
|
|
tmp = (value * 200) / 100 + 50;
|
|
mediaVol = tmp;
|
|
VS_Set_Vol(tmp); // when vs1053 does not init,this call will be hang.
|
|
#elif CODECTYPE==1
|
|
|
|
ret = apVolSet(tmp);
|
|
#endif
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MediaErr mediaHalMute(void)
|
|
{
|
|
uint32_t ret = 0;
|
|
#if CODECTYPE==0
|
|
VS_Set_Vol(0);
|
|
#elif CODECTYPE==1
|
|
|
|
ret = apVolMuteEnable();
|
|
#endif
|
|
mediaVol = 0;
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MediaErr mediaHalStatusGet(MediaState *staus)
|
|
{
|
|
if (NULL == staus) {
|
|
return MediaErr_ParaError;
|
|
}
|
|
*staus = mediaStatus;
|
|
return MediaErr_NoError;
|
|
}
|
|
|
|
void mediaHalSleep(void)
|
|
{
|
|
// GPIO_OUTPUT_SET(PA_POINT_PWR, 0);
|
|
// GPIO_OUTPUT_SET(AP_POINT_PWR, 0);
|
|
printf("%s mediaHal sleep\r\n", LOGPRE);
|
|
}
|
|
|
|
void mediaHalWakeup(void)
|
|
{
|
|
// GPIO_OUTPUT_SET(PA_POINT_PWR, 1);
|
|
// GPIO_OUTPUT_SET(AP_POINT_PWR, 1);
|
|
printf("%s Codec wakeup\r\n", LOGPRE);
|
|
}
|
|
|
|
MediaErr mediaHalDecodeTimeRest()
|
|
{
|
|
uint32_t ret = apRestDecodeTime();
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MediaErr mediaHalDecodeTimeGet(uint32_t *time)
|
|
{
|
|
if (NULL == time) {
|
|
return MediaErr_ParaError;
|
|
}
|
|
uint32_t ret = apGetDecodeTime((DecodeTime*)time);
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MediaErr mediaHalMusicInfoGet(MusicInfo *info)
|
|
{
|
|
if (NULL == info) {
|
|
return MediaErr_ParaError;
|
|
}
|
|
uint32_t ret = apGetInfo((SongInformation*)info);
|
|
if (ret != OK_RESPONSE) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
ret = MediaErr_CodecError;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MediaErr mediaHalModeSet(MediaMode mode, MusicInfo* info)
|
|
{
|
|
MediaErr err = MediaErr_NoError;
|
|
uint8_t ret = OK_RESPONSE;
|
|
|
|
|
|
switch (mode) {
|
|
case MediaMode_Encode:
|
|
{
|
|
setEnccodeInfo tmpInfo;
|
|
memset(&tmpInfo, 0, sizeof(tmpInfo));
|
|
ret = apSetEncodeMode();
|
|
tmpInfo.streamDirection = 1;
|
|
tmpInfo.numChannels = info->num_channels;
|
|
tmpInfo.sampleRate = info->sampling_rate;
|
|
tmpInfo.encoderType = info->stream_type; //OPUS_ENCODER;
|
|
ret = apEncodeStart();
|
|
ret += apSetEncodeInfo(&tmpInfo);
|
|
LOGD("apSetEncodeInfo ret = %d %d\n", ret, tmpInfo.encoderType,
|
|
tmpInfo.sampleRate, tmpInfo.numChannels);
|
|
break;
|
|
}
|
|
case MediaMode_Decode:
|
|
{
|
|
setDecodeInfo tmpInfo;
|
|
memset(&tmpInfo, 0, sizeof(tmpInfo));
|
|
ret = apSetDecodeMode();
|
|
tmpInfo.streamDirection = 0;
|
|
tmpInfo.numChannels = info->num_channels;
|
|
tmpInfo.sampleRate = info->sampling_rate;
|
|
|
|
ret += apSetDecodeInfo(&tmpInfo);
|
|
LOGD("apSetDecodeInfo ret=%d\n", ret);
|
|
|
|
break;
|
|
}
|
|
case MediaMode_AuxIn:
|
|
ret = apSetDecodeMode();
|
|
break;
|
|
default:
|
|
err = MediaErr_NotSuport;
|
|
break;
|
|
}
|
|
if ((ret != OK_RESPONSE) && (ERROR_OTHER!= ret)) {
|
|
printf("%s,[func]%s,ret=%d\r\n", LOGPRE, __func__, ret);
|
|
err = MediaErr_CodecError;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
EspAudioMeidaType checkMediaType(const char* targetUri)
|
|
{
|
|
EspAudioMeidaType type;
|
|
if (EndsWith(targetUri, ".wav", 1) != 0) {
|
|
type = EspAudioMeidaType_Wav;
|
|
} else if (EndsWith(targetUri, ".aac", 1) != 0) {
|
|
type = EspAudioMeidaType_Aac;
|
|
} else if (EndsWith(targetUri, ".mp3", 1) != 0) {
|
|
type = EspAudioMeidaType_Mp3;
|
|
} else if (EndsWith(targetUri, ".amr", 1) != 0) {
|
|
type = EspAudioMeidaType_Amr;
|
|
} else if (EndsWith(targetUri, ".alac", 1) != 0) {
|
|
type = EspAudioMeidaType_Alac;
|
|
} else if (EndsWith(targetUri, ".flac", 1) != 0) {
|
|
type = EspAudioMeidaType_Flac;
|
|
} else if (EndsWith(targetUri, ".ape", 1) != 0) {
|
|
type = EspAudioMeidaType_Ape;
|
|
} else if (EndsWith(targetUri, ".m3u8", 1) != 0) {
|
|
type = EspAudioMeidaType_M3u;
|
|
} else if (EndsWith(targetUri, ".opu", 1) != 0) {
|
|
type = EspAudioMeidaType_Opus;
|
|
} else if (EndsWith(targetUri, ".pcm", 1) != 0) {
|
|
type = EspAudioMeidaType_Pcm;
|
|
} else {
|
|
type = EspAudioMeidaType_Unknown;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
// end
|