static void
xrun(void)
{
snd_pcm_status_t *status;
int res;
snd_pcm_status_alloca(&status);
if ((res = snd_pcm_status(AHandle, status)) < 0) {
fprintf(stderr, "status error: %s", snd_strerror(res));
exit(EXIT_FAILURE);
}
if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
struct timeval now,
diff,
tstamp;
gettimeofday(&now, 0);
snd_pcm_status_get_trigger_tstamp(status, &tstamp);
timersub(&now, &tstamp, &diff);
fprintf(stderr, "Underrun!!! (at least %.3f ms long)\n",
diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
if ((res = snd_pcm_prepare(AHandle)) < 0) {
fprintf(stderr, "xrun: prepare error: %s", snd_strerror(res));
exit(EXIT_FAILURE);
}
return; // ok, data should be accepted
// again
}
fprintf(stderr, "read/write error, state = %s",
snd_pcm_state_name(snd_pcm_status_get_state(status)));
exit(EXIT_FAILURE);
}
int main(void)
{
int val;
printf("ALSA library version: %s\n", SND_LIB_VERSION_STR);
printf("\nPCM stream types:\n");
for (val = 0; val <= SND_PCM_STREAM_LAST; val++)
printf(" %s\n", snd_pcm_stream_name((snd_pcm_stream_t)val));
printf("\nPCM access types:\n");
for (val = 0; val <= SND_PCM_ACCESS_LAST; val++)
printf(" %s\n", snd_pcm_access_name((snd_pcm_access_t)val));
printf("\nPCM formats:\n");
for (val = 0; val <= SND_PCM_FORMAT_LAST; val++)
if (snd_pcm_format_name((snd_pcm_format_t)val) != NULL)
printf(" %s (%s)\n",
snd_pcm_format_name((snd_pcm_format_t)val),
snd_pcm_format_description(
(snd_pcm_format_t)val));
printf("\nPCM subformats:\n");
for (val = 0; val <= SND_PCM_SUBFORMAT_LAST; val++)
printf(" %s (%s)\n", snd_pcm_subformat_name((snd_pcm_subformat_t)val),
snd_pcm_subformat_description((snd_pcm_subformat_t)val));
printf("\nPCM states:\n");
for (val = 0; val <= SND_PCM_STATE_LAST; val++)
printf(" %s\n", snd_pcm_state_name((snd_pcm_state_t)val));
return 0;
}
// I/O error handler
static void xrun(void)
{
snd_pcm_status_t *status;
int res;
snd_pcm_status_alloca(&status);
if ((res = snd_pcm_status(handle, status))<0) {
error(_("status error: %s"), snd_strerror(res));
exit(EXIT_FAILURE);
}
if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
struct timeval now, diff, tstamp;
gettimeofday(&now, 0);
snd_pcm_status_get_trigger_tstamp(status, &tstamp);
timersub(&now, &tstamp, &diff);
fprintf(stderr, _("%s!!! (at least %.3f ms long)\n"),
stream == SND_PCM_STREAM_PLAYBACK ? _("underrun") : _("overrun"),
diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
if ((res = snd_pcm_prepare(handle))<0) {
error(_("xrun: prepare error: %s"), snd_strerror(res));
exit(EXIT_FAILURE);
}
return; // ok, data should be accepted again
} if (snd_pcm_status_get_state(status) == SND_PCM_STATE_DRAINING) {
}
error(_("read/write error, state = %s"), snd_pcm_state_name(snd_pcm_status_get_state(status)));
exit(EXIT_FAILURE);
}
int snd_pcm_status_dump(snd_pcm_status_t *status, snd_output_t *out)
{
snd_output_printf(out, " state : %s\n",
snd_pcm_state_name((snd_pcm_state_t) status->state));
snd_output_printf(out, " trigger_time: %ld.%06ld\n",
status->trigger_tstamp.tv_sec, status->trigger_tstamp.tv_nsec);
snd_output_printf(out, " tstamp : %ld.%06ld\n",
status->tstamp.tv_sec, status->tstamp.tv_nsec);
snd_output_printf(out, " delay : %ld\n", (long)status->delay);
snd_output_printf(out, " avail : %ld\n", (long)status->avail);
snd_output_printf(out, " avail_max : %ld\n", (long)status->avail_max);
return 0;
}
int aplaypop()
{
if (pcm_handle == NULL && aplaypop_open() != 0)
return -1;
fprintf(stderr, "snd_pcm_state() = %s\n",
snd_pcm_state_name(snd_pcm_state(pcm_handle)));
int err = snd_pcm_prepare(pcm_handle);
if (err != 0) {
fprintf(stderr, "snd_pcm_start(): %s\n", snd_strerror(err));
return -1;
}
int16_t *ptr = (int16_t *)bin_data;
int len = sizeof(bin_data) / frame_bytes;
while (len > 0) {
// The unit of the buffersize depends on the function. Sometimes it is
// given in bytes, sometimes the number of frames has to be specified.
// One frame is the sample data vector for all channels.
// For 16 Bit stereo data, one frame has a length of four bytes.
snd_pcm_sframes_t frames = snd_pcm_writei(pcm_handle, ptr, len);
fprintf(stderr, " snd_pcm_writei(h, ptr, %d) = %ld\n", len, frames);
if (frames == -EAGAIN) {
frames = 0;
} else if (frames < 0) { // -EPIPE, -ESTRPIPE
frames = snd_pcm_recover(pcm_handle, frames, 1/*silent*/);
if (frames < 0) {
fprintf(stderr, "writei/recover failed: %s\n", snd_strerror(err));
break;
}
} else if (frames < len) {
fprintf(stderr, "Short write (expected %d, wrote %ld)\n", len, frames);
} else {
break; // All done
}
len -= frames * frame_bytes;
ptr += frames * frame_bytes;
snd_pcm_wait(pcm_handle, 10/*ms*/);
}
err = snd_pcm_drain(pcm_handle);
if (err != 0) {
fprintf(stderr, "snd_pcm_start(): %s\n", snd_strerror(err));
return -1;
}
return 0;
}
/* I/O error handler */
static void xrun(void)
{
snd_pcm_status_t *status;
int res;
snd_pcm_status_alloca(&status);
if ((res = snd_pcm_status(handle, status))<0) {
error("status error: %s", snd_strerror(res));
exit(EXIT_FAILURE);
}
if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
struct timeval now, diff, tstamp;
gettimeofday(&now, 0);
snd_pcm_status_get_trigger_tstamp(status, &tstamp);
timersub(&now, &tstamp, &diff);
fprintf(stderr, "%s!!! (at least %.3f ms long)\n",
stream == SND_PCM_STREAM_PLAYBACK ? "underrun" : "overrun",
diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
if (verbose) {
fprintf(stderr, "Status:\n");
snd_pcm_status_dump(status, log);
}
if ((res = snd_pcm_prepare(handle))<0) {
error("xrun: prepare error: %s", snd_strerror(res));
exit(EXIT_FAILURE);
}
return; /* ok, data should be accepted again */
} if (snd_pcm_status_get_state(status) == SND_PCM_STATE_DRAINING) {
if (verbose) {
fprintf(stderr, "Status(DRAINING):\n");
snd_pcm_status_dump(status, log);
}
if (stream == SND_PCM_STREAM_CAPTURE) {
fprintf(stderr, "capture stream format change? attempting recover...\n");
if ((res = snd_pcm_prepare(handle))<0) {
error("xrun(DRAINING): prepare error: %s", snd_strerror(res));
exit(EXIT_FAILURE);
}
return;
}
}
if (verbose) {
fprintf(stderr, "Status(R/W):\n");
snd_pcm_status_dump(status, log);
}
error("read/write error, state = %s", snd_pcm_state_name(snd_pcm_status_get_state(status)));
exit(EXIT_FAILURE);
}
static void xrun(void)
{
snd_pcm_status_t *status;
int res;
snd_pcm_status_alloca(&status);
if ((res = snd_pcm_status(AHandle, status))<0) {
fprintf(stderr, "status error: %s", snd_strerror(res));
return;
}
if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
if (monotonic) {
#ifdef HAVE_CLOCK_GETTIME
struct timespec now, diff, tstamp;
clock_gettime(CLOCK_MONOTONIC, &now);
snd_pcm_status_get_trigger_htstamp(status, &tstamp);
timermsub(&now, &tstamp, &diff);
fprintf(stderr, _("%s!!! (at least %.3f ms long)\n"),
stream == SND_PCM_STREAM_PLAYBACK ? _("underrun") : _("overrun"),
diff.tv_sec * 1000 + diff.tv_nsec / 10000000.0);
#else
fprintf(stderr, "%s !!!\n", "underrun");
#endif
} else {
struct timeval now, diff, tstamp;
gettimeofday(&now, 0);
snd_pcm_status_get_trigger_tstamp(status, &tstamp);
timersub(&now, &tstamp, &diff);
fprintf(stderr, "%s!!! (at least %.3f ms long)\n",
"Underrun",
diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
}
if ((res = snd_pcm_prepare(AHandle))<0) {
fprintf(stderr, "xrun: prepare error: %s", snd_strerror(res)); /* we should probably die here */
return;
}
return; /* ok, data should be accepted again */
}
fprintf(stderr, "read/write error, state = %s", snd_pcm_state_name(snd_pcm_status_get_state(status)));
}
void alsa_print_info(snd_pcm_t * handle, snd_pcm_hw_params_t * hwp) {
printf("device [%s] opened with\n",
snd_pcm_name(handle));
printf("\tstate=%s\n",
snd_pcm_state_name(snd_pcm_state(handle)));
unsigned int val, val2;
snd_pcm_hw_params_get_access(hwp,
(snd_pcm_access_t *) &val);
printf("\taccess_type=%s\n",
snd_pcm_access_name((snd_pcm_access_t)val));
snd_pcm_hw_params_get_format(hwp, (snd_pcm_format_t *) &val);
printf("\tformat=%s\n",
snd_pcm_format_name((snd_pcm_format_t) val)
);
snd_pcm_hw_params_get_channels(hwp, &val);
printf("\tchannels=%d\n", val);
snd_pcm_hw_params_get_rate(hwp, &val, (int *) &val2);
printf("\trate=%d fps\n", val);
snd_pcm_hw_params_get_period_time(hwp,
&val, (int *) &val2);
printf("\tperiod_time=%d us\n", val);
snd_pcm_uframes_t frames;
snd_pcm_hw_params_get_period_size(hwp,
&frames, (int *) &val2);
printf("\tperiod_size=%d frames\n", (int)frames);
snd_pcm_hw_params_get_buffer_size(hwp,
(snd_pcm_uframes_t *) &val);
printf("\tbuffer_size=%d frames\n", val);
snd_pcm_hw_params_get_periods(hwp, &val, (int *) &val2);
printf("\tperiods_per_buffer=%d periods\n", val);
}
bool open()
{
// Open the Alsa playback device.
int err=-1,count=0;
unsigned int freakuency = frequency;
while((count < 5) && (err < 0)) {
err = snd_pcm_open
( &handle, ALSA_OUTPUT_NAME, SND_PCM_STREAM_PLAYBACK, 0 );
if(err < 0) {
count++;
qWarning()<<"QAudioOutput::open() err="<<err<<", count="<<count;
}
}
if (( err < 0)||(handle == 0)) {
qWarning( "QAudioOuput: snd_pcm_open: error %d", err );
return false;
}
snd_pcm_nonblock( handle, 0 );
// Set the desired HW parameters.
snd_pcm_hw_params_t *hwparams;
snd_pcm_hw_params_alloca( &hwparams );
err = snd_pcm_hw_params_any( handle, hwparams );
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_any: err %d", err);
return false;
}
err = snd_pcm_hw_params_set_access( handle, hwparams, access );
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_access: err %d", err);
return false;
}
err = snd_pcm_hw_params_set_format( handle, hwparams,
( bitsPerSample == 16 ? SND_PCM_FORMAT_S16
: SND_PCM_FORMAT_U8 ) );
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_format: err %d", err);
return false;
}
err = snd_pcm_hw_params_set_channels
( handle, hwparams, (unsigned int)channels );
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_channels: err %d", err);
return false;
}
err = snd_pcm_hw_params_set_rate_near
( handle, hwparams, &freakuency, 0 );
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_rate_near: err %d", err);
return false;
}
#ifndef ALSA_BUFFER_SIZE
err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, 0);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_buffer_time_near: err %d",err);
}
err = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_get_buffer_size: err %d",err);
}
#else
buffer_size = ALSA_BUFFER_SIZE;
err = snd_pcm_hw_params_set_buffer_size_near(handle, hwparams, &buffer_size);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_buffer_time_near: err %d",err);
}
#endif
#ifndef ALSA_PERIOD_SIZE
period_time = buffer_time/4;
err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, 0);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_period_time_near: err %d",err);
}
#else
period_size = ALSA_PERIOD_SIZE;
err = snd_pcm_hw_params_set_period_size_near(handle, hwparams, &period_size, 0);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params_set_period_size_near: err %d",err);
}
#endif
err = snd_pcm_hw_params(handle, hwparams);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_hw_params: err %d", err);
return false;
}
int dir;
unsigned int vval, vval2;
snd_pcm_access_t val;
snd_pcm_format_t fval;
snd_pcm_subformat_t sval;
qLog(QAudioOutput) << "PCM handle name =" << snd_pcm_name(handle);
qLog(QAudioOutput) << "PCM state =" << snd_pcm_state_name(snd_pcm_state(handle));
snd_pcm_hw_params_get_access(hwparams,&val);
vval = (unsigned int)val;
if ( (int)vval != (int)access ) {
qWarning( "QAudioInput: access type not set, want %s got %s",
snd_pcm_access_name((snd_pcm_access_t)access),
snd_pcm_access_name((snd_pcm_access_t)vval) );
access = (snd_pcm_access_t)vval;
}
qLog(QAudioOutput) << "access type =" << snd_pcm_access_name((snd_pcm_access_t)vval);
snd_pcm_hw_params_get_format(hwparams, &fval);
vval = (unsigned int)fval;
if ( (int)vval != (int)format ) {
qWarning( "QAudioInput: format type not set, want %s got %s",
snd_pcm_format_name((snd_pcm_format_t)format),
snd_pcm_format_name((snd_pcm_format_t)vval) );
format = (snd_pcm_format_t)vval;
}
qLog(QAudioOutput) << QString("format = '%1' (%2)").arg(snd_pcm_format_name((snd_pcm_format_t)vval))
.arg(snd_pcm_format_description((snd_pcm_format_t)vval))
.toLatin1().constData();
snd_pcm_hw_params_get_subformat(hwparams,&sval);
vval = (unsigned int)sval;
qLog(QAudioOutput) << QString("subformat = '%1' (%2)").arg(snd_pcm_subformat_name((snd_pcm_subformat_t)vval))
.arg(snd_pcm_subformat_description((snd_pcm_subformat_t)vval))
.toLatin1().constData();
snd_pcm_hw_params_get_channels(hwparams, &vval);
if ( (int)vval != (int)channels ) {
qWarning( "QAudioInput: channels type not set, want %d got %d",channels,vval);
channels = vval;
}
qLog(QAudioOutput) << "channels =" << vval;
snd_pcm_hw_params_get_rate(hwparams, &vval, &dir);
if ( (int)vval != (int)frequency ) {
qWarning( "QAudioInput: frequency type not set, want %d got %d",frequency,vval);
frequency = vval;
}
qLog(QAudioOutput) << "rate =" << vval << "bps";
snd_pcm_hw_params_get_period_time(hwparams,&period_time, &dir);
qLog(QAudioOutput) << "period time =" << period_time << "us";
snd_pcm_hw_params_get_period_size(hwparams,&period_size, &dir);
qLog(QAudioOutput) << "period size =" << (int)period_size << "frames";
qLog(QAudioOutput) << "buffer time =" << (int)buffer_time << "us";
qLog(QAudioOutput) << "buffer size =" << (int)buffer_size << "frames";
snd_pcm_hw_params_get_periods(hwparams, &vval, &dir);
periods = vval;
qLog(QAudioOutput) << "periods per buffer =" << vval << "frames";
snd_pcm_hw_params_get_rate_numden(hwparams, &vval, &vval2);
qLog(QAudioOutput) << QString("exact rate = %1/%2 bps").arg(vval).arg(vval2).toLatin1().constData();
vval = snd_pcm_hw_params_get_sbits(hwparams);
qLog(QAudioOutput) << "significant bits =" << vval;
vval = snd_pcm_hw_params_is_batch(hwparams);
qLog(QAudioOutput) << "is batch =" << vval;
vval = snd_pcm_hw_params_is_block_transfer(hwparams);
qLog(QAudioOutput) << "is block transfer =" << vval;
vval = snd_pcm_hw_params_is_double(hwparams);
qLog(QAudioOutput) << "is double =" << vval;
vval = snd_pcm_hw_params_is_half_duplex(hwparams);
qLog(QAudioOutput) << "is half duplex =" << vval;
vval = snd_pcm_hw_params_is_joint_duplex(hwparams);
qLog(QAudioOutput) << "is joint duplex =" << vval;
vval = snd_pcm_hw_params_can_overrange(hwparams);
qLog(QAudioOutput) << "can overrange =" << vval;
vval = snd_pcm_hw_params_can_mmap_sample_resolution(hwparams);
qLog(QAudioOutput) << "can mmap =" << vval;
vval = snd_pcm_hw_params_can_pause(hwparams);
qLog(QAudioOutput) << "can pause =" << vval;
vval = snd_pcm_hw_params_can_resume(hwparams);
qLog(QAudioOutput) << "can resume =" << vval;
vval = snd_pcm_hw_params_can_sync_start(hwparams);
qLog(QAudioOutput) << "can sync start =" << vval;
// Set the desired SW parameters.
snd_pcm_sw_params_t *swparams;
snd_pcm_sw_params_alloca(&swparams);
err = snd_pcm_sw_params_current(handle, swparams);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_sw_params_current: err %d",err);
}
err = snd_pcm_sw_params_set_start_threshold(handle,swparams,buffer_size);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_sw_params_set_start_threshold: err %d",err);
}
err = snd_pcm_sw_params_set_stop_threshold(handle,swparams,buffer_size);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_sw_params_set_stop_threshold: err %d",err);
}
err = snd_pcm_sw_params_set_avail_min(handle, swparams,period_size);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_sw_params_set_avail_min: err %d",err);
}
err = snd_pcm_sw_params(handle, swparams);
if ( err < 0 ) {
qWarning( "QAudioOutput: snd_pcm_sw_params: err %d",err);
}
// Prepare for audio output.
snd_pcm_prepare( handle );
return true;
}
int main( int argc, char *argv[] )
{
struct structArgs cmdArgs;
unsigned int val, val2;
int dir;
int errNum;
cmdArgs.card = 0; // Default card.
cmdArgs.control = 1; // Default control.
// ************************************************************************
// ALSA control elements.
// ************************************************************************
snd_pcm_t *pcmp;
snd_pcm_hw_params_t *params;
// snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE;
snd_pcm_uframes_t frames;
// ************************************************************************
// Get command line parameters.
// ************************************************************************
argp_parse( &argp, argc, argv, 0, 0, &cmdArgs );
printf( "Card = %i\n", cmdArgs.card );
printf( "Control = %i\n", cmdArgs.control );
sprintf( cmdArgs.deviceID, "hw:%i,%i", cmdArgs.card, cmdArgs.control );
printf( "Using device %s :", cmdArgs.deviceID );
/* Allocate a hardware parameters object. */
if ( snd_pcm_hw_params_alloca( ¶ms ) < 0 )
{
fprintf( stderr, "Unable to allocate.\n" );
return -1;
}
/* Open PCM device for playback. */
// if ( snd_pcm_open( &pcmp, cmdArgs.deviceID, stream, 0 ) < 0 )
// {
// fprintf( stderr, "Unable to open pcm device.\n" );
// return -1;
// }
/* Fill it in with default values. */
// if ( snd_pcm_hw_params_any( pcmp, params ) < 0
// {
// fprintf( stderr, "Unable to set default values.\n" );
// return -1;
// }
/* Interleaved mode */
// snd_pcm_hw_params_set_access( pcmp, params,
// SND_PCM_ACCESS_RW_INTERLEAVED );
/* Signed 16-bit little-endian format */
snd_pcm_hw_params_set_format( pcmp, params,
SND_PCM_FORMAT_S16_LE );
/* Two channels (stereo) */
snd_pcm_hw_params_set_channels( pcmp, params, 2 );
/* 44100 bits/second sampling rate (CD quality) */
val = 44100;
snd_pcm_hw_params_set_rate_near( pcmp, params, &val, &dir );
/* Write the parameters to the driver */
errNum = snd_pcm_hw_params( pcmp, params );
if ( errNum < 0 )
{
fprintf(stderr, "unable to set hw parameters: %s\n",
snd_strerror( errNum ));
exit( 1 );
}
/* Display information about the PCM interface */
printf( "PCM handle name = '%s'\n", snd_pcm_name( pcmp ));
printf("PCM state = %s\n", snd_pcm_state_name( snd_pcm_state( pcmp )));
snd_pcm_hw_params_get_access( params, ( snd_pcm_access_t * ) &val );
printf( "access type = %s\n",
snd_pcm_access_name(( snd_pcm_access_t ) val ));
snd_pcm_hw_params_get_format( params, ( snd_pcm_format_t * ) &val );
printf( "format = '%s' (%s)\n",
snd_pcm_format_name(( snd_pcm_format_t ) val ),
snd_pcm_format_description(( snd_pcm_format_t ) val ));
snd_pcm_hw_params_get_subformat( params,
( snd_pcm_subformat_t * ) &val );
printf( "subformat = '%s' (%s)\n",
snd_pcm_subformat_name(( snd_pcm_subformat_t ) val ),
snd_pcm_subformat_description((
snd_pcm_subformat_t ) val ));
snd_pcm_hw_params_get_channels( params, &val );
printf( "channels = %d\n", val );
snd_pcm_hw_params_get_rate( params, &val, &dir );
printf( "rate = %d bps\n", val );
snd_pcm_hw_params_get_period_time( params, &val, &dir );
printf( "period time = %d us\n", val );
snd_pcm_hw_params_get_period_size( params, &frames, &dir );
printf( "period size = %d frames\n", ( int ) frames );
snd_pcm_hw_params_get_buffer_time( params, &val, &dir );
printf( "buffer time = %d us\n", val );
snd_pcm_hw_params_get_buffer_size( params,
( snd_pcm_uframes_t * ) &val );
printf( "buffer size = %d frames\n", val );
snd_pcm_hw_params_get_periods( params, &val, &dir );
printf( "periods per buffer = %d frames\n", val );
snd_pcm_hw_params_get_rate_numden( params, &val, &val2 );
printf( "exact rate = %d/%d bps\n", val, val2 );
val = snd_pcm_hw_params_get_sbits( params );
printf( "significant bits = %d\n", val );
// snd_pcm_hw_params_get_tick_time( params, &val, &dir );
// printf( "tick time = %d us\n", val );
val = snd_pcm_hw_params_is_batch( params );
printf( "is batch = %d\n", val );
val = snd_pcm_hw_params_is_block_transfer( params );
printf( "is block transfer = %d\n", val );
val = snd_pcm_hw_params_is_double( params );
printf( "is double = %d\n", val );
val = snd_pcm_hw_params_is_half_duplex( params );
printf( "is half duplex = %d\n", val );
val = snd_pcm_hw_params_is_joint_duplex( params );
printf( "is joint duplex = %d\n", val );
val = snd_pcm_hw_params_can_overrange( params );
printf( "can overrange = %d\n", val );
val = snd_pcm_hw_params_can_mmap_sample_resolution( params );
printf( "can mmap = %d\n", val );
val = snd_pcm_hw_params_can_pause( params );
printf( "can pause = %d\n", val );
val = snd_pcm_hw_params_can_resume( params );
printf( "can resume = %d\n", val );
val = snd_pcm_hw_params_can_sync_start( params );
printf( "can sync start = %d\n", val );
snd_pcm_close( pcmp );
return 0;
}
int main()
{
int rc;
snd_pcm_t* handle;
snd_pcm_hw_params_t* params;
unsigned int val;
unsigned int val2;
int dir;
snd_pcm_uframes_t frames;
if ( (rc = snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0)) < 0)
{
std::cerr << "unable to open pcm devices: " << snd_strerror(rc) << std::endl;
exit(1);
}
snd_pcm_hw_params_alloca(¶ms);
snd_pcm_hw_params_any(handle, params);
snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_channels(handle, params, 2);
val = 44100;
snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir);
if ( (rc = snd_pcm_hw_params(handle, params)) < 0)
{
std::cerr << "unable to set hw parameters: " << snd_strerror(rc) << std::endl;
exit(1);
}
std::cout << "PCM handle name = " << snd_pcm_name(handle) << std::endl;
std::cout << "PCM state = " << snd_pcm_state_name(snd_pcm_state(handle)) << std::endl;
snd_pcm_hw_params_get_access(params, (snd_pcm_access_t *)&val);
std::cout << "access type = " << snd_pcm_access_name((snd_pcm_access_t)val) << std::endl;
snd_pcm_hw_params_get_format(params, (snd_pcm_format_t*)(&val));
std::cout << "format = '" << snd_pcm_format_name((snd_pcm_format_t)val) << "' (" << snd_pcm_format_description((snd_pcm_format_t)val) << ")" << std::endl;
snd_pcm_hw_params_get_subformat(params, (snd_pcm_subformat_t *)&val);
std::cout << "subformat = '" <<
snd_pcm_subformat_name((snd_pcm_subformat_t)val) << "' (" << snd_pcm_subformat_description((snd_pcm_subformat_t)val) << ")" << std::endl;
snd_pcm_hw_params_get_channels(params, &val);
std::cout << "channels = " << val << std::endl;
snd_pcm_hw_params_get_rate(params, &val, &dir);
std::cout << "rate = " << val << " bps" << std::endl;
snd_pcm_hw_params_get_period_time(params, &val, &dir);
std::cout << "period time = " << val << " us" << std::endl;
snd_pcm_hw_params_get_period_size(params, &frames, &dir);
std::cout << "period size = " << static_cast<int>(frames) << " frames" << std::endl;
snd_pcm_hw_params_get_buffer_time(params, &val, &dir);
std::cout << "buffer time = " << val << " us" << std::endl;
snd_pcm_hw_params_get_buffer_size(params, (snd_pcm_uframes_t *) &val);
std::cout << "buffer size = " << val << " frames" << std::endl;
snd_pcm_hw_params_get_periods(params, &val, &dir);
std::cout << "periods per buffer = " << val << " frames" << std::endl;
snd_pcm_hw_params_get_rate_numden(params, &val, &val2);
std::cout << "exact rate = " << val/val2 << " bps" << std::endl;
val = snd_pcm_hw_params_get_sbits(params);
std::cout << "significant bits = " << val << std::endl;
snd_pcm_hw_params_get_tick_time(params, &val, &dir);
std::cout << "tick time = " << val << " us" << std::endl;
val = snd_pcm_hw_params_is_batch(params);
std::cout << "is batch = " << val << std::endl;
val = snd_pcm_hw_params_is_block_transfer(params);
std::cout << "is block transfer = " << val << std::endl;
val = snd_pcm_hw_params_is_double(params);
std::cout << "is double = " << val << std::endl;
val = snd_pcm_hw_params_is_half_duplex(params);
std::cout << "is half duplex = " << val << std::endl;
val = snd_pcm_hw_params_is_joint_duplex(params);
std::cout << "is joint duplex = " << val << std::endl;
val = snd_pcm_hw_params_can_overrange(params);
std::cout << "can overrange = " << val << std::endl;
val = snd_pcm_hw_params_can_mmap_sample_resolution(params);
std::cout << "can mmap = " << val << std::endl;
val = snd_pcm_hw_params_can_pause(params);
std::cout << "can pause = " << val << std::endl;
val = snd_pcm_hw_params_can_resume(params);
std::cout << "can resume = " << val << std::endl;
val = snd_pcm_hw_params_can_sync_start(params);
std::cout << "can sync start = " << val << std::endl;
snd_pcm_close(handle);
return 0;
}
int main() {
int rc;
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
unsigned int val, val2;
int dir;
snd_pcm_uframes_t frames;
/* Open PCM device for playback. */
rc = snd_pcm_open(&handle, "default",
SND_PCM_STREAM_PLAYBACK, 0);
if (rc < 0) {
fprintf(stderr,
"unable to open pcm device: %s\n",
snd_strerror(rc));
exit(1);
}
/* Allocate a hardware parameters object. */
snd_pcm_hw_params_alloca(¶ms);
/* Fill it in with default values. */
snd_pcm_hw_params_any(handle, params);
/* Set the desired hardware parameters. */
/* Interleaved mode */
snd_pcm_hw_params_set_access(handle, params,
SND_PCM_ACCESS_RW_INTERLEAVED);
/* Signed 16-bit little-endian format */
snd_pcm_hw_params_set_format(handle, params,
SND_PCM_FORMAT_S16_LE);
/* Two channels (stereo) */
snd_pcm_hw_params_set_channels(handle, params, 2);
/* 44100 bits/second sampling rate (CD quality) */
val = 44100;
snd_pcm_hw_params_set_rate_near(handle,
params, &val, &dir);
/* Write the parameters to the driver */
rc = snd_pcm_hw_params(handle, params);
if (rc < 0) {
fprintf(stderr,
"unable to set hw parameters: %s\n",
snd_strerror(rc));
exit(1);
}
/* Display information about the PCM interface */
printf("PCM handle name = '%s'\n",
snd_pcm_name(handle));
printf("PCM state = %s\n",
snd_pcm_state_name(snd_pcm_state(handle)));
snd_pcm_hw_params_get_access(params,
(snd_pcm_access_t *) &val);
printf("access type = %s\n",
snd_pcm_access_name((snd_pcm_access_t)val));
snd_pcm_hw_params_get_format(params, &val);
printf("format = '%s' (%s)\n",
snd_pcm_format_name((snd_pcm_format_t)val),
snd_pcm_format_description(
(snd_pcm_format_t)val));
snd_pcm_hw_params_get_subformat(params,
(snd_pcm_subformat_t *)&val);
printf("subformat = '%s' (%s)\n",
snd_pcm_subformat_name((snd_pcm_subformat_t)val),
snd_pcm_subformat_description(
(snd_pcm_subformat_t)val));
snd_pcm_hw_params_get_channels(params, &val);
printf("channels = %d\n", val);
snd_pcm_hw_params_get_rate(params, &val, &dir);
printf("rate = %d bps\n", val);
snd_pcm_hw_params_get_period_time(params,
&val, &dir);
printf("period time = %d us\n", val);
snd_pcm_hw_params_get_period_size(params,
&frames, &dir);
printf("period size = %d frames\n", (int)frames);
snd_pcm_hw_params_get_buffer_time(params,
&val, &dir);
printf("buffer time = %d us\n", val);
snd_pcm_hw_params_get_buffer_size(params,
(snd_pcm_uframes_t *) &val);
printf("buffer size = %d frames\n", val);
snd_pcm_hw_params_get_periods(params, &val, &dir);
printf("periods per buffer = %d frames\n", val);
snd_pcm_hw_params_get_rate_numden(params,
&val, &val2);
printf("exact rate = %d/%d bps\n", val, val2);
val = snd_pcm_hw_params_get_sbits(params);
printf("significant bits = %d\n", val);
snd_pcm_hw_params_get_tick_time(params,
&val, &dir);
printf("tick time = %d us\n", val);
val = snd_pcm_hw_params_is_batch(params);
printf("is batch = %d\n", val);
val = snd_pcm_hw_params_is_block_transfer(params);
printf("is block transfer = %d\n", val);
val = snd_pcm_hw_params_is_double(params);
printf("is double = %d\n", val);
val = snd_pcm_hw_params_is_half_duplex(params);
printf("is half duplex = %d\n", val);
val = snd_pcm_hw_params_is_joint_duplex(params);
printf("is joint duplex = %d\n", val);
val = snd_pcm_hw_params_can_overrange(params);
printf("can overrange = %d\n", val);
val = snd_pcm_hw_params_can_mmap_sample_resolution(params);
printf("can mmap = %d\n", val);
val = snd_pcm_hw_params_can_pause(params);
printf("can pause = %d\n", val);
val = snd_pcm_hw_params_can_resume(params);
printf("can resume = %d\n", val);
val = snd_pcm_hw_params_can_sync_start(params);
printf("can sync start = %d\n", val);
snd_pcm_close(handle);
return 0;
}
int main(int argc, char **argv){
int i;
int aver,val,val2;
int16_t buf[BUFSIZE];
double d_buffer[BUFSIZE];
double pitch = 0.0;
struct timespec before,after;
struct pitch_tracker_params *settings;
snd_pcm_uframes_t period_size = PERIOD_SIZE;
//ALSA PCM configuration
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
int dir,rc;
snd_pcm_uframes_t frames;
/* Open PCM device for capture */
rc = snd_pcm_open( &handle, "default" , SND_PCM_STREAM_CAPTURE , 0);
if(rc < 0 ){
fprintf(stderr,"unable to open pcm device: %s\n",snd_strerror(rc));
exit(1);
}
/* Allocate a hardware parameters object. */
snd_pcm_hw_params_alloca(¶ms);
/* Fill it in with default values. */
snd_pcm_hw_params_any(handle, params);
/* Set the desired hardware parameters. */
/* Interleaved mode */
snd_pcm_hw_params_set_access(handle, params,SND_PCM_ACCESS_RW_INTERLEAVED);
/* unsigned 16-bit format */
snd_pcm_hw_params_set_format(handle, params,SND_PCM_FORMAT_S16);
snd_pcm_hw_params_set_channels(handle, params, 1);
/* 44100 bits/second sampling rate */
val = 44100;
snd_pcm_hw_params_set_rate_near(handle,params, &val, &dir);
/* set size time*/
snd_pcm_hw_params_set_period_size_near(handle, params, &period_size , &dir);
/* write configuration */
rc = snd_pcm_hw_params(handle,params);
/*Display info*/
printf("PCM handle name = '%s'\n",
snd_pcm_name(handle));
printf("PCM state = %s\n",
snd_pcm_state_name(snd_pcm_state(handle)));
snd_pcm_hw_params_get_access(params,
(snd_pcm_access_t *) &val);
printf("access type = %s\n",
snd_pcm_access_name((snd_pcm_access_t)val));
snd_pcm_hw_params_get_format(params, &val);
printf("format = '%s' (%s)\n",
snd_pcm_format_name((snd_pcm_format_t)val),
snd_pcm_format_description(
(snd_pcm_format_t)val));
snd_pcm_hw_params_get_subformat(params,
(snd_pcm_subformat_t *)&val);
printf("subformat = '%s' (%s)\n",
snd_pcm_subformat_name((snd_pcm_subformat_t)val),
snd_pcm_subformat_description(
(snd_pcm_subformat_t)val));
snd_pcm_hw_params_get_channels(params, &val);
printf("channels = %d\n", val);
snd_pcm_hw_params_get_rate(params, &val, &dir);
printf("rate = %d bps\n", val);
snd_pcm_hw_params_get_period_time(params,
&val, &dir);
printf("period time = %d us\n", val);
snd_pcm_hw_params_get_period_size(params,
&frames, &dir);
printf("period size = %d frames\n", (int)frames);
snd_pcm_hw_params_get_buffer_time(params,
&val, &dir);
printf("buffer time = %d us\n", val);
snd_pcm_hw_params_get_buffer_size(params,
(snd_pcm_uframes_t *) &val);
printf("buffer size = %d frames\n", val);
snd_pcm_hw_params_get_periods(params, &val, &dir);
printf("periods per buffer = %d frames\n", val);
snd_pcm_hw_params_get_rate_numden(params,
&val, &val2);
printf("exact rate = %d/%d bps\n", val, val2);
val = snd_pcm_hw_params_get_sbits(params);
printf("significant bits = %d\n", val);
val = snd_pcm_hw_params_is_batch(params);
printf("is batch = %d\n", val);
val = snd_pcm_hw_params_is_block_transfer(params);
printf("is block transfer = %d\n", val);
val = snd_pcm_hw_params_is_double(params);
printf("is double = %d\n", val);
val = snd_pcm_hw_params_is_half_duplex(params);
printf("is half duplex = %d\n", val);
val = snd_pcm_hw_params_is_joint_duplex(params);
printf("is joint duplex = %d\n", val);
val = snd_pcm_hw_params_can_overrange(params);
printf("can overrange = %d\n", val);
val = snd_pcm_hw_params_can_mmap_sample_resolution(params);
printf("can mmap = %d\n", val);
val = snd_pcm_hw_params_can_pause(params);
printf("can pause = %d\n", val);
val = snd_pcm_hw_params_can_resume(params);
printf("can resume = %d\n", val);
val = snd_pcm_hw_params_can_sync_start(params);
printf("can sync start = %d\n", val);
settings = open_pitch_tracker();
while(1){
rc = snd_pcm_readi(handle, buf, frames);
if (rc == -EPIPE) {
/* EPIPE means overrun */
fprintf(stderr, "overrun occurred\n");
snd_pcm_prepare(handle);
} else if (rc < 0) {
fprintf(stderr,
"error from read: %s\n",
snd_strerror(rc));
} else if (rc != (int)frames) {
fprintf(stderr, "short read, read %d frames\n", rc);
}
for( i = 0 ; i< BUFSIZE ; i++){
d_buffer[i] = (double) buf[i];
}
pitch = compute_pitch(d_buffer, BUFSIZE, S16, settings ,ACCURACY);
if( pitch != 0.0 )
printf("frequency -> %f\n",pitch);
memset(buf,0,BUFSIZE);
}
close_pitch_tracker(&settings);
snd_pcm_drain(handle);
snd_pcm_close(handle);
return 0;
}
static inline void print_pcm_state(snd_pcm_t *handle, char *msg)
{
fprintf(stderr, "PCM state at %s = %s\n", msg,
snd_pcm_state_name(snd_pcm_state(handle)));
}
int record(int size,char *serverString)
{
unsigned int pcm, tmp, dir;
int rate, channels, seconds;
snd_pcm_t *pcm_handle;
snd_pcm_hw_params_t *params;
snd_pcm_uframes_t frames;
char *buff,*buf;
int buff_size, loops;
int fp;
/*if (argc < 4)
{
printf("Usage: %s <sample_rate> <channels> <seconds>\n",
argv[0]);
return -1;
}*/
rate = 8000;//atoi(argv[1]);
channels = 1;//atoi(argv[2]);
seconds = 10;//atoi(argv[3]);
/* Open the PCM device in playback mode */
if (pcm = snd_pcm_open(&pcm_handle, "default" , SND_PCM_STREAM_PLAYBACK, 0) < 0)
printf("ERROR: Can't open \"%s\" PCM device. %s\n", "default", snd_strerror(pcm));
/* Allocate parameters object and fill it with default values*/
snd_pcm_hw_params_alloca(¶ms);
snd_pcm_hw_params_any(pcm_handle, params);
/* Set parameters */
if (pcm = snd_pcm_hw_params_set_access(pcm_handle, params,SND_PCM_ACCESS_RW_INTERLEAVED) < 0)
printf("ERROR: Can't set interleaved mode. %s\n", snd_strerror(pcm));
if (pcm = snd_pcm_hw_params_set_format(pcm_handle, params,SND_PCM_FORMAT_U8) < 0)
printf("ERROR: Can't set format. %s\n", snd_strerror(pcm));
if (pcm = snd_pcm_hw_params_set_channels(pcm_handle, params, channels) < 0)
printf("ERROR: Can't set channels number. %s\n", snd_strerror(pcm));
if (pcm = snd_pcm_hw_params_set_rate_near(pcm_handle, params, &rate, 0) < 0)
printf("ERROR: Can't set rate. %s\n", snd_strerror(pcm));
/* Write parameters */
if (pcm = snd_pcm_hw_params(pcm_handle, params) < 0)
printf("ERROR: Can't set harware parameters. %s\n", snd_strerror(pcm));
/* Resume information */
printf("PCM name: '%s'\n", snd_pcm_name(pcm_handle));
printf("PCM state: %s\n", snd_pcm_state_name(snd_pcm_state(pcm_handle)));
snd_pcm_hw_params_get_channels(params, &tmp);
printf("channels: %i ", tmp);
if (tmp == 1)
printf("(mono)\n");
else if (tmp == 2)
printf("(stereo)\n");
snd_pcm_hw_params_get_rate(params, &tmp, 0);
printf("rate: %d bps\n", tmp);
printf("seconds: %d\n", seconds);
/* Allocate buffer to hold single period */
snd_pcm_hw_params_get_period_size(params, &frames, 0);
buff_size = frames * channels * 2 /* 2 -> sample size */;
buff = (char *) malloc(buff_size*3);
size = frames * channels * 2 /* 2 -> sample size */;
buf = (char *) realloc((void*)serverString,(size*3));
snd_pcm_hw_params_get_period_time(params, &tmp, NULL);
//fp=open("222.wav",O_RDONLY);
for (loops = (seconds * 1000000) / tmp; loops > 0; loops--)
{
/*
if (pcm = read(fp, buff, buff_size) == 0)
{
printf("Early end of file.\n");
//return 0;
}
*/
if (pcm = snd_pcm_writei(pcm_handle, buf, frames) == -EPIPE)
{
printf("XRUN.\n");
snd_pcm_prepare(pcm_handle);
}
else
if(pcm < 0)
{
printf("ERROR. Can't write to PCM device. %s\n", snd_strerror(pcm));
}
}
snd_pcm_drain(pcm_handle);
snd_pcm_close(pcm_handle);
free(buff);
return 0;
}
bool QAudioInputPrivate::open( QObject *input )
{
// Open the Alsa capture device.
bool rc = true;
int err;
unsigned int freakuency = frequency;
if ((err = snd_pcm_open(&handle,
m_device.constData(), //"plughw:0,0"
SND_PCM_STREAM_CAPTURE,
0/*SND_PCM_ASYNC*/)) < 0) {
qWarning( "QAudioInput: snd_pcm_open: error %d", err);
rc = false;
}
else {
snd_pcm_hw_params_t *hwparams;
// We want non-blocking mode.
snd_pcm_nonblock(handle, 1);
// Set the desired parameters.
snd_pcm_hw_params_alloca(&hwparams);
err = snd_pcm_hw_params_any(handle, hwparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_any: err %d", err);
}
err = snd_pcm_hw_params_set_access(handle, hwparams,
access);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_access: err %d",err);
}
err = snd_pcm_hw_params_set_format(handle, hwparams,format);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_format: err %d",err);
}
err = snd_pcm_hw_params_set_channels(handle,hwparams,(unsigned int)channels);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_channels: err %d",err);
}
err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &freakuency, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_rate_near: err %d",err);
}
if(freakuency > 1.05 * frequency || freakuency < 0.95 * frequency) {
qWarning("QAudioInput: warning, sample rate %i not supported by the hardware, using %u", frequency, freakuency);
}
if ( samplesPerBlock != -1 ) {
// Set buffer and period sizes based on the supplied block size.
sample_size = (snd_pcm_uframes_t)( samplesPerBlock * channels / 8 );
err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &freakuency, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_rate_near: err %d",err);
}
if(freakuency > 1.05 * frequency || freakuency < 0.95 * frequency) {
qWarning( "QAudioInput: warning, sample rate %i not supported by the hardware, using %u", frequency, freakuency);
}
err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_buffer_time_near: err %d",err);
}
period_time = 1000000 * 256 / frequency;
err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_period_time_near: err %d",err);
}
} else {
// Use the largest buffer and period sizes we can.
err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_buffer_time_near: err %d",err);
}
period_time = 1000000 * 256 / frequency;
err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_period_time_near: err %d",err);
}
}
err = snd_pcm_hw_params(handle, hwparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params: err %d",err);
}
int dir;
unsigned int vval, vval2;
snd_pcm_access_t aval;
snd_pcm_format_t fval;
snd_pcm_subformat_t sval;
qLog(QAudioInput) << "PCM handle name = " << snd_pcm_name(handle);
qLog(QAudioInput) << "PCM state = " << snd_pcm_state_name(snd_pcm_state(handle));
snd_pcm_hw_params_get_access(hwparams,&aval);
vval = (unsigned int)aval;
if ( (int)vval != (int)access ) {
qLog(QAudioInput) << QString("access type not set, want %1 got %2")
.arg(snd_pcm_access_name((snd_pcm_access_t)access))
.arg(snd_pcm_access_name((snd_pcm_access_t)vval));
access = (snd_pcm_access_t)vval;
}
qLog(QAudioInput) << "access type = " << snd_pcm_access_name((snd_pcm_access_t)vval);
snd_pcm_hw_params_get_format(hwparams, &fval);
vval = (unsigned int)fval;
if ( (int)vval != (int)format ) {
qLog(QAudioInput) << QString("format type not set, want %1 got %2")
.arg(snd_pcm_format_name((snd_pcm_format_t)format))
.arg(snd_pcm_format_name((snd_pcm_format_t)vval));
format = (snd_pcm_format_t)vval;
}
qLog(QAudioInput) << QString("format = '%1' (%2)")
.arg(snd_pcm_format_name((snd_pcm_format_t)vval))
.arg(snd_pcm_format_description((snd_pcm_format_t)vval))
.toLatin1().constData();
snd_pcm_hw_params_get_subformat(hwparams,&sval);
vval = (unsigned int)sval;
qLog(QAudioInput) << QString("subformat = '%1' (%2)")
.arg(snd_pcm_subformat_name((snd_pcm_subformat_t)vval))
.arg(snd_pcm_subformat_description((snd_pcm_subformat_t)vval))
.toLatin1().constData();
snd_pcm_hw_params_get_channels(hwparams, &vval);
if ( (int)vval != (int)channels ) {
qLog(QAudioInput) << QString("channels type not set, want %1 got %2").arg(channels).arg(vval);
channels = vval;
}
qLog(QAudioInput) << "channels = " << vval;
snd_pcm_hw_params_get_rate(hwparams, &vval, &dir);
if ( (int)vval != (int)frequency ) {
qLog(QAudioInput) << QString("frequency type not set, want %1 got %2").arg(frequency).arg(vval);
frequency = vval;
}
qLog(QAudioInput) << "rate =" << vval << " bps";
snd_pcm_hw_params_get_period_time(hwparams,&period_time, &dir);
qLog(QAudioInput) << "period time =" << period_time << " us";
snd_pcm_hw_params_get_period_size(hwparams,&period_size, &dir);
qLog(QAudioInput) << "period size =" << (int)period_size;
snd_pcm_hw_params_get_buffer_time(hwparams,&buffer_time, &dir);
qLog(QAudioInput) << "buffer time =" << buffer_time;
snd_pcm_hw_params_get_buffer_size(hwparams,(snd_pcm_uframes_t *) &buffer_size);
qLog(QAudioInput) << "buffer size =" << (int)buffer_size;
snd_pcm_hw_params_get_periods(hwparams, &vval, &dir);
qLog(QAudioInput) << "periods per buffer =" << vval;
snd_pcm_hw_params_get_rate_numden(hwparams, &vval, &vval2);
qLog(QAudioInput) << QString("exact rate = %1/%2 bps").arg(vval).arg(vval2).toLatin1().constData();
vval = snd_pcm_hw_params_get_sbits(hwparams);
qLog(QAudioInput) << "significant bits =" << vval;
snd_pcm_hw_params_get_tick_time(hwparams,&vval, &dir);
qLog(QAudioInput) << "tick time =" << vval;
vval = snd_pcm_hw_params_is_batch(hwparams);
qLog(QAudioInput) << "is batch =" << vval;
vval = snd_pcm_hw_params_is_block_transfer(hwparams);
qLog(QAudioInput) << "is block transfer =" << vval;
vval = snd_pcm_hw_params_is_double(hwparams);
qLog(QAudioInput) << "is double =" << vval;
vval = snd_pcm_hw_params_is_half_duplex(hwparams);
qLog(QAudioInput) << "is half duplex =" << vval;
vval = snd_pcm_hw_params_is_joint_duplex(hwparams);
qLog(QAudioInput) << "is joint duplex =" << vval;
vval = snd_pcm_hw_params_can_overrange(hwparams);
qLog(QAudioInput) << "can overrange =" << vval;
vval = snd_pcm_hw_params_can_mmap_sample_resolution(hwparams);
qLog(QAudioInput) << "can mmap =" << vval;
vval = snd_pcm_hw_params_can_pause(hwparams);
qLog(QAudioInput) << "can pause =" << vval;
vval = snd_pcm_hw_params_can_resume(hwparams);
qLog(QAudioInput) << "can resume =" << vval;
vval = snd_pcm_hw_params_can_sync_start(hwparams);
qLog(QAudioInput) << "can sync start =" << vval;
snd_pcm_sw_params_t *swparams;
snd_pcm_sw_params_alloca(&swparams);
err = snd_pcm_sw_params_current(handle, swparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_current: err %d",err);
}
err = snd_pcm_sw_params_set_start_threshold(handle,swparams,period_size);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_set_start_threshold: err %d",err);
}
err = snd_pcm_sw_params_set_avail_min(handle, swparams,period_size);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_set_avail_min: err %d",err);
}
err = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_set_xfer_align: err %d",err);
}
err = snd_pcm_sw_params(handle, swparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params: err %d",err);
}
snd_pcm_prepare(handle);
snd_pcm_start(handle);
int count = snd_pcm_poll_descriptors_count(handle);
pollfd *pfds = new pollfd[count];
snd_pcm_poll_descriptors(handle, pfds, count);
for (int i = 0; i < count; ++i)
{
if ((pfds[i].events & POLLIN) != 0) {
notifier = new QSocketNotifier(pfds[i].fd, QSocketNotifier::Read);
QObject::connect(notifier,
SIGNAL(activated(int)),
input,
SIGNAL(readyRead()));
break;
}
}
if (notifier == NULL) {
rc = false;
}
delete pfds;
}
return rc;
}
bool
AlsaSource::PreparePcm (snd_pcm_sframes_t *avail)
{
int err = 0;
bool closed = false;
snd_pcm_state_t state;
mutex.Lock ();
if (initialized) {
state = snd_pcm_state (pcm);
} else {
LOG_ALSA ("AlsaSource::PreparePcm (): pcm has been closed.\n");
closed = true;
}
mutex.Unlock ();
if (closed)
return false;
switch (state) {
case SND_PCM_STATE_XRUN:
LOG_ALSA ("AlsaSource::PreparePcm (): SND_PCM_STATE_XRUN.\n");
if (!XrunRecovery (-EPIPE))
return false;
started = false;
break;
case SND_PCM_STATE_SUSPENDED:
if (!XrunRecovery (-ESTRPIPE))
return false;
break;
case SND_PCM_STATE_SETUP:
if (!XrunRecovery (-EPIPE))
return false;
started = false;
break;
case SND_PCM_STATE_RUNNING:
started = true; // We might have gotten started automatically after writing a certain number of samples.
case SND_PCM_STATE_PREPARED:
break;
case SND_PCM_STATE_PAUSED:
case SND_PCM_STATE_DRAINING:
default:
LOG_ALSA ("AlsaSource::PreparePcm (): state: %s (prepare failed)\n", snd_pcm_state_name (state));
return false;
}
err = 0;
mutex.Lock ();
if (initialized) {
*avail = snd_pcm_avail_update (pcm);
} else {
closed = true;
}
mutex.Unlock ();
if (closed)
return false;
if (*avail < 0) {
if (!XrunRecovery (*avail))
return false;
started = false;
return false;
}
if ((snd_pcm_uframes_t) *avail < period_size) {
if (!started) {
LOG_ALSA ("AlsaSource::PreparePcm (): starting pcm (period size: %li, available: %li)\n", period_size, *avail);
mutex.Lock ();
if (initialized) {
err = snd_pcm_start (pcm);
} else {
closed = true;
}
mutex.Unlock ();
if (closed)
return false;
if (err < 0) {
LOG_AUDIO ("AlsaPlayer: Could not start pcm: %s\n", snd_strerror (err));
return false;
}
started = true;
} else {
return false;
}
return false;
}
LOG_ALSA ("AlsaSource::PreparePcm (): Prepared, avail: %li, started: %i\n", *avail, (int) started);
return true;
}
main(int argc, char **argv){
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
snd_pcm_uframes_t frames;
//the libsamplerate stuff
SRC_DATA datastr;//holds the data(inpu and output),input frames used, output frames generated
SRC_STATE *statestr;//holds the state
int error;
//the lbsndfile stuff, one keeps the header the other the data
SF_INFO sfinf;//has all the info like total frames,samplerate, channels, mode
SNDFILE *input = NULL;
//buffers used in computation to pass to the playback function
float *buffin = NULL;//float into the converter
float *filein = NULL;
float *flangebuffout = NULL;//float to traverse the array for getting flange effects
float *flangebase = NULL;//float to fix the array for initialising the flange effects
float *buffout = NULL;//float out of the converter
short *final = NULL;//final array to write to snd card
float fldelmax = 256;
float flfreq = 1;
float flgain = .5;
int fltime = 0;
int pcm, readcount, pcmrc, blah;//pcm is used for error checking the alsa stuff, pcmrc is used in the main loop
float *eofin;//to point to the end of the file's raw data
int tmp;//used to hold information that is printed in stdio
int i = 0;//index for initialising the output DAC
// float fldelmax, flgain, flfreq;
// pointer for the file input
if (argc != 3){
printf("Usage requires music file and src ratio, please try again\n\n");
return 0;
}
char *inputname = argv[1];
//int *filein = argv[1];
input = sf_open(inputname, SFM_READ, &sfinf);
if (input == NULL){
printf("could not open file sorry \n\n");
return 0;
}
fprintf(stderr, "Channels : %d\n", sfinf.channels);
fprintf(stderr, "Sample rate; %d\n", sfinf.samplerate);
fprintf(stderr, "Sections: %d\n", sfinf.sections);
fprintf(stderr, "Format: %d\n", sfinf.format);
// fprintf(stderr, "Frame Count: %d\n", sfinf.frames);
//fprintf(stderr, "size: %d\n", sizeof(short));
//open sndcard
if ((filein = malloc(sizeof(float)*sfinf.channels*sfinf.frames)) == NULL)
{
printf("MAN YOU OUT OF MEM");
return 0;
}
blah = sf_readf_float(input, filein, sfinf.frames);
buffin = filein;
eofin = filein + (sfinf.frames)*sfinf.channels;
if (pcm =snd_pcm_open(&handle, PCM_DEVICE, SND_PCM_STREAM_PLAYBACK, 0)< 0){
printf("Error: CANNOT OPEN PCM DEVICE\n");
}
//allocate default parameters
snd_pcm_hw_params_alloca(¶ms);
snd_pcm_hw_params_any(handle, params);
//set parameters
if (pcm = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED)< 0){
printf("Cannot set interleaved mode\n");
}
if (pcm = snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE)< 0){
printf("CANNOT SET FORMAT\n");
}
if (pcm = snd_pcm_hw_params_set_channels(handle, params, sfinf.channels)< 0){
printf("CANNOT SET CHANNELS \n");
}
if (pcm = snd_pcm_hw_params_set_rate(handle, params, sfinf.samplerate, 0)< 0){
printf("CANNOT SET SAMPLERATES \n");
}
if (pcm = snd_pcm_hw_params_set_periods(handle, params,1024, 0) < 0){
printf("CANNOT SET PERIOD TO 128");
}
//write parameters
if (pcm = snd_pcm_hw_params(handle, params)< 0){
printf("CANNOT SET HARDWARE PARAMETERS\n");
}
printf("PCm NAME: %s\n", snd_pcm_name(handle));
printf("PCM state: %s \n", snd_pcm_state_name(snd_pcm_state(handle)));
snd_pcm_hw_params_get_channels(params, &tmp);
printf("channels: %i\n", tmp);
snd_pcm_hw_params_get_rate(params, &tmp, 0);
printf("rate: %d \n", tmp);
//find size of period on hardware
snd_pcm_hw_params_get_period_size(params, &frames, 0);
fprintf(stderr, "# frames in a period: %d\n", frames);
//buffers on buffers (buffout for float output from sample rate conversion), (final for short array to write to pcm) and flangebse for the flanger stuff
buffout = malloc(frames*sfinf.channels * sizeof(float));//frames
final = malloc(frames*sfinf.channels * sizeof(short));//frames
