On Mon, 8 Oct 2007, Peteris Krisjanis wrote:

...

Introducing a /proc/asound/card0/pcm0{p,c}/hw_limits or similar might not be a bad idea though?

That would be good idea, with completion with 'alsainfo' about device.

How to do that properly, any clues before I try to sink my teeths in ALSA code?

Is this even possible? Ie, do sound cards actually tell you what their max or min hardware capabilities are and what info might you put into here? Ie, some cards can do 2 or 4 or 5.1 channel output. Do you put that in? And re speed, does the card actually advertise what speeds it supports, or is it more a matter of trying and if it does not support it, it rejects it.

On 10/08/2007 09:30 PM, Rene Herman wrote:

On 10/08/2007 09:14 PM, Bill Unruh wrote:

...

...

...

Introducing a /proc/asound/card0/pcm0{p,c}/hw_limits or similar might not be a bad idea though?

[ ... ]

It could also be done in userspace by opening the stream and quering the format_mask, channels and rates and stuff and I'll look into that a bit as a followup to the rates_min/max thing that I posted if only as a template thingy, but unless I'm missing it, I don't believe there's actually a way to get the information from userspace without opening the "hw" device, and that one only allows "subdevices_count" concurrent opens, meaning you'd have to stop things talking to your soundcard if it has just one (normal).

Okay, well, in userspace it would be something like this.

Not too sure about that subformat thing by the way. Jaroslav (or anyone, obviously): is the subformat intended/designed to be format-specific or snd_pcm_t global?

Currently there is only ever one subformat (STD) anyway but generally, I'd expect a subformat to be specific to a given format. There's just one non format-specific SND_PCM_SUBFORMAT_LAST though, no defines (or functions) to get subformats from the format. Is the design that all formats would be supporting all subformats or something?

This is modelled after the hw_params file in an opened substream directory (and ignores the possibility of anything more involved than simple min-max intervals). Provide a "-c" for the capture direction.

Not sure if this helps much (other than hopefully teaching me about subformats).

Rene

/* gcc -W -Wall -o ainfo ainfo.c -lasound */

#include <stdio.h> #include <unistd.h> #include <alsa/asoundlib.h>

#define DEVICE "hw:0,0" #define STREAM SND_PCM_STREAM_PLAYBACK

void snd_perror(const char *s, int err) { fprintf(stderr, "%s: %s\n", s, snd_strerror(err)); }

int hw_params_access(snd_pcm_hw_params_t *params) { snd_pcm_access_mask_t *mask; snd_pcm_access_t val; int err;

err = snd_pcm_access_mask_malloc(&mask); if (err < 0) { snd_perror("snd_pcm_acess_mask_malloc", err); return err; } snd_pcm_hw_params_get_access_mask(params, mask);

printf("access:"); for (val = 0; val <= SND_PCM_ACCESS_LAST; val++) if (snd_pcm_access_mask_test(mask, val)) printf(" %s", snd_pcm_access_name(val)); printf("\n");

snd_pcm_access_mask_free(mask); return 0; }

int hw_params_format(snd_pcm_hw_params_t *params) { snd_pcm_format_mask_t *mask; snd_pcm_format_t val; int err;

err = snd_pcm_format_mask_malloc(&mask); if (err < 0) { snd_perror("snd_pcm_format_mask_malloc", err); return err; } snd_pcm_hw_params_get_format_mask(params, mask);

printf("format:"); for (val = 0; val <= SND_PCM_FORMAT_LAST; val++) if (snd_pcm_format_mask_test(mask, val)) printf(" %s", snd_pcm_format_name(val)); printf("\n");

snd_pcm_format_mask_free(mask); return 0; }

int hw_params_subformat(snd_pcm_hw_params_t *params) { snd_pcm_subformat_mask_t *mask; snd_pcm_subformat_t val; int err;

err = snd_pcm_subformat_mask_malloc(&mask); if (err < 0) { snd_perror("snd_pcm_subformat_mask_malloc", err); return err; } snd_pcm_hw_params_get_subformat_mask(params, mask);

printf("subformat:"); for (val = 0; val <= SND_PCM_SUBFORMAT_LAST; val++) if (snd_pcm_subformat_mask_test(mask, val)) printf(" %s", snd_pcm_subformat_name(val)); printf("\n");

snd_pcm_subformat_mask_free(mask); return 0; }

int hw_params_channels(snd_pcm_hw_params_t *params) { unsigned int min; unsigned int max; int err;

err = snd_pcm_hw_params_get_channels_min(params, &min); if (err < 0) { snd_perror("snd_pcm_hw_params_get_channels_min", err); return err; } err = snd_pcm_hw_params_get_channels_max(params, &max); if (err < 0) { snd_perror("snd_pcm_hw_params_get_channels_max", err); return err; } printf("channels: %u-%u\n", min, max); return 0; }

int hw_params_rate(snd_pcm_hw_params_t *params) { unsigned int min; unsigned int max; int dir; int err;

err = snd_pcm_hw_params_get_rate_min(params, &min, &dir); if (err < 0) { snd_perror("snd_pcm_hw_params_get_rate_min", err); return err; } err = snd_pcm_hw_params_get_rate_max(params, &max, &dir); if (err < 0) { snd_perror("snd_pcm_hw_params_get_rate_max", err); return err; } printf("rate: %u-%u\n", min, max); return 0; }

int hw_params_period_size(snd_pcm_hw_params_t *params) { snd_pcm_uframes_t min; snd_pcm_uframes_t max; int dir; int err;

err = snd_pcm_hw_params_get_period_size_min(params, &min, &dir); if (err < 0) { snd_perror("snd_pcm_hw_params_get_period_size_min", err); return err; } err = snd_pcm_hw_params_get_period_size_max(params, &max, &dir); if (err < 0) { snd_perror("snd_pcm_hw_params_get_period_size_max", err); return err; } printf("period_size: %lu-%lu\n", min, max); return 0; }

int hw_params_buffer_size(snd_pcm_hw_params_t *params) { snd_pcm_uframes_t min; snd_pcm_uframes_t max; int err;

err = snd_pcm_hw_params_get_buffer_size_min(params, &min); if (err < 0) { snd_perror("snd_pcm_hw_params_get_buffer_size_min", err); return err; } err = snd_pcm_hw_params_get_buffer_size_max(params, &max); if (err < 0) { snd_perror("snd_pcm_hw_params_get_buffer_size_max", err); return err; } printf("buffer_size: %lu-%lu\n", min, max); return 0; }

int hw_params_tick_time(snd_pcm_hw_params_t *params) { unsigned int min; unsigned int max; int dir; int err;

err = snd_pcm_hw_params_get_tick_time_min(params, &min, &dir); if (err < 0) { snd_perror("snd_pcm_hw_params_get_tick_time_min", err); return err; } err = snd_pcm_hw_params_get_tick_time_max(params, &max, &dir); if (err < 0) { snd_perror("snd_pcm_hw_params_get_tick_time_max", err); return err; } printf("tick_time: %u-%u\n", min, max); return 0; }

int hw_params(snd_pcm_t *handle) { snd_pcm_hw_params_t *params; int err;

err = snd_pcm_hw_params_malloc(&params); if (err < 0) { snd_perror("snd_pcm_hw_params_alloc", err); return err; } err = snd_pcm_hw_params_any(handle, params); if (err < 0) { snd_perror("snd_pcm_hw_params_any", err); return err; } err = snd_pcm_hw_params_set_rate_resample(handle, params, 0); if (err < 0) { snd_perror("snd_pcm_hw_params_set_resample", err); return err; }

err = hw_params_access(params); if (err < 0) return err;

err = hw_params_format(params); if (err < 0) return err;

err = hw_params_subformat(params); if (err < 0) return err;

err = hw_params_channels(params); if (err < 0) return err;

err = hw_params_rate(params); if (err < 0) return err;

err = hw_params_period_size(params); if (err < 0) return err;

err = hw_params_buffer_size(params); if (err < 0) return err;

err = hw_params_tick_time(params); if (err < 0) return err;

snd_pcm_hw_params_free(params); return 0; }

int main(int argc, char *argv[]) { const char *device = DEVICE; snd_pcm_stream_t stream = STREAM;

snd_pcm_t *handle; int err;

while ((err = getopt(argc, argv, "pc")) != -1) switch (err) { case 'p': stream = SND_PCM_STREAM_PLAYBACK; break; case 'c': stream = SND_PCM_STREAM_CAPTURE; break; case '?': return -1; }

if (optind < argc) device = argv[optind];

err = snd_pcm_open(&handle, device, stream, 0); if (err < 0) { snd_perror("snd_pcm_open", err); return err; }

err = hw_params(handle); if (err < 0) return err; err = snd_pcm_close(handle); if (err < 0) { snd_perror("snd_pcm_close", err); return err; }

return 0; }

At Mon, 15 Oct 2007 22:20:10 +0200, Rene Herman wrote:

On 10/09/2007 02:23 AM, Rene Herman wrote:

...

Not too sure about that subformat thing by the way. Jaroslav (or anyone, obviously): is the subformat intended/designed to be format-specific or snd_pcm_t global?

Currently there is only ever one subformat (STD) anyway but generally, I'd expect a subformat to be specific to a given format. There's just one non format-specific SND_PCM_SUBFORMAT_LAST though, no defines (or functions) to get subformats from the format. Is the design that all formats would be supporting all subformats or something?

Takashi, with Jaroslav his usual blackhole self -- do you know what the idea is of the subformats?

I'm also not 100% sure, and I think this hasn't been much discussed until now. That's why we have no definition yet.

As my understanding, it could be both. The sub-format is in general an additional attribute. An attribute can be generic for all formats and can be specific for certain formats.

IMO, we can drop this field now (but keep it as a place holder for compatibility).

Takashi