netease
/
SmartAudio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
SmartAudio/package/allwinner/tina_multimedia/libcedarx/demo/demoAdecoder/tinyplaydemo.c

578 lines
17 KiB
C
Executable File
Raw Blame History

/*
* Copyright (c) 2008-2017 Allwinner Technology Co. Ltd.
* All rights reserved.
*
* File : tinyplaydemo.c
* Description : demoAdecoder
* History :
*
*/
#include "tinyplaydemo.h"
#include "demo_utils.h"
#include <fcntl.h>
#ifdef LOG_TAG
#undef LOG_TAG
#define LOG_TAG "Tinyplaydemo"
#endif
#define DEMO_DEBUG 1
#define ID_RIFF 0x46464952
#define ID_WAVE 0x45564157
#define ID_FMT 0x20746d66
#define ID_DATA 0x61746164
typedef struct name_map_t
{
char name_linux[32];
char name_android[32];
}name_map;
#define AUDIO_MAP_CNT 16
#define AUDIO_NAME_CODEC "AUDIO_CODEC"
#define AUDIO_NAME_HDMI "AUDIO_HDMI"
#define AUDIO_NAME_SPDIF "AUDIO_SPDIF"
#define AUDIO_NAME_I2S "AUDIO_I2S"
#define AUDIO_NAME_RT3261 "AUDIO_CODEC_RT"
#define AUDIO_NAME_RT3261_RAW "RT3261_RAW"
#define AUDIO_NAME_MIX "AUDIO_MIX"
#define AUDIO_NAME_BT "AUDIO_BT"
static name_map audio_name_map[AUDIO_MAP_CNT] =
{
{"snddaudio", AUDIO_NAME_CODEC},//A80
{"audiocodec", AUDIO_NAME_CODEC},//A31,A20
{"sndacx00codec", AUDIO_NAME_CODEC},//H6
{"sndhdmi", AUDIO_NAME_HDMI},
{"rt3261aif2", AUDIO_NAME_RT3261_RAW},
{"sndspdif", AUDIO_NAME_SPDIF},
{"rt3261", AUDIO_NAME_RT3261},
{"snddaudio2", AUDIO_NAME_BT},
{"sndahub", AUDIO_NAME_MIX},
};
enum SND_AUIDO_RAW_DATA_TYPE
{
SND_AUDIO_RAW_DATA_UNKOWN = 0,
SND_AUDIO_RAW_DATA_PCM = 1,
SND_AUDIO_RAW_DATA_AC3 = 2,
SND_AUDIO_RAW_DATA_MPEG1 = 3,
SND_AUDIO_RAW_DATA_MP3 = 4,
SND_AUDIO_RAW_DATA_MPEG2 = 5,
SND_AUDIO_RAW_DATA_AAC = 6,
SND_AUDIO_RAW_DATA_DTS = 7,
SND_AUDIO_RAW_DATA_ATRAC = 8,
SND_AUDIO_RAW_DATA_ONE_BIT_AUDIO = 9,
SND_AUDIO_RAW_DATA_DOLBY_DIGITAL_PLUS = 10,
SND_AUDIO_RAW_DATA_DTS_HD = 11,
SND_AUDIO_RAW_DATA_MAT = 12,
SND_AUDIO_RAW_DATA_DST = 13,
SND_AUDIO_RAW_DATA_WMAPRO = 14
};
struct riff_wave_header {
uint32_t riff_id;
uint32_t riff_sz;
uint32_t wave_id;
};
struct chunk_header {
uint32_t id;
uint32_t sz;
};
struct chunk_fmt {
uint16_t audio_format;
uint16_t num_channels;
uint32_t sample_rate;
uint32_t byte_rate;
uint16_t block_align;
uint16_t bits_per_sample;
};
static int find_name_map(AudioDsp *adev, char * in, char * out)
{
int index = 0;
CDX_UNUSE(adev);
if (in == 0 || out == 0)
{
demo_loge("error params");
return -1;
}
for (; index < AUDIO_MAP_CNT; index++)
{
if (strlen(audio_name_map[index].name_linux) == 0)
{
//sprintf(out, "AUDIO_USB%d", adev->usb_audio_cnt++);
sprintf(out, "AUDIO_USB_%s", in);
strcpy(audio_name_map[index].name_linux, in);
strcpy(audio_name_map[index].name_android, out);
demo_logd("linux name = %s, android name = %s",
audio_name_map[index].name_linux,
audio_name_map[index].name_android);
return 0;
}
if (!strcmp(in, audio_name_map[index].name_linux))
{
strcpy(out, audio_name_map[index].name_android);
demo_logd("linux name = %s, android name = %s",
audio_name_map[index].name_linux,
audio_name_map[index].name_android);
return 0;
}
}
return 0;
}
static int do_init_audio_card(AudioDsp *adev, int card)
{
int ret = -1;
int fd = 0;
char * snd_path = "/sys/class/sound";
char snd_card[128], snd_node[128];
char snd_id[32], snd_name[32];
memset(snd_card, 0, sizeof(snd_card));
memset(snd_node, 0, sizeof(snd_node));
memset(snd_id, 0, sizeof(snd_id));
memset(snd_name, 0, sizeof(snd_name));
sprintf(snd_card, "%s/card%d", snd_path, card);
ret = access(snd_card, F_OK);
if(ret == 0)
{
// id / name
sprintf(snd_node, "%s/card%d/id", snd_path, card);
demo_logd("1... read card %s/card%d/id",snd_path, card);
fd = open(snd_node, O_RDONLY);
if (fd > 0)
{
ret = read(fd, snd_id, sizeof(snd_id));
if (ret > 0)
{
snd_id[ret - 1] = '\0';
demo_logd("2.... %s, %s, card: %d", snd_node, snd_id, card);
}
close(fd);
}
else
{
demo_logd("3.... fd fail ....%s, %s, len: %d", snd_node, snd_id, card);
return -1;
}
strcpy(adev->dev_manager[card].card_id, snd_id);
find_name_map(adev, snd_id, snd_name);
strcpy(adev->dev_manager[card].name, snd_name);
adev->dev_manager[card].card = card;
adev->dev_manager[card].device = 0;
adev->dev_manager[card].flag_exist = true;
// playback device
sprintf(snd_node, "%s/card%d/pcmC%dD0p", snd_path, card, card);
ret = access(snd_node, F_OK);
if(ret == 0)
{
// there is a playback device
adev->dev_manager[card].flag_out = AUDIO_OUT;
adev->dev_manager[card].flag_out_active = 0;
}
// capture device
sprintf(snd_node, "%s/card%d/pcmC%dD0c", snd_path, card, card);
ret = access(snd_node, F_OK);
if(ret == 0)
{
// there is a capture device
adev->dev_manager[card].flag_in = AUDIO_IN;
adev->dev_manager[card].flag_in_active = 0;
}
}
else
{
return -1;
}
return 0;
}
static void init_audio_devices(AudioDsp *adev)
{
int card = 0;
memset(adev->dev_manager, 0, sizeof(adev->dev_manager));
for (card = 0; card < MAX_AUDIO_DEVICES; card++)
{
if (do_init_audio_card(adev, card) == 0)
{
// break;
demo_logd("card: %d, name: %s, capture: %d, playback: %d",
card, adev->dev_manager[card].name,
adev->dev_manager[card].flag_in == AUDIO_IN,
adev->dev_manager[card].flag_out == AUDIO_OUT);
}
}
}
static void getCardNumbyName(AudioDsp *adev, char *name, int *card)
{
int index;
for (index = 0; index < MAX_AUDIO_DEVICES; index++) {
if (!strcmp(adev->dev_manager[index].name, name)) {
*card = index;
demo_logd("getCardNumbyName: name = %s , card = %d",name, index);
demo_logd("NAME = %s",adev->dev_manager[index].name);
return;
}
}
for (index = 0; index < MAX_AUDIO_DEVICES; index++) {
if (!strncmp(adev->dev_manager[index].name, "AUDIO_USB", 9)
&& !strncmp(name, "AUDIO_USB", 9)
&& adev->dev_manager[index].flag_exist) {
*card = index;
demo_logd("USBNAME = %s",adev->dev_manager[index].name);
demo_logd("getCardNumbyName: name = %s , card = %d",name, index);
break;
}
}
demo_logd("card 0 name = %s",adev->dev_manager[0].name);
if (index == MAX_AUDIO_DEVICES) {
demo_logd("BT");
*card = -1;
demo_loge("%s card does not exist",name);
}
}
#ifdef H6_AUDIO_HUB
void enble_hub_hdmi(struct mixer *mixer)
{
demo_logd("enble_hub_hdmi");
struct mixer_ctl *ctl;
//i2s1->APBIF_TXDIF0
ctl = mixer_get_ctl_by_name(mixer, "I2S1 Src Select");
mixer_ctl_set_value(ctl, 0, 1);
//enble i2s1
ctl = mixer_get_ctl_by_name(mixer, "I2S1OUT Switch");
mixer_ctl_set_value(ctl, 0, 1);
}
void close_hub_hdmi(struct mixer *mixer)
{
demo_logd("close_hub_hdmi");
struct mixer_ctl *ctl;
//i2s1->APBIF_TXDIF0
ctl = mixer_get_ctl_by_name(mixer, "I2S1 Src Select");
mixer_ctl_set_value(ctl, 0, 0);
//close i2s1
ctl = mixer_get_ctl_by_name(mixer, "I2S1OUT Switch");
mixer_ctl_set_value(ctl, 0, 0);
}
static int set_ahub_rontiue(int ahub_card_id, const char* name, int on_off)
{
struct mixer *audio_hub_mixer = mixer_open(ahub_card_id);
if(!audio_hub_mixer)
{
demo_loge("Unable to open the audio_hub_mixer, aborting...");
return -1;
}
//Now only fix the HDMI scenoris
if(on_off != 0)//enable...
{
if(!strcmp(name, AUDIO_NAME_HDMI))
{
demo_logi("ahub enable hdmi hub...");
enble_hub_hdmi(audio_hub_mixer);
}
}
else//shut down...
{
if(!strcmp(name, AUDIO_NAME_HDMI))
{
demo_logi("ahub shut down hdmi hub...");
close_hub_hdmi(audio_hub_mixer);
}
}
mixer_close(audio_hub_mixer);
audio_hub_mixer = NULL;
return 0;
}
#endif
static int set_raw_flag(AudioDsp* dsp, int card, int raw_flag)
{
demo_logi("set_raw_flag(card=%d, raw_flag=%d)", card, raw_flag);
struct mixer *mixer = mixer_open(card);
if (!mixer) {
demo_loge("Unable to open the mixer, aborting...");
return -1;
}
const char *control_name = (card == dsp->cardHDMI) ? "hdmi audio format Function":
(card == dsp->cardMIX) ? "ahub audio format Function":
"spdif audio format Function";
demo_logi("control_name : %s, card : %d", control_name, card);
const char *control_value = (raw_flag==SND_AUDIO_RAW_DATA_AC3) ? "AC3" :
(raw_flag==SND_AUDIO_RAW_DATA_DOLBY_DIGITAL_PLUS) ? "DOLBY_DIGITAL_PLUS":
(raw_flag==SND_AUDIO_RAW_DATA_MAT) ? "MAT":
(raw_flag==SND_AUDIO_RAW_DATA_DTS) ? "DTS" : "pcm";
struct mixer_ctl *audio_format = mixer_get_ctl_by_name(mixer, control_name);
if (audio_format)
mixer_ctl_set_enum_by_string(audio_format, control_value);
mixer_close(mixer);
return 0;
}
int check_param(struct pcm_params *params, unsigned int param, unsigned int value,
char *param_name, char *param_unit)
{
unsigned int min;
unsigned int max;
int is_within_bounds = 1;
min = pcm_params_get_min(params, param);
if (value < min) {
demo_loge("%s is %u%s, device only supports >= %u%s", param_name, value,
param_unit, min, param_unit);
is_within_bounds = 0;
}
max = pcm_params_get_max(params, param);
if (value > max) {
demo_loge("%s is %u%s, device only supports <= %u%s", param_name, value,
param_unit, max, param_unit);
is_within_bounds = 0;
}
return is_within_bounds;
}
static int sample_is_playable(unsigned int card, unsigned int device, unsigned int channels,
unsigned int rate, unsigned int bits, unsigned int period_size,
unsigned int period_count)
{
struct pcm_params *params;
int can_play;
demo_loge("line : %d, card:%u, device:%u",__LINE__, card, device);
params = pcm_params_get(card, device, PCM_OUT);
if (params == NULL) {
demo_loge("Unable to open PCM device %u", device);
return 0;
}
demo_loge("line : %d, card:%u, device:%u",__LINE__, card, device);
can_play = check_param(params, PCM_PARAM_RATE, rate, "Sample rate", "Hz");
can_play &= check_param(params, PCM_PARAM_CHANNELS, channels, "Sample", " channels");
can_play &= check_param(params, PCM_PARAM_SAMPLE_BITS, bits, "Bitrate", " bits");
can_play &= check_param(params, PCM_PARAM_PERIOD_SIZE, period_size, "Period size", "Hz");
can_play &= check_param(params, PCM_PARAM_PERIODS, period_count, "Period count", "Hz");
pcm_params_free(params);
return can_play;
}
int DspWrite(AudioDsp* dsp, void *pPcmData, int nPcmDataLen)
{
void* buf_conv = NULL;
int buf_conv_len = 0;
int samples = 0;
if(!dsp)
return -1;
if(!dsp->start)
{
dsp->config.channels = dsp->ch;
dsp->config.rate = dsp->spr;
dsp->config.period_size = dsp->period_size;
dsp->config.period_count = dsp->period_count;
dsp->config.raw_flag = dsp->raw_flag;
if (dsp->bps == 32)
dsp->config.format = PCM_FORMAT_S32_LE;
else if (dsp->bps == 24)
dsp->config.format = PCM_FORMAT_S24_LE;
else
dsp->config.format = PCM_FORMAT_S16_LE;
demo_logi("dsp->bps : %d", dsp->bps);
dsp->config.start_threshold = 0;
dsp->config.stop_threshold = 0;
dsp->config.silence_threshold = 0;
if(set_raw_flag(dsp, dsp->cardHDMI, dsp->raw_flag) < 0){
demo_loge("can not set raw flag...");
return -1;
}
demo_logi("hdmi , raw_flag : %d, ch : %d, spr : %d, period_size : %d, period_count : %d",
dsp->config.raw_flag, dsp->config.channels , dsp->config.rate, dsp->config.period_size,
dsp->config.period_count);
#ifdef H6_AUDIO_HUB
dsp->hubconfig = dsp->config;
if(set_raw_flag(dsp, dsp->cardMIX, dsp->raw_flag) < 0){
demo_loge("can not set raw flag...");
return -1;
}
demo_logi("ahub , raw_flag : %d, ch : %d, spr : %d, period_size : %d, period_count : %d",
dsp->hubconfig.raw_flag, dsp->hubconfig.channels , dsp->hubconfig.rate,
dsp->hubconfig.period_size, dsp->hubconfig.period_count);
set_ahub_rontiue(dsp->cardMIX, AUDIO_NAME_HDMI, 1);
dsp->pcmhub = pcm_open(dsp->cardMIX, dsp->device, PCM_OUT, &dsp->hubconfig);
if (!dsp->pcmhub || !pcm_is_ready(dsp->pcmhub)) {
demo_loge("Unable to open PCM device %d (%s)\n",
dsp->device, pcm_get_error(dsp->pcmhub));
return -1;
}
#else
dsp->pcm = pcm_open(dsp->cardHDMI, dsp->device, PCM_OUT, &dsp->config);
if (!dsp->pcm || !pcm_is_ready(dsp->pcm)) {
demo_loge("Unable to open PCM device %u (%s)\n",
dsp->device, pcm_get_error(dsp->pcm));
return -1;
}
#endif
dsp->start = 1;
}
if(nPcmDataLen > 0)
{
if (dsp->bps == 24)
{
int idx = 0, jdx = 0;
char* dst = NULL;
char* src = NULL;
samples = nPcmDataLen * 8/ dsp->ch / dsp->bps;
buf_conv_len = nPcmDataLen*4/3;
DEMO_VERBOS_SAFE_MALLOC(buf_conv, buf_conv_len,
demo_loge("Error no mem for conventer buffer...");\
return -1;
)
dst = (char*)buf_conv;
for(idx = 0; idx < dsp->ch; idx++)
{
dst = ((char*)buf_conv) + 4*idx;
src = ((char*)pPcmData) + 3*idx;
for(jdx = 0; jdx < samples; jdx++){
dst[0] = src[0]&0xff;
dst[1] = src[1]&0xff;
dst[2] = src[2]&0xff;
dst[3] = (dst[2]&0x80)?0xff:0x00;
dst += 4*dsp->ch;
src += 3*dsp->ch;
}
}
#ifdef H6_AUDIO_HUB
if (pcm_write(dsp->pcmhub, buf_conv, buf_conv_len) < 0)
#else
if (pcm_write(dsp->pcm, buf_conv, buf_conv_len) < 0)
#endif
{
demo_loge("Error playing sample...");
DEMO_SAFE_FREE(buf_conv, "buf_conv", 0)
return -1;
}
DEMO_SAFE_FREE(buf_conv, "buf_conv", 0)
}
else
{
#ifdef H6_AUDIO_HUB
if (pcm_write(dsp->pcmhub, pPcmData, nPcmDataLen) < 0)
#else
if (pcm_write(dsp->pcm, pPcmData, nPcmDataLen) < 0)
#endif
{
demo_loge("Error playing sample...");
return -1;
}
}
}
else
demo_loge("Invaild write len : %d", nPcmDataLen);
return nPcmDataLen;
}
int DspStop(AudioDsp* dsp)
{
if(!dsp)
return -1;
if(dsp->start)
{
#ifdef H6_AUDIO_HUB
if(dsp->pcmhub)
{
pcm_close(dsp->pcmhub);
dsp->pcmhub = NULL;
set_ahub_rontiue(dsp->cardMIX, AUDIO_NAME_HDMI, 0);
demo_logi("Dsp pcmhub device closed ...");
}
#else
if(dsp->pcm)
{
pcm_close(dsp->pcm);
dsp->pcm = NULL;
demo_logi("Dsp pcm device closed ...");
}
#endif
dsp->start = 0;
}
else
{
demo_logd("dsp stop while unactive...");
}
return 0;
}
void DspWaitForDevConsume(int waitms)
{
usleep(waitms * 1000);
}
extern void NotifyHalDirect(int on_off);
AudioDsp* CreateAudioDsp()
{
AudioDsp* pMem = NULL;
DEMO_VERBOS_SAFE_MALLOC(pMem, sizeof(AudioDsp),
demo_loge("CreateAudioDsp fail for no mem...");\
return NULL;
);
NotifyHalDirect(1);
init_audio_devices(pMem);
getCardNumbyName(pMem, AUDIO_NAME_CODEC, &pMem->cardCODEC);
getCardNumbyName(pMem, AUDIO_NAME_HDMI, &pMem->cardHDMI);
getCardNumbyName(pMem, AUDIO_NAME_SPDIF, &pMem->cardSPDIF);
getCardNumbyName(pMem, AUDIO_NAME_BT, &pMem->cardBT);
getCardNumbyName(pMem, AUDIO_NAME_MIX, &pMem->cardMIX);
demo_logi("cardCODEC : %d, cardHDMI: %d, cardSPDIF: %d, cardBT: %d, cardMIX: %d",
pMem->cardCODEC, pMem->cardHDMI, pMem->cardSPDIF, pMem->cardBT, pMem->cardMIX);
return pMem;
}
void DeleteAudioDsp(AudioDsp* dsp)
{
AudioDsp* pMem = NULL;
pMem = dsp;
if(!pMem)
{
demo_loge("DeleteAudioDsp strange for null ptr...");
return;
}
DspStop(pMem);
NotifyHalDirect(0);
DEMO_SAFE_FREE(pMem, "AudioDsp", 1)
}
Reference in New Issue View Git Blame Copy Permalink