[pulseaudio-discuss] R: New equalizer module (module-eqpro-sink), some questions

[Georg Chini]

On 27.04.19 17:14, Georg Chini wrote:
> On 27.04.19 12:55, Georg Chini wrote:
>> On 27.04.19 12:04, Tanu Kaskinen wrote:
>>> On Fri, 2019-04-26 at 11:40 +0200, Georg Chini wrote:
>>>> On 26.04.19 10:56, Tanu Kaskinen wrote:
>>>>> On Tue, 2019-04-23 at 21:20 +0200, Georg Chini wrote:
>>>>>> The current scheme for
>>>>>> updating
>>>>>> parameters I have in mind should work for any of the existing 
>>>>>> filters
>>>>>> and relies on
>>>>>> passing around parameter structures:
>>>>>>
>>>>>>
Based on my implementation, the interface to a PA external plugin could 
look like this:


     unsigned input_channels;                 /* Number of audio input 
channels, 0 if variable */
     unsigned output_channels;                /* Number of audio output 
channels, 0 if variable */

     const char *desc_head;                    /* Leading part of 
description string */
     const char *filter_type;                  /* Name for the type of 
filter */

     size_t max_chunk_size;                    /* Maximum chunk size in 
bytes that the filter will
                                                * accept, 0 for default */
     size_t fixed_block_size;                  /* Block size in frames 
for fixed block size filters,
                                                * 0 if block size is 
variable */
     uint64_t min_latency;                     /* Minimum latency 
allowed for the sink, 0 if unused */
     uint64_t max_latency;                     /* Maximum latency 
allowed for the sink, 0 if unused */
     bool disable_rewind;                      /* True when rewinding is 
disabled */

     /* Callback to reset the filter after rewind. May be NULL */
     void (*rewind_filter)(void *filter_handle, size_t amount);

     /* Callback to process a chunk of data by the filter. May be NULL */
     void (*process_chunk)(float *src, float *dst, unsigned count, void 
*filter_handle);

     /* Callback to retrieve additional latency caused by the filter. 
May be NULL */
     uint64_t (*get_extra_latency)(void *filter_handle);

     /* Initializes a new filter instance and returns a handle to it. */
     void *(*init_filter)(unsigned input_channels, unsigned 
output_channels, unsigned sample_rate);

     /* Deletes filter instance. */
     void (*exit_filter)(void *filter_handle);

     /* If set, this function is called in thread context when an update 
of the
      * filter parameters is requested, may be NULL. The function must 
replace
      * the currently used parameter structure by the new structure and 
return
      * a pointer to the old structure so that it can be freed in the 
main thread
      * using parameter_free(). If the old structure can be re-used, the 
function
      * may return NULL. */
     void *(*update_filter_parameters)(void *parameters, void 
*filter_handle);

     /* Frees a parameter structure. May only be NULL, if 
update_filter_parameters()
      * is also NULL or if update_filter_parameters() always returns 
NULL. */
     void (*parameter_free)(void *parameters);

     /* The following functions can be provided to set and get 
parameters. The parameter
      * structure is defined by the filter and should contain all 
parameters that are
      * configurable by the user. The library code makes no assumption 
on the contents
      * of the structure but only passes references. The library 
implements a message
      * handler which supports the following messages that use the 
functions below:
      * parameter-get - Retrieve a single parameter.
      * parameter-set - Set a single parameter.
      * parameter-get-all - Retrieve all parameters as a list in message 
format.
      * parameter-set-all - Set all parameters simultaneously.
      * parameter-get-description - Returns a filter description and a 
list that describes
      *                             all parameters. Example of the list 
element format:
      * {{Identifier}{Type}{default}{min}{max}}
      * The last message can be used to get information about the filter 
or to implement
      * a filter control GUI that is independent of the filter type.
      * If filter_message_handler() is defined, all other messages are 
passed on to the
      * filter. The get functions are expected to return a string in the 
message handler
      * format while the set functions receive plain strings. On 
failure, all get/set
      * functions will return NULL. */

     /* Get the value of the parameter described by identifier. The 
value shall be returned
      * as a string enclosed in double curly braces. The identifier may 
be any string that
      * the filter recognizes like a name or index, depending of the 
implementation of this
      * function. */
     char *(*parameter_get)(const char *identifier, void *filter_handle);

     /* Sets the value of the parameter described by identifier. The 
value is expected as
      * a string. The identifier may be any string that the filter 
recognizes like a name
      * or index. Returns a parameter structure filled with all current 
parameter values,
      * reflecting the updated parameter, so that the structure can be 
passed to
      * update_filter_parameters(). update_filter_parameters() will 
replace the current
      * parameter set with the new structure. */
     void *(*parameter_set)(const char *identifier, const char *value, 
void *filter_handle);

     /* Returns a list of the values of all filter parameters. Each 
parameter must be enclosed
      * in curly braces and there must be braces around the whole list. */
     char *(*parameter_get_all)(void *filter_handle);

     /* Expects an array of all filter parameter values as strings and 
returns a parameter
      * structure that can be passed to update_filter_parameters(). See 
set_parameter(). */
     void *(*parameter_set_all)(const char **all_params, int 
param_count, void *filter_handle);

     /* Returns a parameter description string as described above. */
     char *(*parameter_get_description)(void *filter_handle);

     /* Handler for additional messages. */
     int (*filter_message_handler)(const char *message, char 
*message_parameters, char **response, void *filter_handle);


Does this look OK? Any suggestions?