mirror of
https://github.com/alsa-project/alsa-lib.git
synced 2025-11-05 13:30:00 -05:00
dshare and dsnoop plugins are working now
This commit is contained in:
Jaroslav Kysela
parent
87538939bd
commit
7470a5b9af
5 changed files with 510 additions and 589 deletions
|
|
@ -52,85 +52,94 @@ const char *_snd_module_pcm_dsnoop = "";
|
|||
*
|
||||
*/
|
||||
|
||||
static void snoop_areas(snd_pcm_direct_t *dmix,
|
||||
static void snoop_areas(snd_pcm_direct_t *dsnoop,
|
||||
const snd_pcm_channel_area_t *src_areas,
|
||||
const snd_pcm_channel_area_t *dst_areas,
|
||||
snd_pcm_uframes_t src_ofs,
|
||||
snd_pcm_uframes_t dst_ofs,
|
||||
snd_pcm_uframes_t size)
|
||||
{
|
||||
if (dmix->interleaved) {
|
||||
unsigned int chn, schn, channels;
|
||||
snd_pcm_format_t format;
|
||||
|
||||
channels = dsnoop->channels;
|
||||
format = dsnoop->shmptr->s.format;
|
||||
if (dsnoop->interleaved) {
|
||||
unsigned int fbytes = snd_pcm_format_physical_width(format) / 8;
|
||||
memcpy(((char *)dst_areas[0].addr) + (dst_ofs * channels * fbytes),
|
||||
((char *)src_areas[0].addr) + (src_ofs * channels * fbytes),
|
||||
size * channels * fbytes);
|
||||
} else {
|
||||
for (chn = 0; chn < channels; chn++) {
|
||||
schn = dsnoop->bindings ? dsnoop->bindings[chn] : chn;
|
||||
snd_pcm_area_copy(&dst_areas[chn], dst_ofs, &src_areas[schn], src_ofs, size, format);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* synchronize shm ring buffer with hardware
|
||||
*/
|
||||
static void snd_pcm_dsnoop_sync_area(snd_pcm_t *pcm, snd_pcm_uframes_t size)
|
||||
static void snd_pcm_dsnoop_sync_area(snd_pcm_t *pcm, snd_pcm_uframes_t slave_hw_ptr, snd_pcm_uframes_t size)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_uframes_t appl_ptr, slave_appl_ptr, transfer;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
snd_pcm_uframes_t hw_ptr = dsnoop->hw_ptr;
|
||||
snd_pcm_uframes_t transfer;
|
||||
const snd_pcm_channel_area_t *src_areas, *dst_areas;
|
||||
|
||||
/* get the start of update area */
|
||||
appl_ptr = dmix->appl_ptr - size;
|
||||
if (appl_ptr > pcm->boundary)
|
||||
appl_ptr += pcm->boundary;
|
||||
appl_ptr %= pcm->buffer_size;
|
||||
/* add sample areas here */
|
||||
src_areas = snd_pcm_mmap_areas(pcm);
|
||||
dst_areas = snd_pcm_mmap_areas(dmix->spcm);
|
||||
slave_appl_ptr = dmix->slave_appl_ptr % dmix->shmptr->s.buffer_size;
|
||||
dmix->slave_appl_ptr += size;
|
||||
dmix->slave_appl_ptr %= dmix->shmptr->s.boundary;
|
||||
dst_areas = snd_pcm_mmap_areas(pcm);
|
||||
src_areas = snd_pcm_mmap_areas(dsnoop->spcm);
|
||||
hw_ptr %= pcm->buffer_size;
|
||||
slave_hw_ptr %= dsnoop->shmptr->s.buffer_size;
|
||||
while (size > 0) {
|
||||
transfer = appl_ptr + size > pcm->buffer_size ? pcm->buffer_size - appl_ptr : size;
|
||||
transfer = slave_appl_ptr + transfer > dmix->shmptr->s.buffer_size ? dmix->shmptr->s.buffer_size - slave_appl_ptr : transfer;
|
||||
transfer = hw_ptr + size > pcm->buffer_size ? pcm->buffer_size - hw_ptr : size;
|
||||
transfer = slave_hw_ptr + transfer > dsnoop->shmptr->s.buffer_size ? dsnoop->shmptr->s.buffer_size - slave_hw_ptr : transfer;
|
||||
size -= transfer;
|
||||
snoop_areas(dmix, src_areas, dst_areas, appl_ptr, slave_appl_ptr, transfer);
|
||||
slave_appl_ptr += transfer;
|
||||
slave_appl_ptr %= dmix->shmptr->s.buffer_size;
|
||||
appl_ptr += transfer;
|
||||
appl_ptr %= pcm->buffer_size;
|
||||
snoop_areas(dsnoop, src_areas, dst_areas, slave_hw_ptr, hw_ptr, transfer);
|
||||
slave_hw_ptr += transfer;
|
||||
slave_hw_ptr %= dsnoop->shmptr->s.buffer_size;
|
||||
hw_ptr += transfer;
|
||||
hw_ptr %= pcm->buffer_size;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* synchronize hardware pointer (hw_ptr) with ours
|
||||
*/
|
||||
static int snd_pcm_dsnoop_sync_ptr(snd_pcm_t *pcm)
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_sync_ptr(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
snd_pcm_uframes_t slave_hw_ptr, old_slave_hw_ptr, avail;
|
||||
snd_pcm_sframes_t diff;
|
||||
|
||||
old_slave_hw_ptr = dmix->slave_hw_ptr;
|
||||
slave_hw_ptr = dmix->slave_hw_ptr = *dmix->spcm->hw.ptr;
|
||||
old_slave_hw_ptr = dsnoop->slave_hw_ptr;
|
||||
slave_hw_ptr = dsnoop->slave_hw_ptr = *dsnoop->spcm->hw.ptr;
|
||||
diff = slave_hw_ptr - old_slave_hw_ptr;
|
||||
if (diff == 0) /* fast path */
|
||||
return 0;
|
||||
if (diff < 0) {
|
||||
slave_hw_ptr += dmix->shmptr->s.boundary;
|
||||
slave_hw_ptr += dsnoop->shmptr->s.boundary;
|
||||
diff = slave_hw_ptr - old_slave_hw_ptr;
|
||||
}
|
||||
dmix->hw_ptr += diff;
|
||||
dmix->hw_ptr %= pcm->boundary;
|
||||
snd_pcm_dsnoop_sync_area(pcm, old_slave_hw_ptr, diff);
|
||||
dsnoop->hw_ptr += diff;
|
||||
dsnoop->hw_ptr %= pcm->boundary;
|
||||
// printf("sync ptr diff = %li\n", diff);
|
||||
if (pcm->stop_threshold >= pcm->boundary) /* don't care */
|
||||
return 0;
|
||||
if ((avail = snd_pcm_mmap_playback_avail(pcm)) >= pcm->stop_threshold) {
|
||||
if ((avail = snd_pcm_mmap_capture_hw_avail(pcm)) >= pcm->stop_threshold) {
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, 0);
|
||||
dmix->trigger_tstamp.tv_sec = tv.tv_sec;
|
||||
dmix->trigger_tstamp.tv_nsec = tv.tv_usec * 1000L;
|
||||
dmix->state = SND_PCM_STATE_XRUN;
|
||||
dmix->avail_max = avail;
|
||||
dsnoop->trigger_tstamp.tv_sec = tv.tv_sec;
|
||||
dsnoop->trigger_tstamp.tv_nsec = tv.tv_usec * 1000L;
|
||||
dsnoop->state = SND_PCM_STATE_XRUN;
|
||||
dsnoop->avail_max = avail;
|
||||
return -EPIPE;
|
||||
}
|
||||
if (avail > dmix->avail_max)
|
||||
dmix->avail_max = avail;
|
||||
return 0;
|
||||
if (avail > dsnoop->avail_max)
|
||||
dsnoop->avail_max = avail;
|
||||
return diff;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -145,13 +154,13 @@ static int snd_pcm_dsnoop_nonblock(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int nonblock
|
|||
|
||||
static int snd_pcm_dsnoop_async(snd_pcm_t *pcm, int sig, pid_t pid)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
return snd_timer_async(dmix->timer, sig, pid);
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
return snd_timer_async(dsnoop->timer, sig, pid);
|
||||
}
|
||||
|
||||
static int snd_pcm_dsnoop_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
unsigned short events;
|
||||
static snd_timer_read_t rbuf[5]; /* can be overwriten by multiple plugins, we don't need the value */
|
||||
|
||||
|
|
@ -161,7 +170,7 @@ static int snd_pcm_dsnoop_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsi
|
|||
events |= POLLOUT;
|
||||
events &= ~POLLIN;
|
||||
/* empty the timer read queue */
|
||||
while (snd_timer_read(dmix->timer, &rbuf, sizeof(rbuf)) == sizeof(rbuf)) ;
|
||||
while (snd_timer_read(dsnoop->timer, &rbuf, sizeof(rbuf)) == sizeof(rbuf)) ;
|
||||
}
|
||||
*revents = events;
|
||||
return 0;
|
||||
|
|
@ -169,7 +178,7 @@ static int snd_pcm_dsnoop_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsi
|
|||
|
||||
static int snd_pcm_dsnoop_info(snd_pcm_t *pcm, snd_pcm_info_t * info)
|
||||
{
|
||||
// snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
// snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
|
||||
memset(info, 0, sizeof(*info));
|
||||
info->stream = pcm->stream;
|
||||
|
|
@ -204,7 +213,7 @@ static int hw_param_interval_refine_one(snd_pcm_hw_params_t *params,
|
|||
return 0;
|
||||
i = hw_param_interval(params, var);
|
||||
if (snd_interval_empty(i)) {
|
||||
SNDERR("dmix interval %i empty?", (int)var);
|
||||
SNDERR("dsnoop interval %i empty?", (int)var);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (snd_interval_refine(i, hw_param_interval(src, var)))
|
||||
|
|
@ -216,8 +225,8 @@ static int hw_param_interval_refine_one(snd_pcm_hw_params_t *params,
|
|||
|
||||
static int snd_pcm_dsnoop_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_hw_params_t *hw_params = &dmix->shmptr->hw_params;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
snd_pcm_hw_params_t *hw_params = &dsnoop->shmptr->hw_params;
|
||||
static snd_mask_t access = { .bits = {
|
||||
(1<<SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) |
|
||||
(1<<SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED) |
|
||||
|
|
@ -234,7 +243,7 @@ static int snd_pcm_dsnoop_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
|
|||
#endif
|
||||
if (params->rmask & (1<<SND_PCM_HW_PARAM_ACCESS)) {
|
||||
if (snd_mask_empty(hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS))) {
|
||||
SNDERR("dmix access mask empty?");
|
||||
SNDERR("dsnoop access mask empty?");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (snd_mask_refine(hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS), &access))
|
||||
|
|
@ -242,7 +251,7 @@ static int snd_pcm_dsnoop_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
|
|||
}
|
||||
if (params->rmask & (1<<SND_PCM_HW_PARAM_FORMAT)) {
|
||||
if (snd_mask_empty(hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT))) {
|
||||
SNDERR("dmix format mask empty?");
|
||||
SNDERR("dsnoop format mask empty?");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (snd_mask_refine_set(hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT),
|
||||
|
|
@ -252,10 +261,10 @@ static int snd_pcm_dsnoop_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
|
|||
//snd_mask_none(hw_param_mask(params, SND_PCM_HW_PARAM_SUBFORMAT));
|
||||
if (params->rmask & (1<<SND_PCM_HW_PARAM_CHANNELS)) {
|
||||
if (snd_interval_empty(hw_param_interval(params, SND_PCM_HW_PARAM_CHANNELS))) {
|
||||
SNDERR("dmix channels mask empty?");
|
||||
SNDERR("dsnoop channels mask empty?");
|
||||
return -EINVAL;
|
||||
}
|
||||
err = snd_interval_refine_set(hw_param_interval(params, SND_PCM_HW_PARAM_CHANNELS), dmix->u.dmix.channels);
|
||||
err = snd_interval_refine_set(hw_param_interval(params, SND_PCM_HW_PARAM_CHANNELS), dsnoop->channels);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
|
|
@ -311,30 +320,30 @@ static int snd_pcm_dsnoop_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t *
|
|||
|
||||
static int snd_pcm_dsnoop_status(snd_pcm_t *pcm, snd_pcm_status_t * status)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
|
||||
memset(status, 0, sizeof(*status));
|
||||
status->state = dmix->state;
|
||||
status->trigger_tstamp = dmix->trigger_tstamp;
|
||||
status->tstamp = snd_pcm_hw_fast_tstamp(dmix->spcm);
|
||||
status->avail = snd_pcm_mmap_playback_avail(pcm);
|
||||
status->avail_max = status->avail > dmix->avail_max ? status->avail : dmix->avail_max;
|
||||
dmix->avail_max = 0;
|
||||
status->state = dsnoop->state;
|
||||
status->trigger_tstamp = dsnoop->trigger_tstamp;
|
||||
status->tstamp = snd_pcm_hw_fast_tstamp(dsnoop->spcm);
|
||||
status->avail = snd_pcm_mmap_capture_avail(pcm);
|
||||
status->avail_max = status->avail > dsnoop->avail_max ? status->avail : dsnoop->avail_max;
|
||||
dsnoop->avail_max = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static snd_pcm_state_t snd_pcm_dsnoop_state(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
return dmix->state;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
return dsnoop->state;
|
||||
}
|
||||
|
||||
static int snd_pcm_dsnoop_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
int err;
|
||||
|
||||
switch(dmix->state) {
|
||||
switch(dsnoop->state) {
|
||||
case SNDRV_PCM_STATE_DRAINING:
|
||||
case SNDRV_PCM_STATE_RUNNING:
|
||||
err = snd_pcm_dsnoop_sync_ptr(pcm);
|
||||
|
|
@ -342,7 +351,7 @@ static int snd_pcm_dsnoop_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
|
|||
return err;
|
||||
case SNDRV_PCM_STATE_PREPARED:
|
||||
case SNDRV_PCM_STATE_SUSPENDED:
|
||||
*delayp = snd_pcm_mmap_playback_hw_avail(pcm);
|
||||
*delayp = snd_pcm_mmap_capture_hw_avail(pcm);
|
||||
return 0;
|
||||
case SNDRV_PCM_STATE_XRUN:
|
||||
return -EPIPE;
|
||||
|
|
@ -353,9 +362,9 @@ static int snd_pcm_dsnoop_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
|
|||
|
||||
static int snd_pcm_dsnoop_hwsync(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
|
||||
switch(dmix->state) {
|
||||
switch(dsnoop->state) {
|
||||
case SNDRV_PCM_STATE_DRAINING:
|
||||
case SNDRV_PCM_STATE_RUNNING:
|
||||
return snd_pcm_dsnoop_sync_ptr(pcm);
|
||||
|
|
@ -371,73 +380,66 @@ static int snd_pcm_dsnoop_hwsync(snd_pcm_t *pcm)
|
|||
|
||||
static int snd_pcm_dsnoop_prepare(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
|
||||
snd_pcm_direct_check_interleave(dmix, pcm);
|
||||
// assert(pcm->boundary == dmix->shmptr->s.boundary); /* for sure */
|
||||
dmix->state = SND_PCM_STATE_PREPARED;
|
||||
dmix->appl_ptr = 0;
|
||||
dmix->hw_ptr = 0;
|
||||
snd_pcm_direct_check_interleave(dsnoop, pcm);
|
||||
// assert(pcm->boundary == dsnoop->shmptr->s.boundary); /* for sure */
|
||||
dsnoop->state = SND_PCM_STATE_PREPARED;
|
||||
dsnoop->appl_ptr = 0;
|
||||
dsnoop->hw_ptr = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_pcm_dsnoop_reset(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
dmix->hw_ptr %= pcm->period_size;
|
||||
dmix->appl_ptr = dmix->hw_ptr;
|
||||
dmix->slave_appl_ptr = dmix->slave_hw_ptr = *dmix->spcm->hw.ptr;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
dsnoop->hw_ptr %= pcm->period_size;
|
||||
dsnoop->appl_ptr = dsnoop->hw_ptr;
|
||||
dsnoop->slave_appl_ptr = dsnoop->slave_hw_ptr = *dsnoop->spcm->hw.ptr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_pcm_dsnoop_start(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_sframes_t avail;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
struct timeval tv;
|
||||
int err;
|
||||
|
||||
if (dmix->state != SND_PCM_STATE_PREPARED)
|
||||
if (dsnoop->state != SND_PCM_STATE_PREPARED)
|
||||
return -EBADFD;
|
||||
err = snd_timer_start(dmix->timer);
|
||||
err = snd_timer_start(dsnoop->timer);
|
||||
if (err < 0)
|
||||
return err;
|
||||
dmix->state = SND_PCM_STATE_RUNNING;
|
||||
dmix->slave_appl_ptr = dmix->slave_hw_ptr = *dmix->spcm->hw.ptr;
|
||||
avail = snd_pcm_mmap_playback_hw_avail(pcm);
|
||||
if (avail < 0)
|
||||
return 0;
|
||||
if (avail > (snd_pcm_sframes_t)pcm->buffer_size)
|
||||
avail = pcm->buffer_size;
|
||||
snd_pcm_dsnoop_sync_area(pcm, avail);
|
||||
dsnoop->state = SND_PCM_STATE_RUNNING;
|
||||
dsnoop->slave_appl_ptr = dsnoop->slave_hw_ptr = *dsnoop->spcm->hw.ptr;
|
||||
gettimeofday(&tv, 0);
|
||||
dmix->trigger_tstamp.tv_sec = tv.tv_sec;
|
||||
dmix->trigger_tstamp.tv_nsec = tv.tv_usec * 1000L;
|
||||
dsnoop->trigger_tstamp.tv_sec = tv.tv_sec;
|
||||
dsnoop->trigger_tstamp.tv_nsec = tv.tv_usec * 1000L;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_pcm_dsnoop_drop(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
if (dmix->state == SND_PCM_STATE_OPEN)
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
if (dsnoop->state == SND_PCM_STATE_OPEN)
|
||||
return -EBADFD;
|
||||
snd_timer_stop(dmix->timer);
|
||||
dmix->state = SND_PCM_STATE_SETUP;
|
||||
snd_timer_stop(dsnoop->timer);
|
||||
dsnoop->state = SND_PCM_STATE_SETUP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_pcm_dsnoop_drain(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
snd_pcm_uframes_t stop_threshold;
|
||||
int err;
|
||||
|
||||
if (dmix->state == SND_PCM_STATE_OPEN)
|
||||
if (dsnoop->state == SND_PCM_STATE_OPEN)
|
||||
return -EBADFD;
|
||||
stop_threshold = pcm->stop_threshold;
|
||||
if (pcm->stop_threshold > pcm->buffer_size)
|
||||
pcm->stop_threshold = pcm->buffer_size;
|
||||
while (dmix->state == SND_PCM_STATE_RUNNING) {
|
||||
while (dsnoop->state == SND_PCM_STATE_RUNNING) {
|
||||
err = snd_pcm_dsnoop_sync_ptr(pcm);
|
||||
if (err < 0)
|
||||
break;
|
||||
|
|
@ -451,24 +453,23 @@ static int snd_pcm_dsnoop_drain(snd_pcm_t *pcm)
|
|||
|
||||
static int snd_pcm_dsnoop_pause(snd_pcm_t *pcm, int enable)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
if (enable) {
|
||||
if (dmix->state != SND_PCM_STATE_RUNNING)
|
||||
if (dsnoop->state != SND_PCM_STATE_RUNNING)
|
||||
return -EBADFD;
|
||||
dmix->state = SND_PCM_STATE_PAUSED;
|
||||
snd_timer_stop(dmix->timer);
|
||||
dsnoop->state = SND_PCM_STATE_PAUSED;
|
||||
snd_timer_stop(dsnoop->timer);
|
||||
} else {
|
||||
if (dmix->state != SND_PCM_STATE_PAUSED)
|
||||
if (dsnoop->state != SND_PCM_STATE_PAUSED)
|
||||
return -EBADFD;
|
||||
dmix->state = SND_PCM_STATE_RUNNING;
|
||||
snd_timer_start(dmix->timer);
|
||||
dsnoop->state = SND_PCM_STATE_RUNNING;
|
||||
snd_timer_start(dsnoop->timer);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
|
||||
{
|
||||
/* FIXME: substract samples from the mix ring buffer, too? */
|
||||
snd_pcm_mmap_appl_backward(pcm, frames);
|
||||
return frames;
|
||||
}
|
||||
|
|
@ -477,7 +478,7 @@ static snd_pcm_sframes_t snd_pcm_dsnoop_forward(snd_pcm_t *pcm, snd_pcm_uframes_
|
|||
{
|
||||
snd_pcm_sframes_t avail;
|
||||
|
||||
avail = snd_pcm_mmap_avail(pcm);
|
||||
avail = snd_pcm_mmap_capture_hw_avail(pcm);
|
||||
if (avail < 0)
|
||||
return 0;
|
||||
if (frames > (snd_pcm_uframes_t)avail)
|
||||
|
|
@ -488,17 +489,17 @@ static snd_pcm_sframes_t snd_pcm_dsnoop_forward(snd_pcm_t *pcm, snd_pcm_uframes_
|
|||
|
||||
static int snd_pcm_dsnoop_resume(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
||||
{
|
||||
// snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
// snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
// FIXME
|
||||
return 0;
|
||||
}
|
||||
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_readi(snd_pcm_t *pcm ATTRIBUTE_UNUSED, void *buffer ATTRIBUTE_UNUSED, snd_pcm_uframes_t size ATTRIBUTE_UNUSED)
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_writei(snd_pcm_t *pcm ATTRIBUTE_UNUSED, const void *buffer ATTRIBUTE_UNUSED, snd_pcm_uframes_t size ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_readn(snd_pcm_t *pcm ATTRIBUTE_UNUSED, void **bufs ATTRIBUTE_UNUSED, snd_pcm_uframes_t size ATTRIBUTE_UNUSED)
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_writen(snd_pcm_t *pcm ATTRIBUTE_UNUSED, void **bufs ATTRIBUTE_UNUSED, snd_pcm_uframes_t size ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
|
@ -515,72 +516,69 @@ static int snd_pcm_dsnoop_munmap(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
|||
|
||||
static int snd_pcm_dsnoop_close(snd_pcm_t *pcm)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
|
||||
if (dmix->timer)
|
||||
snd_timer_close(dmix->timer);
|
||||
snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT);
|
||||
snd_pcm_close(dmix->spcm);
|
||||
if (dmix->server)
|
||||
snd_pcm_direct_server_discard(dmix);
|
||||
if (dmix->client)
|
||||
snd_pcm_direct_client_discard(dmix);
|
||||
if (snd_pcm_direct_shm_discard(dmix) > 0) {
|
||||
if (snd_pcm_direct_semaphore_discard(dmix) < 0)
|
||||
snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);
|
||||
if (dsnoop->timer)
|
||||
snd_timer_close(dsnoop->timer);
|
||||
snd_pcm_direct_semaphore_down(dsnoop, DIRECT_IPC_SEM_CLIENT);
|
||||
snd_pcm_close(dsnoop->spcm);
|
||||
if (dsnoop->server)
|
||||
snd_pcm_direct_server_discard(dsnoop);
|
||||
if (dsnoop->client)
|
||||
snd_pcm_direct_client_discard(dsnoop);
|
||||
if (snd_pcm_direct_shm_discard(dsnoop) > 0) {
|
||||
if (snd_pcm_direct_semaphore_discard(dsnoop) < 0)
|
||||
snd_pcm_direct_semaphore_up(dsnoop, DIRECT_IPC_SEM_CLIENT);
|
||||
} else {
|
||||
snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);
|
||||
snd_pcm_direct_semaphore_up(dsnoop, DIRECT_IPC_SEM_CLIENT);
|
||||
}
|
||||
if (dmix->u.dmix.bindings)
|
||||
free(dmix->u.dmix.bindings);
|
||||
if (dsnoop->bindings)
|
||||
free(dsnoop->bindings);
|
||||
pcm->private_data = NULL;
|
||||
free(dmix);
|
||||
free(dsnoop);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_mmap_commit(snd_pcm_t *pcm,
|
||||
snd_pcm_uframes_t offset ATTRIBUTE_UNUSED,
|
||||
snd_pcm_uframes_t size)
|
||||
snd_pcm_uframes_t offset ATTRIBUTE_UNUSED,
|
||||
snd_pcm_uframes_t size)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
int err;
|
||||
|
||||
snd_pcm_mmap_appl_forward(pcm, size);
|
||||
if (dmix->state == SND_PCM_STATE_RUNNING) {
|
||||
if (dsnoop->state == SND_PCM_STATE_RUNNING) {
|
||||
err = snd_pcm_dsnoop_sync_ptr(pcm);
|
||||
if (err < 0)
|
||||
return err;
|
||||
/* ok, we commit the changes after the validation of area */
|
||||
/* it's intended, although the result might be crappy */
|
||||
snd_pcm_dsnoop_sync_area(pcm, size);
|
||||
}
|
||||
snd_pcm_mmap_appl_forward(pcm, size);
|
||||
return size;
|
||||
}
|
||||
|
||||
static snd_pcm_sframes_t snd_pcm_dsnoop_avail_update(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
int err;
|
||||
|
||||
if (dmix->state == SND_PCM_STATE_RUNNING) {
|
||||
if (dsnoop->state == SND_PCM_STATE_RUNNING) {
|
||||
err = snd_pcm_dsnoop_sync_ptr(pcm);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
return snd_pcm_mmap_playback_avail(pcm);
|
||||
return snd_pcm_mmap_capture_avail(pcm);
|
||||
}
|
||||
|
||||
static void snd_pcm_dsnoop_dump(snd_pcm_t *pcm, snd_output_t *out)
|
||||
{
|
||||
snd_pcm_direct_t *dmix = pcm->private_data;
|
||||
snd_pcm_direct_t *dsnoop = pcm->private_data;
|
||||
|
||||
snd_output_printf(out, "Direct Stream Mixing PCM\n");
|
||||
if (pcm->setup) {
|
||||
snd_output_printf(out, "\nIts setup is:\n");
|
||||
snd_pcm_dump_setup(pcm, out);
|
||||
}
|
||||
if (dmix->spcm)
|
||||
snd_pcm_dump(dmix->spcm, out);
|
||||
if (dsnoop->spcm)
|
||||
snd_pcm_dump(dsnoop->spcm, out);
|
||||
}
|
||||
|
||||
static snd_pcm_ops_t snd_pcm_dsnoop_ops = {
|
||||
|
|
@ -613,84 +611,16 @@ static snd_pcm_fast_ops_t snd_pcm_dsnoop_fast_ops = {
|
|||
rewind: snd_pcm_dsnoop_rewind,
|
||||
forward: snd_pcm_dsnoop_forward,
|
||||
resume: snd_pcm_dsnoop_resume,
|
||||
writei: snd_pcm_mmap_writei,
|
||||
writen: snd_pcm_mmap_writen,
|
||||
readi: snd_pcm_dsnoop_readi,
|
||||
readn: snd_pcm_dsnoop_readn,
|
||||
writei: snd_pcm_dsnoop_writei,
|
||||
writen: snd_pcm_dsnoop_writen,
|
||||
readi: snd_pcm_mmap_readi,
|
||||
readn: snd_pcm_mmap_readn,
|
||||
avail_update: snd_pcm_dsnoop_avail_update,
|
||||
mmap_commit: snd_pcm_dsnoop_mmap_commit,
|
||||
};
|
||||
|
||||
/*
|
||||
* parse the channel map
|
||||
* id == client channel
|
||||
* value == slave's channel
|
||||
*/
|
||||
static int parse_bindings(snd_pcm_direct_t *dmix, snd_config_t *cfg)
|
||||
{
|
||||
snd_config_iterator_t i, next;
|
||||
unsigned int chn, chn1, count = 0;
|
||||
int err;
|
||||
|
||||
dmix->u.dmix.channels = UINT_MAX;
|
||||
if (cfg == NULL)
|
||||
return 0;
|
||||
if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND) {
|
||||
SNDERR("invalid type for bindings");
|
||||
return -EINVAL;
|
||||
}
|
||||
snd_config_for_each(i, next, cfg) {
|
||||
snd_config_t *n = snd_config_iterator_entry(i);
|
||||
const char *id;
|
||||
long cchannel;
|
||||
if (snd_config_get_id(n, &id) < 0)
|
||||
continue;
|
||||
err = safe_strtol(id, &cchannel);
|
||||
if (err < 0 || cchannel < 0) {
|
||||
SNDERR("invalid client channel in binding: %s\n", id);
|
||||
return -EINVAL;
|
||||
}
|
||||
if ((unsigned)cchannel > count)
|
||||
count = cchannel + 1;
|
||||
}
|
||||
if (count == 0)
|
||||
return 0;
|
||||
if (count > 1024) {
|
||||
SNDERR("client channel out of range");
|
||||
return -EINVAL;
|
||||
}
|
||||
dmix->u.dmix.bindings = malloc(count * sizeof(unsigned int));
|
||||
for (chn = 0; chn < count; chn++)
|
||||
dmix->u.dmix.bindings[chn] = UINT_MAX; /* don't route */
|
||||
snd_config_for_each(i, next, cfg) {
|
||||
snd_config_t *n = snd_config_iterator_entry(i);
|
||||
const char *id;
|
||||
long cchannel, schannel;
|
||||
if (snd_config_get_id(n, &id) < 0)
|
||||
continue;
|
||||
safe_strtol(id, &cchannel);
|
||||
if (snd_config_get_integer(n, &schannel) < 0) {
|
||||
SNDERR("unable to get slave channel (should be integer type) in binding: %s\n", id);
|
||||
return -EINVAL;
|
||||
}
|
||||
dmix->u.dmix.bindings[cchannel] = schannel;
|
||||
}
|
||||
for (chn = 0; chn < count; chn++) {
|
||||
for (chn1 = 0; chn1 < count; chn1++) {
|
||||
if (chn == chn1)
|
||||
continue;
|
||||
if (dmix->u.dmix.bindings[chn] == dmix->u.dmix.bindings[chn1]) {
|
||||
SNDERR("unable to route channels %d,%d to same destination %d", chn, chn1, dmix->u.dmix.bindings[chn]);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
dmix->u.dmix.channels = count;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Creates a new dmix PCM
|
||||
* \brief Creates a new dsnoop PCM
|
||||
* \param pcmp Returns created PCM handle
|
||||
* \param name Name of PCM
|
||||
* \param ipc_key IPC key for semaphore and shared memory
|
||||
|
|
@ -711,47 +641,47 @@ int snd_pcm_dsnoop_open(snd_pcm_t **pcmp, const char *name,
|
|||
snd_pcm_stream_t stream, int mode)
|
||||
{
|
||||
snd_pcm_t *pcm = NULL, *spcm = NULL;
|
||||
snd_pcm_direct_t *dmix = NULL;
|
||||
snd_pcm_direct_t *dsnoop = NULL;
|
||||
int ret, first_instance;
|
||||
|
||||
assert(pcmp);
|
||||
|
||||
if (stream != SND_PCM_STREAM_PLAYBACK) {
|
||||
SNDERR("The dmix plugin supports only playback stream");
|
||||
if (stream != SND_PCM_STREAM_CAPTURE) {
|
||||
SNDERR("The dsnoop plugin supports only capture stream");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dmix = calloc(1, sizeof(snd_pcm_direct_t));
|
||||
if (!dmix) {
|
||||
dsnoop = calloc(1, sizeof(snd_pcm_direct_t));
|
||||
if (!dsnoop) {
|
||||
ret = -ENOMEM;
|
||||
goto _err;
|
||||
}
|
||||
|
||||
ret = parse_bindings(dmix, bindings);
|
||||
ret = snd_pcm_direct_parse_bindings(dsnoop, bindings);
|
||||
if (ret < 0)
|
||||
goto _err;
|
||||
|
||||
dmix->ipc_key = ipc_key;
|
||||
dmix->semid = -1;
|
||||
dmix->shmid = -1;
|
||||
dsnoop->ipc_key = ipc_key;
|
||||
dsnoop->semid = -1;
|
||||
dsnoop->shmid = -1;
|
||||
|
||||
ret = snd_pcm_new(&pcm, SND_PCM_TYPE_DSNOOP, name, stream, mode);
|
||||
ret = snd_pcm_new(&pcm, dsnoop->type = SND_PCM_TYPE_DSNOOP, name, stream, mode);
|
||||
if (ret < 0)
|
||||
goto _err;
|
||||
|
||||
ret = snd_pcm_direct_semaphore_create_or_connect(dmix);
|
||||
ret = snd_pcm_direct_semaphore_create_or_connect(dsnoop);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to create IPC semaphore");
|
||||
goto _err;
|
||||
}
|
||||
|
||||
ret = snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT);
|
||||
ret = snd_pcm_direct_semaphore_down(dsnoop, DIRECT_IPC_SEM_CLIENT);
|
||||
if (ret < 0) {
|
||||
snd_pcm_direct_semaphore_discard(dmix);
|
||||
snd_pcm_direct_semaphore_discard(dsnoop);
|
||||
goto _err;
|
||||
}
|
||||
|
||||
first_instance = ret = snd_pcm_direct_shm_create_or_connect(dmix);
|
||||
first_instance = ret = snd_pcm_direct_shm_create_or_connect(dsnoop);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to create IPC shm instance");
|
||||
goto _err;
|
||||
|
|
@ -759,8 +689,8 @@ int snd_pcm_dsnoop_open(snd_pcm_t **pcmp, const char *name,
|
|||
|
||||
pcm->ops = &snd_pcm_dsnoop_ops;
|
||||
pcm->fast_ops = &snd_pcm_dsnoop_fast_ops;
|
||||
pcm->private_data = dmix;
|
||||
dmix->state = SND_PCM_STATE_OPEN;
|
||||
pcm->private_data = dsnoop;
|
||||
dsnoop->state = SND_PCM_STATE_OPEN;
|
||||
|
||||
if (first_instance) {
|
||||
ret = snd_pcm_open_slave(&spcm, root, sconf, stream, mode);
|
||||
|
|
@ -770,33 +700,33 @@ int snd_pcm_dsnoop_open(snd_pcm_t **pcmp, const char *name,
|
|||
}
|
||||
|
||||
if (snd_pcm_type(spcm) != SND_PCM_TYPE_HW) {
|
||||
SNDERR("dmix plugin can be only connected to hw plugin");
|
||||
SNDERR("dsnoop plugin can be only connected to hw plugin");
|
||||
goto _err;
|
||||
}
|
||||
|
||||
ret = snd_pcm_direct_initialize_slave(dmix, spcm, params);
|
||||
ret = snd_pcm_direct_initialize_slave(dsnoop, spcm, params);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to initialize slave");
|
||||
goto _err;
|
||||
}
|
||||
|
||||
dmix->spcm = spcm;
|
||||
dsnoop->spcm = spcm;
|
||||
|
||||
ret = snd_pcm_direct_server_create(dmix);
|
||||
ret = snd_pcm_direct_server_create(dsnoop);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to create server");
|
||||
goto _err;
|
||||
}
|
||||
|
||||
dmix->shmptr->type = spcm->type;
|
||||
dsnoop->shmptr->type = spcm->type;
|
||||
} else {
|
||||
ret = snd_pcm_direct_client_connect(dmix);
|
||||
ret = snd_pcm_direct_client_connect(dsnoop);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to connect client");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = snd_pcm_hw_open_fd(&spcm, "dmix_client", dmix->hw_fd, 0);
|
||||
ret = snd_pcm_hw_open_fd(&spcm, "dsnoop_client", dsnoop->hw_fd, 0);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to open hardware");
|
||||
goto _err;
|
||||
|
|
@ -804,61 +734,61 @@ int snd_pcm_dsnoop_open(snd_pcm_t **pcmp, const char *name,
|
|||
|
||||
spcm->donot_close = 1;
|
||||
spcm->setup = 1;
|
||||
spcm->buffer_size = dmix->shmptr->s.buffer_size;
|
||||
spcm->sample_bits = dmix->shmptr->s.sample_bits;
|
||||
spcm->channels = dmix->shmptr->s.channels;
|
||||
spcm->format = dmix->shmptr->s.format;
|
||||
spcm->boundary = dmix->shmptr->s.boundary;
|
||||
spcm->buffer_size = dsnoop->shmptr->s.buffer_size;
|
||||
spcm->sample_bits = dsnoop->shmptr->s.sample_bits;
|
||||
spcm->channels = dsnoop->shmptr->s.channels;
|
||||
spcm->format = dsnoop->shmptr->s.format;
|
||||
spcm->boundary = dsnoop->shmptr->s.boundary;
|
||||
ret = snd_pcm_mmap(spcm);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to mmap channels");
|
||||
goto _err;
|
||||
}
|
||||
dmix->spcm = spcm;
|
||||
dsnoop->spcm = spcm;
|
||||
}
|
||||
|
||||
ret = snd_pcm_direct_initialize_poll_fd(dmix);
|
||||
ret = snd_pcm_direct_initialize_poll_fd(dsnoop);
|
||||
if (ret < 0) {
|
||||
SNDERR("unable to initialize poll_fd");
|
||||
goto _err;
|
||||
}
|
||||
|
||||
pcm->poll_fd = dmix->poll_fd;
|
||||
pcm->poll_fd = dsnoop->poll_fd;
|
||||
pcm->poll_events = POLLIN; /* it's different than other plugins */
|
||||
|
||||
pcm->mmap_rw = 1;
|
||||
snd_pcm_set_hw_ptr(pcm, &dmix->hw_ptr, -1, 0);
|
||||
snd_pcm_set_appl_ptr(pcm, &dmix->appl_ptr, -1, 0);
|
||||
snd_pcm_set_hw_ptr(pcm, &dsnoop->hw_ptr, -1, 0);
|
||||
snd_pcm_set_appl_ptr(pcm, &dsnoop->appl_ptr, -1, 0);
|
||||
|
||||
if (dmix->u.dmix.channels == UINT_MAX)
|
||||
dmix->u.dmix.channels = dmix->shmptr->s.channels;
|
||||
if (dsnoop->channels == UINT_MAX)
|
||||
dsnoop->channels = dsnoop->shmptr->s.channels;
|
||||
|
||||
snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);
|
||||
snd_pcm_direct_semaphore_up(dsnoop, DIRECT_IPC_SEM_CLIENT);
|
||||
|
||||
*pcmp = pcm;
|
||||
return 0;
|
||||
|
||||
_err:
|
||||
if (dmix) {
|
||||
if (dmix->timer)
|
||||
snd_timer_close(dmix->timer);
|
||||
if (dmix->server)
|
||||
snd_pcm_direct_server_discard(dmix);
|
||||
if (dmix->client)
|
||||
snd_pcm_direct_client_discard(dmix);
|
||||
if (dsnoop) {
|
||||
if (dsnoop->timer)
|
||||
snd_timer_close(dsnoop->timer);
|
||||
if (dsnoop->server)
|
||||
snd_pcm_direct_server_discard(dsnoop);
|
||||
if (dsnoop->client)
|
||||
snd_pcm_direct_client_discard(dsnoop);
|
||||
if (spcm)
|
||||
snd_pcm_close(spcm);
|
||||
if (dmix->shmid >= 0) {
|
||||
if (snd_pcm_direct_shm_discard(dmix) > 0) {
|
||||
if (dmix->semid >= 0) {
|
||||
if (snd_pcm_direct_semaphore_discard(dmix) < 0)
|
||||
snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT);
|
||||
if (dsnoop->shmid >= 0) {
|
||||
if (snd_pcm_direct_shm_discard(dsnoop) > 0) {
|
||||
if (dsnoop->semid >= 0) {
|
||||
if (snd_pcm_direct_semaphore_discard(dsnoop) < 0)
|
||||
snd_pcm_direct_semaphore_up(dsnoop, DIRECT_IPC_SEM_CLIENT);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (dmix->u.dmix.bindings)
|
||||
free(dmix->u.dmix.bindings);
|
||||
free(dmix);
|
||||
if (dsnoop->bindings)
|
||||
free(dsnoop->bindings);
|
||||
free(dsnoop);
|
||||
}
|
||||
if (pcm)
|
||||
snd_pcm_free(pcm);
|
||||
|
|
@ -909,11 +839,11 @@ pcm.name {
|
|||
*/
|
||||
|
||||
/**
|
||||
* \brief Creates a new dmix PCM
|
||||
* \brief Creates a new dsnoop PCM
|
||||
* \param pcmp Returns created PCM handle
|
||||
* \param name Name of PCM
|
||||
* \param root Root configuration node
|
||||
* \param conf Configuration node with dmix PCM description
|
||||
* \param conf Configuration node with dsnoop PCM description
|
||||
* \param stream PCM Stream
|
||||
* \param mode PCM Mode
|
||||
* \warning Using of this function might be dangerous in the sense
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue