mirror of
https://github.com/alsa-project/alsa-lib.git
synced 2025-11-10 13:30:01 -05:00
Added I/O classes
This commit is contained in:
Abramo Bagnara
parent
da4d6f5ee8
commit
e283a3f642
32 changed files with 1882 additions and 226 deletions
|
|
@ -26,7 +26,7 @@
|
|||
#include <limits.h>
|
||||
#include <errno.h>
|
||||
#include <assert.h>
|
||||
#include <linux/asound.h>
|
||||
#include "asoundlib.h"
|
||||
#include "interval.h"
|
||||
|
||||
static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
|
||||
|
|
@ -352,18 +352,18 @@ void interval_mulkdiv(const interval_t *a, unsigned int k,
|
|||
c->integer = 0;
|
||||
}
|
||||
|
||||
void interval_print(const interval_t *i, FILE *fp)
|
||||
void interval_print(const interval_t *i, snd_output_t *out)
|
||||
{
|
||||
if (interval_empty(i))
|
||||
fprintf(fp, "NONE");
|
||||
snd_output_printf(out, "NONE");
|
||||
else if (i->min == 0 && i->openmin == 0 &&
|
||||
i->max == UINT_MAX && i->openmax == 0)
|
||||
fprintf(fp, "ALL");
|
||||
snd_output_printf(out, "ALL");
|
||||
else if (interval_single(i))
|
||||
fprintf(fp, "%u", interval_value(i));
|
||||
snd_output_printf(out, "%u", interval_value(i));
|
||||
else
|
||||
fprintf(fp, "%c%u %u%c",
|
||||
i->openmin ? '(' : '[',
|
||||
i->min, i->max,
|
||||
i->openmax ? ')' : ']');
|
||||
snd_output_printf(out, "%c%u %u%c",
|
||||
i->openmin ? '(' : '[',
|
||||
i->min, i->max,
|
||||
i->openmax ? ')' : ']');
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ void interval_muldivk(const interval_t *a, const interval_t *b,
|
|||
unsigned int k, interval_t *c);
|
||||
void interval_mulkdiv(const interval_t *a, unsigned int k,
|
||||
const interval_t *b, interval_t *c);
|
||||
void interval_print(const interval_t *i, FILE *fp);
|
||||
void interval_print(const interval_t *i, snd_output_t *out);
|
||||
int interval_refine_min(interval_t *i, unsigned int min, int openmin);
|
||||
int interval_refine_max(interval_t *i, unsigned int max, int openmax);
|
||||
int interval_refine(interval_t *i, const interval_t *v);
|
||||
|
|
|
|||
|
|
@ -501,70 +501,70 @@ const char *snd_pcm_state_name(snd_pcm_state_t state)
|
|||
return snd_pcm_state_names[state];
|
||||
}
|
||||
|
||||
int snd_pcm_dump_hw_setup(snd_pcm_t *pcm, FILE *fp)
|
||||
int snd_pcm_dump_hw_setup(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
assert(pcm);
|
||||
assert(fp);
|
||||
assert(out);
|
||||
assert(pcm->setup);
|
||||
fprintf(fp, "stream : %s\n", snd_pcm_stream_name(pcm->stream));
|
||||
fprintf(fp, "access : %s\n", snd_pcm_access_name(pcm->access));
|
||||
fprintf(fp, "format : %s\n", snd_pcm_format_name(pcm->format));
|
||||
fprintf(fp, "subformat : %s\n", snd_pcm_subformat_name(pcm->subformat));
|
||||
fprintf(fp, "channels : %u\n", pcm->channels);
|
||||
fprintf(fp, "rate : %u\n", pcm->rate);
|
||||
fprintf(fp, "exact rate : %g (%u/%u)\n", (double) pcm->rate_num / pcm->rate_den, pcm->rate_num, pcm->rate_den);
|
||||
fprintf(fp, "msbits : %u\n", pcm->msbits);
|
||||
fprintf(fp, "buffer_size : %lu\n", pcm->buffer_size);
|
||||
fprintf(fp, "period_size : %lu\n", pcm->period_size);
|
||||
fprintf(fp, "period_time : %u\n", pcm->period_time);
|
||||
fprintf(fp, "tick_time : %u\n", pcm->tick_time);
|
||||
snd_output_printf(out, "stream : %s\n", snd_pcm_stream_name(pcm->stream));
|
||||
snd_output_printf(out, "access : %s\n", snd_pcm_access_name(pcm->access));
|
||||
snd_output_printf(out, "format : %s\n", snd_pcm_format_name(pcm->format));
|
||||
snd_output_printf(out, "subformat : %s\n", snd_pcm_subformat_name(pcm->subformat));
|
||||
snd_output_printf(out, "channels : %u\n", pcm->channels);
|
||||
snd_output_printf(out, "rate : %u\n", pcm->rate);
|
||||
snd_output_printf(out, "exact rate : %g (%u/%u)\n", (double) pcm->rate_num / pcm->rate_den, pcm->rate_num, pcm->rate_den);
|
||||
snd_output_printf(out, "msbits : %u\n", pcm->msbits);
|
||||
snd_output_printf(out, "buffer_size : %lu\n", pcm->buffer_size);
|
||||
snd_output_printf(out, "period_size : %lu\n", pcm->period_size);
|
||||
snd_output_printf(out, "period_time : %u\n", pcm->period_time);
|
||||
snd_output_printf(out, "tick_time : %u\n", pcm->tick_time);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_pcm_dump_sw_setup(snd_pcm_t *pcm, FILE *fp)
|
||||
int snd_pcm_dump_sw_setup(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
assert(pcm);
|
||||
assert(fp);
|
||||
assert(out);
|
||||
assert(pcm->setup);
|
||||
fprintf(fp, "start_mode : %s\n", snd_pcm_start_mode_name(pcm->start_mode));
|
||||
fprintf(fp, "xrun_mode : %s\n", snd_pcm_xrun_mode_name(pcm->xrun_mode));
|
||||
fprintf(fp, "tstamp_mode : %s\n", snd_pcm_tstamp_mode_name(pcm->tstamp_mode));
|
||||
fprintf(fp, "period_step : %ld\n", (long)pcm->period_step);
|
||||
fprintf(fp, "sleep_min : %ld\n", (long)pcm->sleep_min);
|
||||
fprintf(fp, "avail_min : %ld\n", (long)pcm->avail_min);
|
||||
fprintf(fp, "xfer_align : %ld\n", (long)pcm->xfer_align);
|
||||
fprintf(fp, "silence_threshold: %ld\n", (long)pcm->silence_threshold);
|
||||
fprintf(fp, "silence_size : %ld\n", (long)pcm->silence_size);
|
||||
fprintf(fp, "boundary : %ld\n", (long)pcm->boundary);
|
||||
snd_output_printf(out, "start_mode : %s\n", snd_pcm_start_mode_name(pcm->start_mode));
|
||||
snd_output_printf(out, "xrun_mode : %s\n", snd_pcm_xrun_mode_name(pcm->xrun_mode));
|
||||
snd_output_printf(out, "tstamp_mode : %s\n", snd_pcm_tstamp_mode_name(pcm->tstamp_mode));
|
||||
snd_output_printf(out, "period_step : %ld\n", (long)pcm->period_step);
|
||||
snd_output_printf(out, "sleep_min : %ld\n", (long)pcm->sleep_min);
|
||||
snd_output_printf(out, "avail_min : %ld\n", (long)pcm->avail_min);
|
||||
snd_output_printf(out, "xfer_align : %ld\n", (long)pcm->xfer_align);
|
||||
snd_output_printf(out, "silence_threshold: %ld\n", (long)pcm->silence_threshold);
|
||||
snd_output_printf(out, "silence_size : %ld\n", (long)pcm->silence_size);
|
||||
snd_output_printf(out, "boundary : %ld\n", (long)pcm->boundary);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_pcm_dump_setup(snd_pcm_t *pcm, FILE *fp)
|
||||
int snd_pcm_dump_setup(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_dump_hw_setup(pcm, fp);
|
||||
snd_pcm_dump_sw_setup(pcm, fp);
|
||||
snd_pcm_dump_hw_setup(pcm, out);
|
||||
snd_pcm_dump_sw_setup(pcm, out);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_pcm_status_dump(snd_pcm_status_t *status, FILE *fp)
|
||||
int snd_pcm_status_dump(snd_pcm_status_t *status, snd_output_t *out)
|
||||
{
|
||||
assert(status);
|
||||
fprintf(fp, "state : %s\n", snd_pcm_state_name(status->state));
|
||||
fprintf(fp, "trigger_time: %ld.%06ld\n",
|
||||
snd_output_printf(out, "state : %s\n", snd_pcm_state_name(status->state));
|
||||
snd_output_printf(out, "trigger_time: %ld.%06ld\n",
|
||||
status->trigger_time.tv_sec, status->trigger_time.tv_usec);
|
||||
fprintf(fp, "tstamp : %ld.%06ld\n",
|
||||
snd_output_printf(out, "tstamp : %ld.%06ld\n",
|
||||
status->tstamp.tv_sec, status->tstamp.tv_usec);
|
||||
fprintf(fp, "delay : %ld\n", (long)status->delay);
|
||||
fprintf(fp, "avail : %ld\n", (long)status->avail);
|
||||
fprintf(fp, "avail_max : %ld\n", (long)status->avail_max);
|
||||
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 snd_pcm_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
int snd_pcm_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
assert(pcm);
|
||||
assert(fp);
|
||||
pcm->ops->dump(pcm->op_arg, fp);
|
||||
assert(out);
|
||||
pcm->ops->dump(pcm->op_arg, out);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -530,17 +530,17 @@ static snd_pcm_sframes_t snd_pcm_adpcm_read_areas(snd_pcm_t *pcm,
|
|||
return err;
|
||||
}
|
||||
|
||||
static void snd_pcm_adpcm_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_adpcm_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_adpcm_t *adpcm = pcm->private;
|
||||
fprintf(fp, "Ima-ADPCM conversion PCM (%s)\n",
|
||||
snd_output_printf(out, "Ima-ADPCM conversion PCM (%s)\n",
|
||||
snd_pcm_format_name(adpcm->sformat));
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(adpcm->plug.slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(adpcm->plug.slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_adpcm_ops = {
|
||||
|
|
|
|||
|
|
@ -398,17 +398,17 @@ static snd_pcm_sframes_t snd_pcm_alaw_read_areas(snd_pcm_t *pcm,
|
|||
return err;
|
||||
}
|
||||
|
||||
static void snd_pcm_alaw_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_alaw_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_alaw_t *alaw = pcm->private;
|
||||
fprintf(fp, "A-Law conversion PCM (%s)\n",
|
||||
snd_output_printf(out, "A-Law conversion PCM (%s)\n",
|
||||
snd_pcm_format_name(alaw->sformat));
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(alaw->plug.slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(alaw->plug.slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_alaw_ops = {
|
||||
|
|
|
|||
|
|
@ -155,16 +155,16 @@ static snd_pcm_sframes_t snd_pcm_copy_read_areas(snd_pcm_t *pcm,
|
|||
return err;
|
||||
}
|
||||
|
||||
static void snd_pcm_copy_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_copy_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_copy_t *copy = pcm->private;
|
||||
fprintf(fp, "Copy conversion PCM\n");
|
||||
snd_output_printf(out, "Copy conversion PCM\n");
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(copy->plug.slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(copy->plug.slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_copy_ops = {
|
||||
|
|
|
|||
|
|
@ -357,19 +357,19 @@ static int snd_pcm_file_munmap(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void snd_pcm_file_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_file_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_file_t *file = pcm->private;
|
||||
if (file->fname)
|
||||
fprintf(fp, "File PCM (file=%s)\n", file->fname);
|
||||
snd_output_printf(out, "File PCM (file=%s)\n", file->fname);
|
||||
else
|
||||
fprintf(fp, "File PCM (fd=%d)\n", file->fd);
|
||||
snd_output_printf(out, "File PCM (fd=%d)\n", file->fd);
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(file->slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(file->slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_file_ops = {
|
||||
|
|
|
|||
|
|
@ -488,17 +488,17 @@ static snd_pcm_sframes_t snd_pcm_hw_avail_update(snd_pcm_t *pcm)
|
|||
return avail;
|
||||
}
|
||||
|
||||
static void snd_pcm_hw_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_hw_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_hw_t *hw = pcm->private;
|
||||
char *name = "Unknown";
|
||||
snd_card_get_name(hw->card, &name);
|
||||
fprintf(fp, "Hardware PCM card %d '%s' device %d subdevice %d\n",
|
||||
snd_output_printf(out, "Hardware PCM card %d '%s' device %d subdevice %d\n",
|
||||
hw->card, name, hw->device, hw->subdevice);
|
||||
free(name);
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -237,17 +237,17 @@ static snd_pcm_sframes_t snd_pcm_linear_read_areas(snd_pcm_t *pcm,
|
|||
return err;
|
||||
}
|
||||
|
||||
static void snd_pcm_linear_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_linear_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_linear_t *linear = pcm->private;
|
||||
fprintf(fp, "Linear conversion PCM (%s)\n",
|
||||
snd_output_printf(out, "Linear conversion PCM (%s)\n",
|
||||
snd_pcm_format_name(linear->sformat));
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(linear->plug.slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(linear->plug.slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_linear_ops = {
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ typedef struct {
|
|||
int (*hw_params)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
int (*sw_params)(snd_pcm_t *pcm, snd_pcm_sw_params_t *params);
|
||||
int (*channel_info)(snd_pcm_t *pcm, snd_pcm_channel_info_t *info);
|
||||
void (*dump)(snd_pcm_t *pcm, FILE *fp);
|
||||
void (*dump)(snd_pcm_t *pcm, snd_output_t *out);
|
||||
int (*mmap)(snd_pcm_t *pcm);
|
||||
int (*munmap)(snd_pcm_t *pcm);
|
||||
} snd_pcm_ops_t;
|
||||
|
|
|
|||
|
|
@ -415,17 +415,17 @@ static snd_pcm_sframes_t snd_pcm_mulaw_read_areas(snd_pcm_t *pcm,
|
|||
return err;
|
||||
}
|
||||
|
||||
static void snd_pcm_mulaw_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_mulaw_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_mulaw_t *mulaw = pcm->private;
|
||||
fprintf(fp, "Mu-Law conversion PCM (%s)\n",
|
||||
snd_output_printf(out, "Mu-Law conversion PCM (%s)\n",
|
||||
snd_pcm_format_name(mulaw->sformat));
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(mulaw->plug.slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(mulaw->plug.slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_mulaw_ops = {
|
||||
|
|
|
|||
|
|
@ -383,26 +383,26 @@ int snd_pcm_multi_poll_descriptor(snd_pcm_t *pcm)
|
|||
return snd_pcm_poll_descriptor(slave);
|
||||
}
|
||||
|
||||
static void snd_pcm_multi_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_multi_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_multi_t *multi = pcm->private;
|
||||
unsigned int k;
|
||||
fprintf(fp, "Multi PCM\n");
|
||||
fprintf(fp, "\nChannel bindings:\n");
|
||||
snd_output_printf(out, "Multi PCM\n");
|
||||
snd_output_printf(out, "\nChannel bindings:\n");
|
||||
for (k = 0; k < multi->channels_count; ++k) {
|
||||
snd_pcm_multi_channel_t *c = &multi->channels[k];
|
||||
if (c->slave_idx < 0)
|
||||
continue;
|
||||
fprintf(fp, "%d: slave %d, channel %d\n",
|
||||
snd_output_printf(out, "%d: slave %d, channel %d\n",
|
||||
k, c->slave_idx, c->slave_channel);
|
||||
}
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
for (k = 0; k < multi->slaves_count; ++k) {
|
||||
fprintf(fp, "\nSlave #%d: ", k);
|
||||
snd_pcm_dump(multi->slaves[k].pcm, fp);
|
||||
snd_output_printf(out, "\nSlave #%d: ", k);
|
||||
snd_pcm_dump(multi->slaves[k].pcm, out);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -271,12 +271,12 @@ static int snd_pcm_null_munmap(snd_pcm_t *pcm)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void snd_pcm_null_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_null_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
fprintf(fp, "Null PCM\n");
|
||||
snd_output_printf(out, "Null PCM\n");
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1117,7 +1117,7 @@ void snd_pcm_hw_param_copy(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var,
|
|||
}
|
||||
|
||||
void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
|
||||
snd_pcm_hw_param_t var, FILE *fp)
|
||||
snd_pcm_hw_param_t var, snd_output_t *out)
|
||||
{
|
||||
static const char *(*funcs[])(unsigned int k) = {
|
||||
[SND_PCM_HW_PARAM_ACCESS] = snd_pcm_access_name,
|
||||
|
|
@ -1127,9 +1127,9 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
|
|||
if (hw_is_mask(var)) {
|
||||
const mask_t *mask = hw_param_mask_c(params, var);
|
||||
if (mask_empty(mask))
|
||||
fputs(" NONE", fp);
|
||||
snd_output_puts(out, " NONE");
|
||||
else if (mask_full(mask))
|
||||
fputs(" ALL", fp);
|
||||
snd_output_puts(out, " ALL");
|
||||
else {
|
||||
unsigned int k;
|
||||
const char *(*f)(unsigned int k);
|
||||
|
|
@ -1138,27 +1138,27 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
|
|||
assert(f);
|
||||
for (k = 0; k <= MASK_MAX; ++k) {
|
||||
if (mask_test(mask, k)) {
|
||||
putc(' ', fp);
|
||||
fputs(f(k), fp);
|
||||
snd_output_putc(out, ' ');
|
||||
snd_output_puts(out, f(k));
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (hw_is_interval(var)) {
|
||||
interval_print(hw_param_interval_c(params, var), fp);
|
||||
interval_print(hw_param_interval_c(params, var), out);
|
||||
return;
|
||||
}
|
||||
assert(0);
|
||||
}
|
||||
|
||||
int snd_pcm_hw_params_dump(snd_pcm_hw_params_t *params, FILE *fp)
|
||||
int snd_pcm_hw_params_dump(snd_pcm_hw_params_t *params, snd_output_t *out)
|
||||
{
|
||||
unsigned int k;
|
||||
for (k = 0; k <= SND_PCM_HW_PARAM_LAST; k++) {
|
||||
fprintf(fp, "%s: ", snd_pcm_hw_param_name(k));
|
||||
snd_pcm_hw_param_dump(params, k, fp);
|
||||
putc('\n', fp);
|
||||
snd_output_printf(out, "%s: ", snd_pcm_hw_param_name(k));
|
||||
snd_pcm_hw_param_dump(params, k, out);
|
||||
snd_output_putc(out, '\n');
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1466,7 +1466,7 @@ int snd_pcm_hw_params_try_explain_failure1(snd_pcm_t *pcm,
|
|||
snd_pcm_hw_params_t *fail,
|
||||
snd_pcm_hw_params_t *success,
|
||||
unsigned int depth,
|
||||
FILE *fp)
|
||||
snd_output_t *out)
|
||||
{
|
||||
snd_pcm_hw_param_t var;
|
||||
snd_pcm_hw_params_t i;
|
||||
|
|
@ -1478,11 +1478,11 @@ int snd_pcm_hw_params_try_explain_failure1(snd_pcm_t *pcm,
|
|||
snd_pcm_hw_param_copy(&i, var, fail);
|
||||
err = snd_pcm_hw_refine(pcm, &i);
|
||||
if (err == 0 &&
|
||||
snd_pcm_hw_params_try_explain_failure1(pcm, fail, &i, depth - 1, fp) < 0)
|
||||
snd_pcm_hw_params_try_explain_failure1(pcm, fail, &i, depth - 1, out) < 0)
|
||||
continue;
|
||||
fprintf(fp, "%s: ", snd_pcm_hw_param_name(var));
|
||||
snd_pcm_hw_param_dump(fail, var, fp);
|
||||
putc('\n', fp);
|
||||
snd_output_printf(out, "%s: ", snd_pcm_hw_param_name(var));
|
||||
snd_pcm_hw_param_dump(fail, var, out);
|
||||
snd_output_putc(out, '\n');
|
||||
return 0;
|
||||
}
|
||||
return -ENOENT;
|
||||
|
|
@ -1492,7 +1492,7 @@ int snd_pcm_hw_params_try_explain_failure(snd_pcm_t *pcm,
|
|||
snd_pcm_hw_params_t *fail,
|
||||
snd_pcm_hw_params_t *success,
|
||||
unsigned int depth,
|
||||
FILE *fp)
|
||||
snd_output_t *out)
|
||||
{
|
||||
snd_pcm_hw_params_t i, any;
|
||||
int err;
|
||||
|
|
@ -1502,7 +1502,7 @@ int snd_pcm_hw_params_try_explain_failure(snd_pcm_t *pcm,
|
|||
for (var = 0; var <= SND_PCM_HW_PARAM_LAST; var++) {
|
||||
if (!snd_pcm_hw_param_empty(fail, var))
|
||||
continue;
|
||||
fprintf(fp, "%s is empty\n", snd_pcm_hw_param_name(var));
|
||||
snd_output_printf(out, "%s is empty\n", snd_pcm_hw_param_name(var));
|
||||
done = 1;
|
||||
}
|
||||
if (done)
|
||||
|
|
@ -1510,14 +1510,14 @@ int snd_pcm_hw_params_try_explain_failure(snd_pcm_t *pcm,
|
|||
i = *fail;
|
||||
err = snd_pcm_hw_refine(pcm, &i);
|
||||
if (err == 0) {
|
||||
fprintf(fp, "Configuration is virtually correct\n");
|
||||
snd_output_printf(out, "Configuration is virtually correct\n");
|
||||
return 0;
|
||||
}
|
||||
if (!success) {
|
||||
snd_pcm_hw_params_any(pcm, &any);
|
||||
success = &any;
|
||||
}
|
||||
return snd_pcm_hw_params_try_explain_failure1(pcm, fail, success, depth, fp);
|
||||
return snd_pcm_hw_params_try_explain_failure1(pcm, fail, success, depth, out);
|
||||
}
|
||||
|
||||
typedef struct _snd_pcm_hw_rule snd_pcm_hw_rule_t;
|
||||
|
|
@ -2151,48 +2151,48 @@ int snd_pcm_sw_param_near(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
|
|||
}
|
||||
|
||||
void snd_pcm_sw_param_dump(const snd_pcm_sw_params_t *params,
|
||||
snd_pcm_sw_param_t var, FILE *fp)
|
||||
snd_pcm_sw_param_t var, snd_output_t *out)
|
||||
{
|
||||
switch (var) {
|
||||
case SND_PCM_SW_PARAM_START_MODE:
|
||||
fputs(snd_pcm_start_mode_name(params->start_mode), fp);
|
||||
snd_output_puts(out, snd_pcm_start_mode_name(params->start_mode));
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_XRUN_MODE:
|
||||
fputs(snd_pcm_xrun_mode_name(params->xrun_mode), fp);
|
||||
snd_output_puts(out, snd_pcm_xrun_mode_name(params->xrun_mode));
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_TSTAMP_MODE:
|
||||
fputs(snd_pcm_tstamp_mode_name(params->tstamp_mode), fp);
|
||||
snd_output_puts(out, snd_pcm_tstamp_mode_name(params->tstamp_mode));
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_PERIOD_STEP:
|
||||
fprintf(fp, "%d", params->period_step);
|
||||
snd_output_printf(out, "%d", params->period_step);
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_SLEEP_MIN:
|
||||
fprintf(fp, "%d", params->sleep_min);
|
||||
snd_output_printf(out, "%d", params->sleep_min);
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_AVAIL_MIN:
|
||||
fprintf(fp, "%ld", (long) params->avail_min);
|
||||
snd_output_printf(out, "%ld", (long) params->avail_min);
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_XFER_ALIGN:
|
||||
fprintf(fp, "%ld", (long) params->xfer_align);
|
||||
snd_output_printf(out, "%ld", (long) params->xfer_align);
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_SILENCE_THRESHOLD:
|
||||
fprintf(fp, "%ld", (long) params->silence_threshold);
|
||||
snd_output_printf(out, "%ld", (long) params->silence_threshold);
|
||||
break;
|
||||
case SND_PCM_SW_PARAM_SILENCE_SIZE:
|
||||
fprintf(fp, "%ld", (long) params->silence_size);
|
||||
snd_output_printf(out, "%ld", (long) params->silence_size);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
|
||||
int snd_pcm_sw_params_dump(snd_pcm_sw_params_t *params, FILE *fp)
|
||||
int snd_pcm_sw_params_dump(snd_pcm_sw_params_t *params, snd_output_t *out)
|
||||
{
|
||||
unsigned int k;
|
||||
for (k = 0; k <= SND_PCM_SW_PARAM_LAST; k++) {
|
||||
fprintf(fp, "%s: ", snd_pcm_sw_param_name(k));
|
||||
snd_pcm_sw_param_dump(params, k, fp);
|
||||
putc('\n', fp);
|
||||
snd_output_printf(out, "%s: ", snd_pcm_sw_param_name(k));
|
||||
snd_pcm_sw_param_dump(params, k, out);
|
||||
snd_output_putc(out, '\n');
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -365,19 +365,7 @@ static int snd_pcm_plug_hw_refine1(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
|
|||
static int snd_pcm_plug_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
|
||||
{
|
||||
snd_pcm_hw_params_t sparams;
|
||||
int err;
|
||||
#if 0
|
||||
fprintf(stderr, "Enter: client =\n");
|
||||
snd_pcm_hw_params_dump(params, stderr);
|
||||
#endif
|
||||
err = snd_pcm_plug_hw_refine1(pcm, params, &sparams);
|
||||
#if 0
|
||||
fprintf(stderr, "Exit: client =\n");
|
||||
snd_pcm_hw_params_dump(params, stderr);
|
||||
fprintf(stderr, "Exit: slave =\n");
|
||||
snd_pcm_hw_params_dump(&sparams, stderr);
|
||||
#endif
|
||||
return err;
|
||||
return snd_pcm_plug_hw_refine1(pcm, params, &sparams);
|
||||
}
|
||||
|
||||
static void snd_pcm_plug_clear(snd_pcm_t *pcm)
|
||||
|
|
@ -670,11 +658,11 @@ static int snd_pcm_plug_munmap(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void snd_pcm_plug_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_plug_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_plug_t *plug = pcm->private;
|
||||
fprintf(fp, "Plug PCM: ");
|
||||
snd_pcm_dump(plug->slave, fp);
|
||||
snd_output_printf(out, "Plug PCM: ");
|
||||
snd_pcm_dump(plug->slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_plug_ops = {
|
||||
|
|
|
|||
|
|
@ -531,22 +531,22 @@ snd_pcm_sframes_t snd_pcm_rate_slave_frames(snd_pcm_t *pcm, snd_pcm_sframes_t fr
|
|||
return muldiv_down(frames, DIV, rate->pitch);
|
||||
}
|
||||
|
||||
static void snd_pcm_rate_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_rate_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_rate_t *rate = pcm->private;
|
||||
if (rate->sformat < 0)
|
||||
fprintf(fp, "Rate conversion PCM (%d)\n",
|
||||
snd_output_printf(out, "Rate conversion PCM (%d)\n",
|
||||
rate->srate);
|
||||
else
|
||||
fprintf(fp, "Rate conversion PCM (%d, sformat=%s)\n",
|
||||
snd_output_printf(out, "Rate conversion PCM (%d, sformat=%s)\n",
|
||||
rate->srate,
|
||||
snd_pcm_format_name(rate->sformat));
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(rate->plug.slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(rate->plug.slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_rate_ops = {
|
||||
|
|
|
|||
|
|
@ -633,42 +633,42 @@ static snd_pcm_sframes_t snd_pcm_route_read_areas(snd_pcm_t *pcm,
|
|||
return err;
|
||||
}
|
||||
|
||||
static void snd_pcm_route_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_route_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_route_t *route = pcm->private;
|
||||
unsigned int dst;
|
||||
if (route->sformat < 0)
|
||||
fprintf(fp, "Route conversion PCM\n");
|
||||
snd_output_printf(out, "Route conversion PCM\n");
|
||||
else
|
||||
fprintf(fp, "Route conversion PCM (sformat=%s)\n",
|
||||
snd_output_printf(out, "Route conversion PCM (sformat=%s)\n",
|
||||
snd_pcm_format_name(route->sformat));
|
||||
fputs("Transformation table:\n", fp);
|
||||
snd_output_puts(out, "Transformation table:\n");
|
||||
for (dst = 0; dst < route->params.ndsts; dst++) {
|
||||
ttable_dst_t *d = &route->params.dsts[dst];
|
||||
unsigned int src;
|
||||
if (d->nsrcs == 0)
|
||||
continue;
|
||||
fprintf(fp, "%d <- ", dst);
|
||||
snd_output_printf(out, "%d <- ", dst);
|
||||
src = 0;
|
||||
while (1) {
|
||||
ttable_src_t *s = &d->srcs[src];
|
||||
if (d->att)
|
||||
fprintf(fp, "%d*%g", s->channel, s->as_float);
|
||||
snd_output_printf(out, "%d*%g", s->channel, s->as_float);
|
||||
else
|
||||
fprintf(fp, "%d", s->channel);
|
||||
snd_output_printf(out, "%d", s->channel);
|
||||
src++;
|
||||
if (src == d->nsrcs)
|
||||
break;
|
||||
fputs(" + ", fp);
|
||||
snd_output_puts(out, " + ");
|
||||
}
|
||||
putc('\n', fp);
|
||||
snd_output_putc(out, '\n');
|
||||
}
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "Its setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(route->plug.slave, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(route->plug.slave, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_route_ops = {
|
||||
|
|
|
|||
|
|
@ -1071,21 +1071,21 @@ static int snd_pcm_share_munmap(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void snd_pcm_share_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_share_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_share_t *share = pcm->private;
|
||||
snd_pcm_share_slave_t *slave = share->slave;
|
||||
unsigned int k;
|
||||
fprintf(fp, "Share PCM\n");
|
||||
fprintf(fp, "\nChannel bindings:\n");
|
||||
snd_output_printf(out, "Share PCM\n");
|
||||
snd_output_printf(out, "\nChannel bindings:\n");
|
||||
for (k = 0; k < share->channels_count; ++k)
|
||||
fprintf(fp, "%d: %d\n", k, share->slave_channels[k]);
|
||||
snd_output_printf(out, "%d: %d\n", k, share->slave_channels[k]);
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
fprintf(fp, "Slave: ");
|
||||
snd_pcm_dump(slave->pcm, fp);
|
||||
snd_output_printf(out, "Slave: ");
|
||||
snd_pcm_dump(slave->pcm, out);
|
||||
}
|
||||
|
||||
snd_pcm_ops_t snd_pcm_share_ops = {
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ static int snd_pcm_shm_action(snd_pcm_t *pcm)
|
|||
if (err != 1)
|
||||
return -EBADFD;
|
||||
if (ctrl->cmd) {
|
||||
fprintf(stderr, "Server has not done the cmd\n");
|
||||
ERR("Server has not done the cmd");
|
||||
return -EBADFD;
|
||||
}
|
||||
return ctrl->result;
|
||||
|
|
@ -110,7 +110,7 @@ static int snd_pcm_shm_action_fd(snd_pcm_t *pcm, int *fd)
|
|||
if (err != 1)
|
||||
return -EBADFD;
|
||||
if (ctrl->cmd) {
|
||||
fprintf(stderr, "Server has not done the cmd\n");
|
||||
ERR("Server has not done the cmd");
|
||||
return -EBADFD;
|
||||
}
|
||||
return ctrl->result;
|
||||
|
|
@ -463,12 +463,12 @@ static int snd_pcm_shm_close(snd_pcm_t *pcm)
|
|||
return result;
|
||||
}
|
||||
|
||||
static void snd_pcm_shm_dump(snd_pcm_t *pcm, FILE *fp)
|
||||
static void snd_pcm_shm_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
fprintf(fp, "Shm PCM\n");
|
||||
snd_output_printf(out, "Shm PCM\n");
|
||||
if (pcm->setup) {
|
||||
fprintf(fp, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, fp);
|
||||
snd_output_printf(out, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue