IpatchSampleTransform

typedef struct {
  guint16 src_format;		/* source sample format */
  guint16 dest_format;		/* destination sample format */
  guint8 channel_map[8];        /* channel mapping for multi-channel audio */
  guint8 buf1_max_frame; /* max bytes per frame for buf1 */
  guint8 buf2_max_frame; /* max bytes per frame for buf2 */
  guint8 func_count;		/* number of functions in funcs array */
  guint8 free_buffers;		/* set to TRUE if buffers need to be freed */
  guint max_frames;		/* max frames that can be converted in batch */
  guint frames;			/* number of frames to transform */
  guint samples; /* # of samples for current transform func (not frames!)*/
  gpointer buf1;		/* buffer 1 (first input) */
  gpointer buf2;		/* buffer 2 */
  guint combined_size; /* size in bytes of both buffers (if combined) */
  gpointer reserved1;           /* Reserved field */
  gpointer reserved2;           /* Reserved field */

  /* array of transform funcs */
  IpatchSampleTransformFunc funcs[IPATCH_SAMPLE_MAX_TRANSFORM_FUNCS];
} IpatchSampleTransform;

IpatchSampleTransformFunc ()

void                (*IpatchSampleTransformFunc)        (IpatchSampleTransform *transform);

Audio conversion handler prototype. Handler will modify samples of transform if number of samples changes (a change in the number of channels occurs).

ipatch_sample_transform_new ()

IpatchSampleTransform * ipatch_sample_transform_new     (int src_format,
                                                         int dest_format,
                                                         guint32 channel_map);

Create a new sample transform object. If src_format and dest_format are not 0 then the transform is initialized for the given source and destination formats, otherwise they are expected to be set later with ipatch_sample_transform_set_formats().

ipatch_sample_transform_free ()

void                ipatch_sample_transform_free        (IpatchSampleTransform *transform);

Free a transform structure as allocated by ipatch_sample_transform_new() and its allocated resources.

ipatch_sample_transform_init ()

void                ipatch_sample_transform_init        (IpatchSampleTransform *transform);

Initialize a sample transform structure. Usually only used to initialize transform structures allocated on the stack, which is done to avoid mallocs.

ipatch_sample_transform_pool_acquire ()

IpatchSampleTransform * ipatch_sample_transform_pool_acquire
                                                        (int src_format,
                                                         int dest_format,
                                                         guint32 channel_map);

Get an unused sample transform object from the sample transform pool. Used for quickly getting a transform object for temporary use without the overhead of allocating one. Note though, that if no more transforms exist in the pool an allocation will occur.

ipatch_sample_transform_pool_release ()

void                ipatch_sample_transform_pool_release
                                                        (IpatchSampleTransform *transform);

Release a sample transform object, returned by ipatch_sample_transform_pool_grab(), back to the transform pool.

ipatch_sample_transform_set_formats ()

void                ipatch_sample_transform_set_formats (IpatchSampleTransform *transform,
                                                         int src_format,
                                                         int dest_format,
                                                         guint32 channel_map);

Initialize a sample transform object for converting from src_format to dest_format.

ipatch_sample_transform_alloc ()

void                ipatch_sample_transform_alloc       (IpatchSampleTransform *transform,
                                                         guint frames);

Allocate buffers for transforming between two audio formats, for which transform has previously been initialized for with ipatch_sample_transform_new() or ipatch_sample_transform_set_formats().

Note: Assigning buffers with this function allows sample formats to be changed without re-assigning the buffers.

ipatch_sample_transform_alloc_size ()

int                 ipatch_sample_transform_alloc_size  (IpatchSampleTransform *transform,
                                                         guint size);

Like ipatch_sample_transform_alloc() but allocates buffers based on a maximum size and returns the maximum number of sample frames which can be converted at a time using this size. Another difference is that conversion formats do not need to be set before calling this function.

ipatch_sample_transform_free_buffers ()

void                ipatch_sample_transform_free_buffers
                                                        (IpatchSampleTransform *transform);

Free sample transform buffers.

ipatch_sample_transform_set_buffers_size ()

guint               ipatch_sample_transform_set_buffers_size
                                                        (IpatchSampleTransform *transform,
                                                         gpointer buf,
                                                         guint size);

Assign transform buffers using a single buffer of a specific size in bytes and determine optimal division for source and destination buffers. Conversion formats must not be set before calling this function (can be set later).

ipatch_sample_transform_get_buffers ()

void                ipatch_sample_transform_get_buffers (IpatchSampleTransform *transform,
                                                         gpointer *buf1,
                                                         gpointer *buf2);

Get the sample data buffers in a sample transform object.

ipatch_sample_transform_get_frame_sizes ()

void                ipatch_sample_transform_get_frame_sizes
                                                        (IpatchSampleTransform *transform,
                                                         guint *buf1_size,
                                                         guint *buf2_size);

Get max frame sizes for transform buffers. When transforming audio the first buffer must be at least frames * buf1_size bytes in size and the second buffer must be at least frames * buf2_size, where frames is the max number of frames to convert in batch.

ipatch_sample_transform_get_max_frames ()

guint               ipatch_sample_transform_get_max_frames
                                                        (IpatchSampleTransform *transform);

Get the maximum frames that the transform object can convert at a time.

ipatch_sample_transform_convert ()

gpointer            ipatch_sample_transform_convert     (IpatchSampleTransform *transform,
                                                         gconstpointer src,
                                                         gpointer dest,
                                                         guint frames);

Convert an arbitrary number of audio frames from user provided buffers, contrary to ipatch_sample_transform_convert_single() which uses internal buffers and converts a max of 1 buffer at a time. The sample formats should already be assigned and internal buffers assigned or allocated.

ipatch_sample_transform_convert_single ()

gpointer            ipatch_sample_transform_convert_single
                                                        (IpatchSampleTransform *transform,
                                                         guint frames);

Convert the format of a single buffer of audio. The transform object must have had its sample formats set and buffers assigned or allocated. Use ipatch_sample_transform_convert() to convert from one buffer to another regardless of the number of frames.