int alsa_init(struct device_t *dv, const char *device_name,
int rate, int buffer_time)
{
struct alsa_t *alsa;
alsa = malloc(sizeof(struct alsa_t));
if (!alsa) {
perror("malloc");
return -1;
}
if (pcm_open(&alsa->capture, device_name, SND_PCM_STREAM_CAPTURE,
rate, buffer_time) < 0)
{
fputs("Failed to open device for capture.\n", stderr);
goto fail;
}
if (pcm_open(&alsa->playback, device_name, SND_PCM_STREAM_PLAYBACK,
rate, buffer_time) < 0)
{
fputs("Failed to open device for playback.\n", stderr);
goto fail;
}
dv->local = alsa;
dv->type = &alsa_type;
return 0;
fail:
free(alsa);
return -1;
}
status_t AudioALSALoopbackController::open(const audio_devices_t output_devices, const audio_devices_t input_device)
{
ALOGD("+%s(), output_devices = 0x%x, input_device = 0x%x", __FUNCTION__, output_devices, input_device);
AudioAutoTimeoutLock _l(mLock);
AudioAutoTimeoutLock _l2(*AudioALSADriverUtility::getInstance()->getStreamSramDramLock());
// DL loopback setting
memset(&mConfig, 0, sizeof(mConfig));
mConfig.channels = 2;
mConfig.rate = 48000;
mConfig.period_size = 1024;
mConfig.period_count = 2;
mConfig.format = PCM_FORMAT_S16_LE;
mConfig.start_threshold = 0;
mConfig.stop_threshold = 0;
mConfig.silence_threshold = 0;
ALOGD("+%s(), mConfig.rate=%d", __FUNCTION__,mConfig.rate);
ASSERT(mPcmUL == NULL && mPcmDL == NULL);
mPcmUL = pcm_open(0, 4, PCM_IN, &mConfig);
mPcmDL = pcm_open(0, 4, PCM_OUT, &mConfig);
ASSERT(mPcmUL != NULL && mPcmDL != NULL);
ALOGV("%s(), mPcmUL = %p, mPcmDL = %p", __FUNCTION__, mPcmUL, mPcmDL);
pcm_start(mPcmUL);
pcm_start(mPcmDL);
mHardwareResourceManager->startInputDevice(input_device);
mHardwareResourceManager->startOutputDevice(output_devices, mConfig.rate);
ALOGD("-%s()", __FUNCTION__);
return NO_ERROR;
}
int proxy_open(alsa_device_proxy * proxy)
{
alsa_device_profile* profile = proxy->profile;
ALOGV("proxy_open(card:%d device:%d %s)", profile->card, profile->device,
profile->direction == PCM_OUT ? "PCM_OUT" : "PCM_IN");
if (profile->card < 0 || profile->device < 0) {
return -EINVAL;
}
proxy->pcm = pcm_open(profile->card, profile->device,
profile->direction | PCM_MONOTONIC, &proxy->alsa_config);
if (proxy->pcm == NULL) {
return -ENOMEM;
}
if (!pcm_is_ready(proxy->pcm)) {
ALOGE(" proxy_open() pcm_open() failed: %s", pcm_get_error(proxy->pcm));
#if defined(LOG_PCM_PARAMS)
log_pcm_config(&proxy->alsa_config, "config");
#endif
pcm_close(proxy->pcm);
proxy->pcm = NULL;
return -ENOMEM;
}
return 0;
}
static int hdmi_out_open_pcm(hdmi_out_t *out)
{
int card = hdmi_out_find_card();
int dev = HDMI_PCM_DEV;
int ret;
TRACEM("out=%p", out);
/* out->up must be 0 (down) */
if (out->up) {
ALOGE("Trying to open a PCM that's already up. "
"This will probably deadlock... so aborting");
return 0;
}
out->pcm = pcm_open(card, dev, PCM_OUT, &out->config);
if(out->pcm && pcm_is_ready(out->pcm)) {
out->up = 1;
ret = 0;
} else {
ALOGE("cannot open HDMI pcm card %d dev %d error: %s",
card, dev, pcm_get_error(out->pcm));
pcm_close(out->pcm);
out->pcm = 0;
out->up = 0;
ret = 1;
}
return ret;
}
bool AudioRecordingLocal::doPrepare(AudioHardware::SamplingRate samplingRate, int samplesInOneGo)
{
releaseHw();
struct pcm_config config;
memset(&config, 0, sizeof(config));
config.channels = 2;
config.rate = samplingRate;
config.period_size = 1024;
config.period_count = 32;
config.format = PCM_FORMAT_S16_LE;
config.start_threshold = 0;
config.stop_threshold = 0;
config.silence_threshold = 0;
mPcmHandle = pcm_open(mHwId, 0, PCM_IN, &config);
if (!mPcmHandle || !pcm_is_ready(mPcmHandle)) {
LOGE("Unable to open PCM device(%d) (%s)\n", mHwId, pcm_get_error(mPcmHandle));
return false;
}
mSamples = samplesInOneGo;
mSizes = samplesInOneGo * 4; // stereo, 16bit
mBufferSize = pcm_get_buffer_size(mPcmHandle);
LOGD("buffer size %d, read size %d", mBufferSize, mSizes);
return true;
}
audio_t *
audio_new(audio_config_t *cfg, audio_device_t *device)
{
struct pcm_config config;
struct pcm *pcm;
audio_t *c;
if (cfg->bits != 16 && cfg->bits != 24 && cfg->bits != 32) {
errno = EINVAL;
return NULL;
}
config.channels = cfg->channels;
config.rate = cfg->rate;
config.period_size = 1024;
config.period_count = 4;
config.format = cfg->bits == 16 ? PCM_FORMAT_S16_LE : cfg->bits == 32 ? PCM_FORMAT_S32_LE : PCM_FORMAT_S24_LE;
config.start_threshold = config.stop_threshold = config.silence_threshold = 0;
if ((pcm = pcm_open(device->card, device->device, device->playback ? PCM_OUT : PCM_IN, &config)) == NULL ||
! pcm_is_ready(pcm))
{
fprintf(stderr, "Failed to open: %s\n", pcm_get_error(pcm));
return NULL;
}
c = fatal_malloc(sizeof(*c));
c->pcm = pcm;
c->cfg = *cfg;
c->dev = *device;
c->buffer_size = pcm_frames_to_bytes(pcm, pcm_get_buffer_size(pcm));
return c;
}
auds_t *auds_open(char *fname, data_type_t adt)
{
auds_t *auds=malloc(sizeof(auds_t));
if(!auds) return NULL;
memset(auds, 0, sizeof(auds_t));
int rval=-1;
int err;
auds->channels=2; //default is stereo
if(adt==AUD_TYPE_NONE)
auds->data_type=get_data_type(fname);
else
auds->data_type=adt;
switch(auds->data_type){
case AUD_TYPE_PCM:
rval=pcm_open(auds, fname);
break;
case AUD_TYPE_NONE:
ERRMSG("unknown audio data type\n");
break;
}
if(rval) goto erexit;
return auds;
erexit:
ERRMSG("errror: %s\n",__func__);
auds_close(auds);
return NULL;
}
status_t AudioALSACaptureDataProviderBase::openPcmDriver(const unsigned int device)
{
ALOGD("+%s(), pcm device = %d", __FUNCTION__, device);
ASSERT(mPcm == NULL);
mPcm = pcm_open(kAudioSoundCardIndex, device, PCM_IN, &mConfig);
if (mPcm == NULL)
{
ALOGE("%s(), mPcm == NULL!!", __FUNCTION__);
}
else if (pcm_is_ready(mPcm) == false)
{
ALOGE("%s(), pcm_is_ready(%p) == false due to %s, close pcm.", __FUNCTION__, mPcm, pcm_get_error(mPcm));
pcm_close(mPcm);
mPcm = NULL;
}
else
{
pcm_start(mPcm);
}
ALOGD("-%s(), mPcm = %p", __FUNCTION__, mPcm);
ASSERT(mPcm != NULL);
return NO_ERROR;
}
status_t TinyAudioStreamOut::set(
TinyAudioHardware *hw,
int *pFormat,
uint32_t *pChannels,
uint32_t *pRate)
{
LOGI("TinyAudioStreamOut::set(): asked for rate %dHz, %d channels",
*pRate, *pChannels);
struct pcm_config pcmConfig;
memset(&pcmConfig, 0, sizeof(pcmConfig));
pcmConfig.channels = 2;
pcmConfig.period_size = 2048;
pcmConfig.period_count = 12;
pcmConfig.format = PCM_FORMAT_S16_LE;
// Try 44.1kHz first...
pcmConfig.rate = 44100;
mPcm = pcm_open(0, 0, PCM_OUT, &pcmConfig);
// ...but fall back to 48kHz
if (!mPcm || !::pcm_is_ready(mPcm)) {
pcm_close(mPcm);
pcmConfig.rate = 48000;
mPcm = pcm_open(0, 0, PCM_OUT, &pcmConfig);
}
if (!mPcm || !::pcm_is_ready(mPcm)) {
LOGE("TinyAudioStreamOut::set() failed: %s\n",
::pcm_get_error(mPcm));
pcm_close(mPcm);
return BAD_VALUE;
}
mSampleRate = pcmConfig.rate;
*pRate = pcmConfig.rate;
*pFormat = AudioSystem::PCM_16_BIT;
*pChannels = AudioSystem::CHANNEL_OUT_STEREO;
LOGI("TinyAudioStreamOut::set(): rate %dHz, %d channels",
*pRate, *pChannels);
return NO_ERROR;
}
bool TinyAlsaCtlPortConfig::doOpenStream(StreamDirection streamDirection, std::string &error)
{
struct pcm *&streamHandle = _streamHandle[streamDirection];
struct pcm_config pcmConfig;
const AlsaCtlPortConfig::PortConfig &portConfig = getPortConfig();
// Fill PCM configuration structure
pcmConfig.channels = portConfig.channelNumber;
pcmConfig.rate = portConfig.sampleRate;
// Check Format is supported by the plugin
if (portConfig.format >= pcmFormatTranslationTableSize) {
error = "The format n°" + asString(portConfig.format) +
" is not supported by the TinyAlsa plugin";
return false;
}
uint8_t format = pcmFormatTranslationTable[portConfig.format].formatAsNumerical;
// Check format is supported by Tinyalsa
if (format == std::numeric_limits<uint8_t>::max()) {
error = "The format " + pcmFormatTranslationTable[portConfig.format].formatAsString +
" is not supported by Tinyalsa";
return false;
}
pcmConfig.format = static_cast<pcm_format>(format);
pcmConfig.period_size = _periodTimeMs * pcmConfig.rate / _msPerSec;
pcmConfig.period_count = _nbRingBuffer;
pcmConfig.start_threshold = 0;
pcmConfig.stop_threshold = 0;
pcmConfig.silence_threshold = 0;
pcmConfig.silence_size = 0;
pcmConfig.avail_min = 0;
// Open and configure
streamHandle = pcm_open(getCardNumber(),
getDeviceNumber(),
streamDirection == Capture ? PCM_IN : PCM_OUT,
&pcmConfig);
// Prepare the stream
if (!pcm_is_ready(streamHandle) || (pcm_prepare(streamHandle) != 0)) {
// Format error
error = formatAlsaError(streamDirection, "open", pcm_get_error(streamHandle));
doCloseStream(streamDirection);
return false;
}
return true;
}
static size_t read_frames(void **frames)
{
unsigned int card = 0;
unsigned int device = 0;
int flags = PCM_IN;
const struct pcm_config config = {
.channels = 2,
.rate = 48000,
.format = PCM_FORMAT_S32_LE,
.period_size = 1024,
.period_count = 2,
.start_threshold = 1024,
.silence_threshold = 1024 * 2,
.stop_threshold = 1024 * 2
};
struct pcm *pcm = pcm_open(card, device, flags, &config);
if (pcm == NULL) {
fprintf(stderr, "failed to allocate memory for PCM\n");
return EXIT_FAILURE;
} else if (!pcm_is_ready(pcm)){
pcm_close(pcm);
fprintf(stderr, "failed to open PCM\n");
return EXIT_FAILURE;
}
unsigned int frame_size = pcm_frames_to_bytes(pcm, 1);
unsigned int frames_per_sec = pcm_get_rate(pcm);
*frames = malloc(frame_size * frames_per_sec);
if (*frames == NULL) {
fprintf(stderr, "failed to allocate frames\n");
pcm_close(pcm);
return EXIT_FAILURE;
}
int read_count = pcm_readi(pcm, *frames, frames_per_sec);
size_t byte_count = pcm_frames_to_bytes(pcm, read_count);
pcm_close(pcm);
return byte_count;
}
static int write_file(const void *frames, size_t size)
{
FILE *output_file = fopen("audio.raw", "wb");
if (output_file == NULL) {
perror("failed to open 'audio.raw' for writing");
return EXIT_FAILURE;
}
fwrite(frames, 1, size, output_file);
fclose(output_file);
return 0;
}
void play_sample(FILE *file, unsigned int device, unsigned int channels,
unsigned int rate, unsigned int bits)
{
struct pcm_config config;
struct pcm *pcm0;
char *buffer;
int size;
int num_read;
/*
channels = 2,period_size = 8092; buffer_size = 8092*4 = 32k
channels = 4, period_size = 4096, buffer_size = 4096*8 = 32k
channels = 4, period_size = 2048, buffer_size = 2048*8 = 16k
channels = 4, period_size = 1024, buffer_size = 1024*8 = 8k
*/
config.channels = 4;
config.rate = rate;
config.period_size = 1024;//4096;//2048
config.period_count = 1;
if (bits == 32)
config.format = PCM_FORMAT_S32_LE;
else if (bits == 16)
config.format = PCM_FORMAT_S16_LE;
config.start_threshold = 0;
config.stop_threshold = 0;
config.silence_threshold = 0;
/*0 is audiocodec, 1 is hdmiaudio, 2 is spdif*/
pcm0 = pcm_open(1, device, PCM_OUT, &config);
if (!pcm0 || !pcm_is_ready(pcm0)) {
fprintf(stderr, "Unable to open PCM device %u (%s)\n", device, pcm_get_error(pcm0));
return;
}
size = pcm_get_buffer_size(pcm0);
buffer = malloc(size);
if (!buffer) {
fprintf(stderr, "Unable to allocate %d bytes\n", size);
free(buffer);
pcm_close(pcm0);
return;
}
size =size;
printf("hx-Playing sample:size:%d, %u ch, %u hz, %u bit\n", size, channels, rate, bits);
do {
num_read = fread(buffer, 1, size, file);
if (num_read > 0) {
if (pcm_write(pcm0, buffer, num_read)) {
fprintf(stderr, "Error playing sample\n");
break;
}
}
} while (num_read > 0);
free(buffer);
pcm_close(pcm0);
}
static int write_frames(const void * frames, size_t byte_count){
unsigned int card = 0;
unsigned int device = 0;
int flags = PCM_OUT;
const struct pcm_config config = {
.channels = 2,
.rate = 48000,
.format = PCM_FORMAT_S32_LE,
.period_size = 1024,
.period_count = 2,
.start_threshold = 1024,
.silence_threshold = 1024 * 2,
.stop_threshold = 1024 * 2
};
struct pcm * pcm = pcm_open(card, device, flags, &config);
if (pcm == NULL) {
fprintf(stderr, "failed to allocate memory for PCM\n");
return -1;
} else if (!pcm_is_ready(pcm)){
pcm_close(pcm);
fprintf(stderr, "failed to open PCM\n");
return -1;
}
unsigned int frame_count = pcm_bytes_to_frames(pcm, byte_count);
int err = pcm_writei(pcm, frames, frame_count);
if (err != 0) {
printf("error: %s\n", pcm_get_error(pcm));
}
pcm_close(pcm);
return 0;
}
int main(void)
{
void *frames;
size_t size;
size = read_file(&frames);
if (size == 0) {
return EXIT_FAILURE;
}
if (write_frames(frames, size) < 0) {
return EXIT_FAILURE;
}
free(frames);
return EXIT_SUCCESS;
}
status_t AudioALSACaptureDataProviderBTSCO::open()
{
ALOGD("%s()", __FUNCTION__);
ASSERT(mClientLock.tryLock() != 0); // lock by base class attach
AudioAutoTimeoutLock _l(mEnableLock);
ASSERT(mEnable == false);
// config attribute (will used in client SRC/Enh/... later) // TODO(Harvey): query this
mStreamAttributeSource.audio_format = AUDIO_FORMAT_PCM_16_BIT;
mStreamAttributeSource.audio_channel_mask = AUDIO_CHANNEL_IN_MONO;
mStreamAttributeSource.num_channels = android_audio_legacy::AudioSystem::popCount(mStreamAttributeSource.audio_channel_mask);
mStreamAttributeSource.sample_rate = mWCNChipController->GetBTCurrentSamplingRateNumber();
// pcm config
mConfig.channels = mStreamAttributeSource.num_channels;
mConfig.rate = mStreamAttributeSource.sample_rate;
// Buffer size: 2048(period_size) * 1(ch) * 2(byte) * 4(period_count) = 16 kb
mConfig.period_size = 2048;
mConfig.period_count = 4;
mConfig.format = PCM_FORMAT_S16_LE;
mConfig.start_threshold = 0;
mConfig.stop_threshold = 0;
mConfig.silence_threshold = 0;
ALOGD("%s(), audio_format = %d, audio_channel_mask=%x, num_channels=%d, sample_rate=%d", __FUNCTION__,
mStreamAttributeSource.audio_format, mStreamAttributeSource.audio_channel_mask, mStreamAttributeSource.num_channels, mStreamAttributeSource.sample_rate);
ALOGD("%s(), format = %d, channels=%d, rate=%d", __FUNCTION__,
mConfig.format, mConfig.channels, mConfig.rate);
OpenPCMDump(LOG_TAG);
// enable pcm
ASSERT(mPcm == NULL);
mPcm = pcm_open(0, 12, PCM_IN | PCM_MONOTONIC, &mConfig);
ASSERT(mPcm != NULL && pcm_is_ready(mPcm) == true);
ALOGV("%s(), mPcm = %p", __FUNCTION__, mPcm);
pcm_start(mPcm);
// create reading thread
mEnable = true;
int ret = pthread_create(&hReadThread, NULL, AudioALSACaptureDataProviderBTSCO::readThread, (void *)this);
if (ret != 0)
{
ALOGE("%s() create thread fail!!", __FUNCTION__);
return UNKNOWN_ERROR;
}
return NO_ERROR;
}
unsigned int capture_sample(FILE *file, unsigned int card, unsigned int device,
unsigned int channels, unsigned int rate,
enum pcm_format format, unsigned int period_size,
unsigned int period_count)
{
struct pcm_config config;
struct pcm *pcm;
char *buffer;
unsigned int size;
unsigned int bytes_read = 0;
memset(&config, 0, sizeof(config));
config.channels = channels;
config.rate = rate;
config.period_size = period_size;
config.period_count = period_count;
config.format = format;
config.start_threshold = 0;
config.stop_threshold = 0;
config.silence_threshold = 0;
pcm = pcm_open(card, device, PCM_IN, &config);
if (!pcm || !pcm_is_ready(pcm)) {
fprintf(stderr, "Unable to open PCM device (%s)\n",
pcm_get_error(pcm));
return 0;
}
size = pcm_frames_to_bytes(pcm, pcm_get_buffer_size(pcm));
buffer = malloc(size);
if (!buffer) {
fprintf(stderr, "Unable to allocate %d bytes\n", size);
free(buffer);
pcm_close(pcm);
return 0;
}
printf("Capturing sample: %u ch, %u hz, %u bit\n", channels, rate,
pcm_format_to_bits(format));
while (capturing && !pcm_read(pcm, buffer, size)) {
if (fwrite(buffer, 1, size, file) != size) {
fprintf(stderr,"Error capturing sample\n");
break;
}
bytes_read += size;
}
free(buffer);
pcm_close(pcm);
return pcm_bytes_to_frames(pcm, bytes_read);
}
unsigned int capture_sample(FILE *file, unsigned int device,
unsigned int channels, unsigned int rate,
unsigned int bits)
{
struct pcm_config config;
struct pcm *pcm;
char *buffer;
unsigned int size;
unsigned int bytes_read = 0;
config.channels = channels;
config.rate = rate;
config.period_size = 1024;
config.period_count = 4;
if (bits == 32)
config.format = PCM_FORMAT_S32_LE;
else if (bits == 16)
config.format = PCM_FORMAT_S16_LE;
pcm = pcm_open(0, device, PCM_IN, &config);
if (!pcm || !pcm_is_ready(pcm)) {
fprintf(stderr, "Unable to open PCM device (%s)\n",
pcm_get_error(pcm));
return 0;
}
size = pcm_get_buffer_size(pcm);
buffer = malloc(size);
if (!buffer) {
fprintf(stderr, "Unable to allocate %d bytes\n", size);
free(buffer);
pcm_close(pcm);
return 0;
}
printf("Capturing sample: %u ch, %u hz, %u bit\n", channels, rate, bits);
while (capturing && !pcm_read(pcm, buffer, size)) {
if (fwrite(buffer, 1, size, file) != size) {
fprintf(stderr,"Error capturing sample\n");
break;
}
bytes_read += size;
}
free(buffer);
pcm_close(pcm);
return bytes_read / ((bits / 8) * channels);
}
int alsa_init(struct device *dv, const char *device_name,
int rate, int buffer_time)
{
struct alsa *alsa;
alsa = malloc(sizeof *alsa);
if (alsa == NULL) {
perror("malloc");
return -1;
}
if (pcm_open(&alsa->capture, device_name, SND_PCM_STREAM_CAPTURE,
rate, buffer_time) < 0)
{
fputs("Failed to open device for capture.\n", stderr);
goto fail;
}
if (pcm_open(&alsa->playback, device_name, SND_PCM_STREAM_PLAYBACK,
rate, buffer_time) < 0)
{
fputs("Failed to open device for playback.\n", stderr);
goto fail_capture;
}
device_init(dv, &alsa_ops);
dv->local = alsa;
return 0;
fail_capture:
pcm_close(&alsa->capture);
fail:
free(alsa);
return -1;
}
static int inner_main(struct tone_generator_config config)
{
struct pcm_config *pcm_config = &config.pcm_config;
struct pcm *pcm;
unsigned pos;
void *buf;
pcm = pcm_open(config.card, config.device, PCM_OUT, pcm_config);
if (!pcm) {
fprintf(stderr, "Could not open sound card\n");
fprintf(stderr, "%s\n", pcm_get_error(pcm));
return 1;
}
if (!pcm_is_ready(pcm)) {
fprintf(stderr, "Sound card not ready\n");
fprintf(stderr, "%s\n", pcm_get_error(pcm));
return 1;
}
buf = calloc(config.bits / 8,
pcm_config->period_size * pcm_config->channels);
if (!buf) {
fprintf(stderr, "Could not allocate memory for buffer\n");
return 1;
}
for (pos=0 ; (!config.duration || (pos < config.duration)) ; pos += pcm_config->period_size) {
oscillator_table_render(buf,
config.wave_table,
pos,
pcm_config->period_size,
config.wave_scale,
pcm_config->channels,
config.chan_mask, /* write to all channels */
config.volume,
config.bits);
if (pcm_write(pcm,
buf,
pcm_config->channels * pcm_config->period_size * (config.bits/8))) {
fprintf(stderr, "Error writing to sound card\n");
fprintf(stderr, "%s\n", pcm_get_error(pcm));
}
}
pcm_close(pcm);
return 0;
}
int main(int argc, char *argv[])
{
(void)argc;
(void)argv;
if (pcm_open() < 0) {
printf("pcm_open error\n");
return 1;
}
int16_t data16[] = {
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
0, 11585, 16384, 11585, 0, -11585, -16384, -11585,
};
char data8[sizeof(data16) / sizeof(data16[0])];
for (int i = 0; i < (int)sizeof(data8); i++) {
data8[i] = data16[i] >> 8;
}
int count = 5 * 10; // 10s
while (count--) {
pcm_play((void*)data16, sizeof(data16));
}
pcm_close();
return 0;
}
static bool profile_test_sample_rate(alsa_device_profile* profile, unsigned rate)
{
struct pcm_config config = profile->default_config;
config.rate = rate;
bool works = false; /* let's be pessimistic */
struct pcm * pcm = pcm_open(profile->card, profile->device,
profile->direction, &config);
if (pcm != NULL) {
works = pcm_is_ready(pcm);
pcm_close(pcm);
}
return works;
}
EXTERN_TAG int pcm_output_init(int sr,int ch)
{
int card = 0;
int device = 2;
cached_len = 0;
wfd_config_out.channels = 2;
wfd_config_out.rate = 48000;
wfd_config_out.period_size = WFD_PERIOD_SIZE;
wfd_config_out.period_count = WFD_PERIOD_NUM;
wfd_config_out.format = PCM_FORMAT_S16_LE;
wfd_config_out.start_threshold = WFD_PERIOD_SIZE;
wfd_config_out.avail_min = 0;//SHORT_PERIOD_SIZE;
card = get_aml_card();
if(card < 0)
{
card = 0;
adec_print("get aml card fail, use default \n");
}
// if hdmi state on
if(get_hdmi_switch_state())
device = get_spdif_port();
else
device = 0; //i2s output for analog output
if(device < 0)
{
device = 0;
adec_print("get aml card device fail, use default \n");
}
adec_print("open output device card %d, device %d \n",card,device);
if(sr < 32000|| sr > 48000 || ch != 2){
adec_print("wfd output: not right parameter sr %d,ch %d \n",sr,ch);
return -1;
}
wfd_config_out.rate = sr;
wfd_config_out.channels = ch;
wfd_pcm = pcm_open(card, device, PCM_OUT /*| PCM_MMAP | PCM_NOIRQ*/, &wfd_config_out);
if (!pcm_is_ready(wfd_pcm)) {
adec_print("wfd cannot open pcm_out driver: %s", pcm_get_error(wfd_pcm));
pcm_close(wfd_pcm);
return -1;
}
adec_print("pcm_output_init done wfd : %p,\n",wfd_pcm);
return 0;
}
/* must be called with hw device and output stream mutexes locked */
static int start_output_stream(struct stream_out *out)
{
struct audio_device *adev = out->dev;
int i;
if ((adev->card < 0) || (adev->device < 0))
return -EINVAL;
out->pcm = pcm_open(adev->card, adev->device, PCM_OUT, &pcm_config);
if (out->pcm && !pcm_is_ready(out->pcm)) {
ALOGE("pcm_open() failed: %s", pcm_get_error(out->pcm));
pcm_close(out->pcm);
return -ENOMEM;
}
return 0;
}
bool PcmDecoder::open(char *file)
{
// log the name
LOGI("Open [%s]", file);
m_pcm = fopen(file, "rb" );
if( m_pcm == NULL )
{
return 0;
}
if(!pcm_open())
{
close();
return 0;
}
return 1;
}
int InStream::startInputStream() {
LOGFUNC("%s(%p)", __func__, this);
mUcm.activateEntry(mEntry, this);
int card = mUcm.getCaptureCard(mEntry);
int port = mUcm.getCapturePort(mEntry);
ALOGE("setting capture card=%d port=%d", card, port);
mPcm = pcm_open(card, port, PCM_IN, &mConfig);
if (!pcm_is_ready(mPcm)) {
ALOGE("cannot open pcm_in driver: %s", pcm_get_error(mPcm));
pcm_close(mPcm);
mPcm = NULL;
mUcm.deactivateEntry(mEntry);
return -ENOMEM;
}
mStandby = false;
return 0;
}
bool SpeechANCController::StartPCMIn(char mTypePCM, uint32_t device, pcm_config mConfig)
{
ALOGD("+%s(), pcm device = %d", __FUNCTION__, device);
pcm *mPcm;
//ASSERT(mPcm == NULL);
mPcm = pcm_open(kAudioSoundCardIndex, device, PCM_IN, &mConfig);
if (mPcm == NULL)
{
ALOGE("%s(), mPcm == NULL!!", __FUNCTION__);
}
else if (pcm_is_ready(mPcm) == false)
{
ALOGE("%s(), pcm_is_ready(%p) == false due to %s, close pcm.", __FUNCTION__, mPcm, pcm_get_error(mPcm));
pcm_close(mPcm);
mPcm = NULL;
}
else
{
pcm_start(mPcm);
}
ALOGD("-%s(), mPcm = %p", __FUNCTION__, mPcm);
ASSERT(mPcm != NULL);
switch (mTypePCM)
{
case 0:
mPcmIn_MOD = mPcm ;
break;
case 1:
mPcmIn_IO2 = mPcm;
break;
case 2:
mPcmIn_ADC2 = mPcm;
break;
}
return true;
}
int start_input_stream(struct stream_in *in)
{
int ret = 0;
struct audio_device *adev = in->dev;
adev->card = get_card_number_by_name("USB Audio");
adev->device = DEFAULT_DEVICE;
ALOGVV("%s: USB card number = %d, device = %d",__func__,adev->card,adev->device);
ALOGV("%s :: requested params \
\r \t channels = %d, \
\r \t rate = %d, \
\r \t period_size = %d, \
\r \t period_count = %d, \
\r \t format = %d", __func__,
in->pcm_config.channels,in->pcm_config.rate,
in->pcm_config.period_size,in->pcm_config.period_count,
in->pcm_config.format);
ret = validate_input_hardware_params(in);
if(ret != 0) {
ALOGE("Unsupport input stream parameters");
in->pcm = NULL;
return -ENOSYS;
}
in->pcm = pcm_open(adev->card, adev->device,
PCM_IN, &in->pcm_config);
if (in->pcm && !pcm_is_ready(in->pcm)) {
ALOGE("%s: %s", __func__, pcm_get_error(in->pcm));
pcm_close(in->pcm);
in->pcm = NULL;
ret = -EIO;
ALOGD("%s: exit: status(%d)", __func__, ret);
return ret;
} else {
ALOGV("%s: exit capture pcm = %x", __func__,in->pcm);
return ret;
}
}
status_t AudioALSACaptureDataProviderTDM::open()
{
ALOGD("%s()", __FUNCTION__);
ASSERT(mClientLock.tryLock() != 0); // lock by base class attach
AudioAutoTimeoutLock _l(mEnableLock);
AudioAutoTimeoutLock _l2(*AudioALSADriverUtility::getInstance()->getStreamSramDramLock());
ASSERT(mEnable == false);
// config attribute (will used in client SRC/Enh/... later) // TODO(Harvey): query this
mStreamAttributeSource.audio_format = AUDIO_FORMAT_PCM_16_BIT;
mStreamAttributeSource.audio_channel_mask = AUDIO_CHANNEL_IN_STEREO;
mStreamAttributeSource.num_channels = android_audio_legacy::AudioSystem::popCount(mStreamAttributeSource.audio_channel_mask);
mStreamAttributeSource.sample_rate = 44100;
OpenPCMDump(LOG_TAG);
// enable pcm
ASSERT(mPcm == NULL);
mPcm = pcm_open(0, 13, PCM_IN, &mConfig);
// mPcm = pcm_open(0, 1, PCM_IN, &mConfig);
ASSERT(mPcm != NULL && pcm_is_ready(mPcm) == true);
ALOGV("%s(), mPcm = %p", __FUNCTION__, mPcm);
pcm_start(mPcm);
// create reading thread
mEnable = true;
int ret = pthread_create(&hReadThread, NULL, AudioALSACaptureDataProviderTDM::readThread, (void *)this);
if (ret != 0)
{
ALOGE("%s() create thread fail!!", __FUNCTION__);
return UNKNOWN_ERROR;
}
return NO_ERROR;
}
int muroard_driver_init(const char * dev) {
struct pcm_config config;
unsigned int period_size = muroard_state_member(abuffer_size);
unsigned int period_count = 4;
unsigned int card = 0;
unsigned int device = 0;
config.channels = muroard_state_member(sa_channels);
config.rate = muroard_state_member(sa_rate);
config.format = PCM_FORMAT_S16_LE;
config.start_threshold = 0;
config.stop_threshold = 0;
config.silence_threshold = 0;
config.period_size = period_size;
config.period_count = period_count;
muroard_state_member(driver_vp) = pcm_open(card, device, PCM_OUT, &config);
if (!muroard_state_member(driver_vp) || !pcm_is_ready(muroard_state_member(driver_vp)))
return -1;
return 0;
}
void AudioALSAPlaybackHandlerNormal::OpenHpImpeDancePcm(void)
{
ALOGD("OpenHpImpeDancePcm");
// Don't lock Sram/Dram lock here, it would be locked by caller function
int pcmindex = AudioALSADeviceParser::getInstance()->GetPcmIndexByString(keypcmHpimpedancePlayback);
int cardindex = AudioALSADeviceParser::getInstance()->GetCardIndexByString(keypcmHpimpedancePlayback);
struct pcm_params *params;
params = pcm_params_get(cardindex, pcmindex, PCM_OUT);
if (params == NULL)
{
ALOGD("Device does not exist.\n");
}
int buffer_size = pcm_params_get_max(params, PCM_PARAM_BUFFER_BYTES);
ALOGD("buffer_size = %d", buffer_size);
pcm_params_free(params);
// HW pcm config
mHpImpedanceConfig.channels = 2;
mHpImpedanceConfig.rate = mStreamAttributeSource->sample_rate;
mHpImpedanceConfig.period_count = 2;
mHpImpedanceConfig.period_size = (buffer_size / (mHpImpedanceConfig.channels * mHpImpedanceConfig.period_count)) / 2;
mHpImpedanceConfig.format = PCM_FORMAT_S16_LE;
mHpImpedanceConfig.start_threshold = 0;
mHpImpedanceConfig.stop_threshold = 0;
mHpImpedanceConfig.silence_threshold = 0;
ALOGD("%s(), mHpImpedanceConfig: channels = %d, rate = %d, period_size = %d, period_count = %d, format = %d",
__FUNCTION__, mHpImpedanceConfig.channels, mHpImpedanceConfig.rate, mHpImpedanceConfig.period_size, mHpImpedanceConfig.period_count, mHpImpedanceConfig.format);
// open pcm driver
mHpImpeDancePcm = pcm_open(cardindex, pcmindex, PCM_OUT, &mHpImpedanceConfig);
if (mHpImpeDancePcm == NULL)
{
ALOGE("%s(), mPcm == NULL!!", __FUNCTION__);
}
ALOGD("-%s(), mPcm = %p", __FUNCTION__, mHpImpeDancePcm);
ASSERT(mHpImpeDancePcm != NULL);
pcm_start(mHpImpeDancePcm);
}
static int initialize_device(out123_handle *ao)
{
mpg123_tinyalsa_t* ta = (mpg123_tinyalsa_t*)ao->userptr;
ta->config.channels = ao->channels;
ta->config.rate = ao->rate;
ta->config.period_size = 1024;
ta->config.period_count = 4;
ta->config.format = PCM_FORMAT_S16_LE;
ta->config.start_threshold = 0;
ta->config.stop_threshold = 0;
ta->config.silence_threshold = 0;
ta->pcm = pcm_open(ta->card, ta->device, PCM_OUT, &ta->config);
if (!ta->pcm || !pcm_is_ready(ta->pcm))
{
if(!AOQUIET)
error3( "(open) Unable to open card %u PCM device %u (%s)\n"
, ta->card, ta->device, pcm_get_error(ta->pcm) );
return -1;
}
return 0;
}