mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-17 07:00:03 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Split out header files

Browse source 
Use separate header files
Add pull-based alsasink
Add audiotestsrc
Implement negotiation and scheduling of audiotestsrc ! alsasink
This commit is contained in:
Wim Taymans 2016-06-03 19:05:19 +02:00
parent 03046301bf
commit 4b2520d173
15 changed files with 2869 additions and 287 deletions
Download patch file Download diff file Expand all files Collapse all files

157
pinos/tests/spi-volume.c
View file

@ -17,9 +17,12 @@
* Boston, MA 02110-1301, USA.
*/
#include <stdbool.h>
#include <string.h>
#include <spi/node.h>
#include "spi-plugins.h"
typedef struct _SpiVolume SpiVolume;
typedef struct {
@ -49,7 +52,7 @@ struct _SpiVolume {
SpiEvent last_event;
SpiEventCallback event_cb;
gpointer user_data;
void *user_data;
bool have_format;
SpiVolumeFormat current_format;
@ -61,19 +64,20 @@ struct _SpiVolume {
};
static const double default_volume = 1.0;
static const uint32_t min_volume = 0.0;
static const uint32_t max_volume = 10.0;
static const double min_volume = 0.0;
static const double max_volume = 10.0;
static const bool default_mute = false;
static const SpiParamRangeInfo volume_range[] = {
{ "min", "Minimum value", 4, &min_volume },
{ "max", "Maximum value", 4, &max_volume },
{ "min", "Minimum value", sizeof (double), &min_volume },
{ "max", "Maximum value", sizeof (double), &max_volume },
{ NULL, NULL, 0, NULL }
};
enum {
PARAM_ID_VOLUME,
PARAM_ID_MUTE,
PARAM_ID_LAST,
};
static const SpiParamInfo param_info[] =
@ -85,7 +89,7 @@ static const SpiParamInfo param_info[] =
SPI_PARAM_RANGE_TYPE_MIN_MAX, volume_range,
NULL,
NULL },
{ PARAM_ID_MUTE , "mute", "Mute",
{ PARAM_ID_MUTE, "mute", "Mute",
SPI_PARAM_FLAG_READWRITE,
SPI_PARAM_TYPE_BOOL, sizeof (bool),
sizeof (bool), &default_mute,
@ -95,22 +99,25 @@ static const SpiParamInfo param_info[] =
};
#define CHECK_TYPE(type,expected) if (type != expected) return SPI_RESULT_WRONG_PARAM_TYPE;
#define CHECK_UNSET(mask,idx) if (mask & (1 << idx)) return SPI_RESULT_PARAM_UNSET;
#define CHECK_SIZE(size,expected) if (size != expected) return SPI_RESULT_WRONG_PARAM_SIZE;
#define CHECK_SIZE_RANGE(size,minsize,maxsize) if (size > maxsize || size < minsize) return SPI_RESULT_WRONG_PARAM_SIZE;
#define CHECK_SIZE_MAX(size,maxsize) if (size > maxsize) return SPI_RESULT_WRONG_PARAM_SIZE;
#define CHECK_UNSET(mask,index) if (mask & (1 << index)) return SPI_RESULT_PARAM_UNSET;
static SpiResult
get_param_info (const SpiParams *params,
int idx,
const SpiParamInfo **info)
enum_param_info (const SpiParams *params,
unsigned int index,
const SpiParamInfo **info)
{
if (idx < 0 || idx >= 2)
return SPI_RESULT_NO_MORE_PARAM_INFO;
*info = &param_info[idx];
if (index >= PARAM_ID_LAST)
return SPI_RESULT_ENUM_END;
*info = &param_info[index];
return SPI_RESULT_OK;
}
static SpiResult
set_param (SpiParams *params,
int id,
uint32_t id,
SpiParamType type,
size_t size,
const void *value)
@ -118,14 +125,19 @@ set_param (SpiParams *params,
SpiResult res = SPI_RESULT_OK;
SpiVolumeParams *p = (SpiVolumeParams *) params;
if (params == NULL || value == NULL)
return SPI_RESULT_INVALID_ARGUMENTS;
switch (id) {
case 0:
case PARAM_ID_VOLUME:
CHECK_TYPE (type, SPI_PARAM_TYPE_DOUBLE);
memcpy (&p->volume, value, MIN (sizeof (double), size));
CHECK_SIZE (size, sizeof (double));
memcpy (&p->volume, value, size);
break;
case 1:
case PARAM_ID_MUTE:
CHECK_TYPE (type, SPI_PARAM_TYPE_BOOL);
memcpy (&p->mute, value, MIN (sizeof (bool), size));
CHECK_SIZE (size, sizeof (bool));
memcpy (&p->mute, value, size);
break;
default:
res = SPI_RESULT_INVALID_PARAM_ID;
@ -136,7 +148,7 @@ set_param (SpiParams *params,
static SpiResult
get_param (const SpiParams *params,
int id,
uint32_t id,
SpiParamType *type,
size_t *size,
const void **value)
@ -144,13 +156,16 @@ get_param (const SpiParams *params,
SpiResult res = SPI_RESULT_OK;
SpiVolumeParams *p = (SpiVolumeParams *) params;
if (params == NULL || type == NULL || size == NULL || value == NULL)
return SPI_RESULT_INVALID_ARGUMENTS;
switch (id) {
case 0:
case PARAM_ID_VOLUME:
*type = SPI_PARAM_TYPE_DOUBLE;
*value = &p->volume;
*size = sizeof (double);
break;
case 1:
case PARAM_ID_MUTE:
*type = SPI_PARAM_TYPE_BOOL;
*value = &p->mute;
*size = sizeof (bool);
@ -203,14 +218,14 @@ spi_volume_node_set_params (SpiNode *node,
}
if (params->get_param (params, 0, &type, &size, &value) == 0) {
if (type != SPI_PARAM_TYPE_DOUBLE)
return SPI_RESULT_WRONG_PARAM_TYPE;
memcpy (&p->volume, value, MIN (size, sizeof (double)));
CHECK_TYPE (type, SPI_PARAM_TYPE_DOUBLE);
CHECK_SIZE (size, sizeof (double));
memcpy (&p->volume, value, size);
}
if (params->get_param (params, 1, &type, &size, &value) == 0) {
if (type != SPI_PARAM_TYPE_BOOL)
return SPI_RESULT_WRONG_PARAM_TYPE;
memcpy (&p->mute, value, MIN (sizeof (bool), size));
CHECK_TYPE (type, SPI_PARAM_TYPE_BOOL);
CHECK_SIZE (size, sizeof (bool));
memcpy (&p->mute, value, size);
}
return SPI_RESULT_OK;
}
@ -432,22 +447,22 @@ static const SpiParamInfo raw_format_param_info[] =
};
static SpiResult
get_raw_format_param_info (const SpiParams *params,
int idx,
const SpiParamInfo **info)
enum_raw_format_param_info (const SpiParams *params,
unsigned int index,
const SpiParamInfo **info)
{
if (idx < 0 || idx >= 4)
return SPI_RESULT_NO_MORE_PARAM_INFO;
*info = &raw_format_param_info[idx];
if (index >= 4)
return SPI_RESULT_ENUM_END;
*info = &raw_format_param_info[index];
return SPI_RESULT_OK;
}
#define CHECK_TYPE(type,expected) if (type != expected) return SPI_RESULT_WRONG_PARAM_TYPE;
#define MARK_SET(mask,idx) (mask &= ~(1 << idx))
#define MARK_SET(mask,index) (mask &= ~(1 << index))
static SpiResult
set_format_param (SpiParams *params,
int id,
uint32_t id,
SpiParamType type,
size_t size,
const void *value)
@ -457,22 +472,26 @@ set_format_param (SpiParams *params,
switch (id) {
case SPI_PARAM_ID_FORMAT:
CHECK_TYPE (type, SPI_PARAM_TYPE_STRING);
memcpy (f->format, value, MIN (16, size));
CHECK_SIZE_MAX (size, 16);
memcpy (f->format, value, size);
MARK_SET (f->unset_mask, 1);
break;
case SPI_PARAM_ID_LAYOUT:
CHECK_TYPE (type, SPI_PARAM_TYPE_UINT32);
memcpy (&f->layout, value, MIN (4, size));
CHECK_SIZE (size, sizeof (uint32_t));
memcpy (&f->layout, value, size);
MARK_SET (f->unset_mask, 2);
break;
case SPI_PARAM_ID_SAMPLERATE:
CHECK_TYPE (type, SPI_PARAM_TYPE_UINT32);
memcpy (&f->samplerate, value, MIN (4, size));
CHECK_SIZE (size, sizeof (uint32_t));
memcpy (&f->samplerate, value, size);
MARK_SET (f->unset_mask, 3);
break;
case SPI_PARAM_ID_CHANNELS:
CHECK_TYPE (type, SPI_PARAM_TYPE_UINT32);
memcpy (&f->channels, value, MIN (4, size));
CHECK_SIZE (size, sizeof (uint32_t));
memcpy (&f->channels, value, size);
MARK_SET (f->unset_mask, 4);
break;
default:
@ -486,7 +505,7 @@ set_format_param (SpiParams *params,
static SpiResult
get_format_param (const SpiParams *params,
int id,
uint32_t id,
SpiParamType *type,
size_t *size,
const void **value)
@ -532,26 +551,26 @@ get_format_param (const SpiParams *params,
static SpiResult
spi_volume_node_get_port_formats (SpiNode *node,
uint32_t port_id,
unsigned int format_idx,
SpiParams **format)
spi_volume_node_enum_port_formats (SpiNode *node,
uint32_t port_id,
unsigned int index,
SpiParams **format)
{
static SpiVolumeFormat fmt;
if (port_id != 0)
return SPI_RESULT_INVALID_PORT;
switch (format_idx) {
switch (index) {
case 0:
strcpy (fmt.media_type, "audio/x-raw");
fmt.unset_mask = (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4);
fmt.param.get_param_info = get_raw_format_param_info;
fmt.param.enum_param_info = enum_raw_format_param_info;
fmt.param.set_param = set_format_param;
fmt.param.get_param = get_format_param;
break;
default:
return SPI_RESULT_NO_MORE_FORMATS;
return SPI_RESULT_ENUM_END;
}
*format = &fmt.param;
@ -583,43 +602,43 @@ spi_volume_node_set_port_format (SpiNode *node,
SPI_PARAM_ID_MEDIA_TYPE,
&type, &size, &value) < 0)
return SPI_RESULT_INVALID_MEDIA_TYPE;
if (type != SPI_PARAM_TYPE_STRING)
return SPI_RESULT_INVALID_MEDIA_TYPE;
memcpy (fmt->media_type, value, MIN (size, 32));
CHECK_TYPE (type, SPI_PARAM_TYPE_STRING);
CHECK_SIZE_MAX (size, 32);
memcpy (fmt->media_type, value, size);
if (format->get_param (format,
SPI_PARAM_ID_FORMAT,
&type, &size, &value) < 0)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
if (type != SPI_PARAM_TYPE_STRING)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
memcpy (fmt->format, value, MIN (size, 16));
CHECK_TYPE (type, SPI_PARAM_TYPE_STRING);
CHECK_SIZE_MAX (size, 16);
memcpy (fmt->format, value, size);
if (format->get_param (format,
SPI_PARAM_ID_LAYOUT,
&type, &size, &value) < 0)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
if (type != SPI_PARAM_TYPE_UINT32)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
memcpy (&fmt->layout, value, MIN (size, 4));
CHECK_TYPE (type, SPI_PARAM_TYPE_UINT32);
CHECK_SIZE (size, sizeof (uint32_t));
memcpy (&fmt->layout, value, size);
if (format->get_param (format,
SPI_PARAM_ID_SAMPLERATE,
&type, &size, &value) < 0)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
if (type != SPI_PARAM_TYPE_UINT32)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
memcpy (&fmt->samplerate, value, MIN (size, 4));
CHECK_TYPE (type, SPI_PARAM_TYPE_UINT32);
CHECK_SIZE (size, sizeof (uint32_t));
memcpy (&fmt->samplerate, value, size);
if (format->get_param (format,
SPI_PARAM_ID_CHANNELS,
&type, &size, &value) < 0)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
if (type != SPI_PARAM_TYPE_UINT32)
return SPI_RESULT_INVALID_FORMAT_PARAMS;
memcpy (&fmt->channels, value, MIN (size, 4));
CHECK_TYPE (type, SPI_PARAM_TYPE_UINT32);
CHECK_SIZE (size, sizeof (uint32_t));
memcpy (&fmt->channels, value, size);
fmt->param.get_param_info = get_raw_format_param_info;
fmt->param.enum_param_info = enum_raw_format_param_info;
fmt->param.set_param = NULL;
fmt->param.get_param = get_format_param;
this->have_format = true;
@ -749,6 +768,8 @@ spi_volume_node_send_port_data (SpiNode *node,
return SPI_RESULT_OK;
}
#define MIN(a,b) ((a) < (b) ? (a) : (b))
static SpiResult
spi_volume_node_receive_port_data (SpiNode *node,
unsigned int n_data,
@ -781,7 +802,7 @@ spi_volume_node_receive_port_data (SpiNode *node,
si = di = 0;
soff = doff = 0;
while (TRUE) {
while (true) {
if (si == sbuf->n_datas || di == dbuf->n_datas)
break;
@ -827,7 +848,7 @@ spi_volume_node_receive_port_data (SpiNode *node,
return SPI_RESULT_OK;
}
static SpiNode *
SpiNode *
spi_volume_new (void)
{
SpiNode *node;
@ -844,7 +865,7 @@ spi_volume_new (void)
node->get_port_ids = spi_volume_node_get_port_ids;
node->add_port = spi_volume_node_add_port;
node->remove_port = spi_volume_node_remove_port;
node->get_port_formats = spi_volume_node_get_port_formats;
node->enum_port_formats = spi_volume_node_enum_port_formats;
node->set_port_format = spi_volume_node_set_port_format;
node->get_port_format = spi_volume_node_get_port_format;
node->get_port_info = spi_volume_node_get_port_info;
@ -855,7 +876,7 @@ spi_volume_new (void)
node->receive_port_data = spi_volume_node_receive_port_data;
this = (SpiVolume *) node;
this->params.param.get_param_info = get_param_info;
this->params.param.enum_param_info = enum_param_info;
this->params.param.set_param = set_param;
this->params.param.get_param = get_param;
reset_volume_params (&this->params);