mixed.h

Go to the documentation of this file.

#ifndef __LIBMIXED_H__
#define __LIBMIXED_H__
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined MIXED_STATIC
#  define MIXED_EXPORT
#elif defined _MSC_VER
#  if defined MIXED_BUILD
#    define MIXED_EXPORT __declspec(dllexport)
#  else
#    define MIXED_EXPORT __declspec(dllimport)
#  endif
#elif defined __GNUC__
#  if defined MIXED_BUILD
#    define MIXED_EXPORT __attribute__((visibility("default")))
#  else
#    define MIXED_EXPORT
#  endif
#else
#  define MIXED_EXPORT
#endif
#include <stdint.h>
#include <stdlib.h>
#include <math.h>
#include "mixed_encoding.h"
 
 
 
 
 
  MIXED_EXPORT enum mixed_error{
    MIXED_NO_ERROR = 0,
    MIXED_OUT_OF_MEMORY,
    MIXED_UNKNOWN_ENCODING,
    MIXED_MIXING_FAILED,
    MIXED_NOT_IMPLEMENTED,
    MIXED_NOT_INITIALIZED,
    MIXED_INVALID_LOCATION,
    MIXED_INVALID_FIELD,
    MIXED_INVALID_VALUE,
    MIXED_SEGMENT_ALREADY_STARTED,
    MIXED_SEGMENT_ALREADY_ENDED,
    MIXED_DYNAMIC_OPEN_FAILED,
    MIXED_BAD_DYNAMIC_LIBRARY,
    MIXED_LADSPA_NO_PLUGIN_AT_INDEX,
    MIXED_LADSPA_INSTANTIATION_FAILED,
    MIXED_RESAMPLE_FAILED,
    MIXED_BUFFER_EMPTY,
    MIXED_BUFFER_FULL,
    MIXED_BUFFER_OVERCOMMIT,
    MIXED_BAD_RESAMPLE_FACTOR,
    MIXED_BAD_CHANNEL_CONFIGURATION,
    MIXED_BUFFER_ALLOCATED,
    MIXED_BUFFER_MISSING,
    MIXED_DUPLICATE_SEGMENT,
    MIXED_BAD_SEGMENT,
    MIXED_BAD_ARGUMENT_COUNT,
    MIXED_BAD_NAME,
    MIXED_BUFFER_TOO_SMALL,
    MIXED_INTERNAL_ERROR,
  };
 
  MIXED_EXPORT enum mixed_encoding{
    MIXED_INT8 = 1,
    MIXED_UINT8,
    MIXED_INT16,
    MIXED_UINT16,
    MIXED_INT24,
    MIXED_UINT24,
    MIXED_INT32,
    MIXED_UINT32,
    MIXED_FLOAT,
    MIXED_DOUBLE
  };
 
  MIXED_EXPORT enum mixed_segment_fields{
    MIXED_BUFFER,
    MIXED_BYPASS,
    MIXED_SAMPLERATE,
    MIXED_VOLUME,
    MIXED_RESAMPLE_TYPE,
    MIXED_VOLUME_CONTROL_PAN,
    MIXED_FADE_FROM,
    MIXED_FADE_TO,
    MIXED_FADE_TIME,
    MIXED_FADE_TYPE,
    MIXED_GENERATOR_FREQUENCY,
    MIXED_GENERATOR_TYPE,
    MIXED_SPACE_LOCATION,
    MIXED_SPACE_DIRECTION,
    MIXED_SPACE_VELOCITY,
    MIXED_SPACE_UP,
    MIXED_SPACE_SOUNDSPEED,
    MIXED_SPACE_DOPPLER_FACTOR,
    MIXED_SPACE_MIN_DISTANCE,
    MIXED_SPACE_MAX_DISTANCE,
    MIXED_SPACE_ROLLOFF,
    MIXED_SPACE_ATTENUATION,
    MIXED_DELAY_TIME,
    MIXED_PITCH_SHIFT,
    MIXED_GATE_OPEN_THRESHOLD,
    MIXED_GATE_CLOSE_THRESHOLD,
    MIXED_GATE_ATTACK,
    MIXED_GATE_HOLD,
    MIXED_GATE_RELEASE,
    MIXED_NOISE_TYPE,
    MIXED_REPEAT_TIME,
    MIXED_REPEAT_MODE,
    MIXED_FREQUENCY,
    MIXED_BIQUAD_FILTER,
    MIXED_GAIN,
    MIXED_Q,
    MIXED_IN_COUNT,
    MIXED_OUT_COUNT,
    MIXED_CURRENT_SEGMENT,
    MIXED_SPEED_FACTOR,
    MIXED_QUANTIZE_STEPS,
    MIXED_MIX,
    MIXED_PLANE_LOCATION,
    MIXED_PLANE_VELOCITY,
    MIXED_COMPRESSOR_PREGAIN,
    MIXED_COMPRESSOR_THRESHOLD,
    MIXED_COMPRESSOR_KNEE,
    MIXED_COMPRESSOR_RATIO,
    MIXED_COMPRESSOR_ATTACK,
    MIXED_COMPRESSOR_RELEASE,
    MIXED_COMPRESSOR_PREDELAY,
    MIXED_COMPRESSOR_RELEASEZONE,
    MIXED_COMPRESSOR_POSTGAIN,
    MIXED_COMPRESSOR_GAIN,
    MIXED_CHANNEL_COUNT_IN,
    MIXED_CHANNEL_COUNT_OUT,
    MIXED_REPEAT_POSITION,
    MIXED_FRAMESIZE,
    MIXED_OVERSAMPLING,
    MIXED_BUFFER_SIZE_HINT,
    MIXED_FIR,
    MIXED_CHANNEL_CONFIGURATION,
    MIXED_EQUALIZER_BAND,
  };
 
  MIXED_EXPORT enum mixed_resample_type{
    MIXED_SINC_BEST_QUALITY = 0,
    MIXED_SINC_MEDIUM_QUALITY,
    MIXED_SINC_FASTEST,
    MIXED_ZERO_ORDER_HOLD,
    MIXED_LINEAR_INTERPOLATION
  };
 
  MIXED_EXPORT enum mixed_attenuation{
    MIXED_NO_ATTENUATION = 1,
    MIXED_INVERSE_ATTENUATION,
    MIXED_LINEAR_ATTENUATION,
    MIXED_EXPONENTIAL_ATTENUATION
  };
 
  MIXED_EXPORT enum mixed_fade_type{
    MIXED_LINEAR = 1,
    MIXED_CUBIC_IN,
    MIXED_CUBIC_OUT,
    MIXED_CUBIC_IN_OUT
  };
 
  MIXED_EXPORT enum mixed_generator_type{
    MIXED_SINE = 1,
    MIXED_SQUARE,
    MIXED_TRIANGLE,
    MIXED_SAWTOOTH
  };
 
  MIXED_EXPORT enum mixed_noise_type{
    MIXED_WHITE_NOISE = 1,
    MIXED_PINK_NOISE,
    MIXED_BROWN_NOISE
  };
 
  MIXED_EXPORT enum mixed_repeat_mode{
    MIXED_RECORD = 1,
    MIXED_PLAY,
    MIXED_RECORD_ONCE
  };
 
  MIXED_EXPORT enum mixed_biquad_filter{
    MIXED_LOWPASS = 1,
    MIXED_HIGHPASS,
    MIXED_BANDPASS,
    MIXED_NOTCH,
    MIXED_PEAKING,
    MIXED_ALLPASS,
    MIXED_LOWSHELF,
    MIXED_HIGHSHELF
  };
 
  MIXED_EXPORT enum mixed_segment_info_flags{
    MIXED_INPLACE        = 0x0001,
    MIXED_MODIFIES_INPUT = 0x0002,
    MIXED_IN             = 0x0001,
    MIXED_OUT            = 0x0002,
    MIXED_SEGMENT        = 0x0004,
    MIXED_SET            = 0x0008,
    MIXED_GET            = 0x0010,
    MIXED_CLEARS_OUTPUT  = 0x0020,
  };
 
  MIXED_EXPORT enum mixed_location{
    MIXED_MONO = 0,
    MIXED_LEFT = 0,
    MIXED_RIGHT = 1,
    MIXED_LEFT_FRONT = 0,
    MIXED_RIGHT_FRONT = 1,
    MIXED_LEFT_REAR = 2,
    MIXED_RIGHT_REAR = 3,
    MIXED_CENTER = 4,
    MIXED_SUBWOOFER = 5,
    MIXED_LEFT_FRONT_BOTTOM = 0,
    MIXED_RIGHT_FRONT_BOTTOM = 1,
    MIXED_LEFT_REAR_BOTTOM = 2,
    MIXED_RIGHT_REAR_BOTTOM = 3,
    MIXED_CENTER_FRONT = 4,
    MIXED_LEFT_SIDE = 6,
    MIXED_RIGHT_SIDE = 7,
    MIXED_LEFT_FRONT_TOP = 8,
    MIXED_RIGHT_FRONT_TOP = 9,
    MIXED_LEFT_REAR_TOP = 10,
    MIXED_RIGHT_REAR_TOP = 11,
    MIXED_CENTER_REAR = 12,
    MIXED_LEFT_SIDE_TOP = 13,
    MIXED_RIGHT_SIDE_TOP = 14,
    MIXED_SUBWOOFER_2 = 15,
    MIXED_LEFT_FRONT_WIDE = 16,
    MIXED_RIGHT_FRONT_WIDE = 17,
    MIXED_CENTER_TOP = 18,
    MIXED_CENTER_FRONT_TOP = 18,
    MIXED_CENTER_REAR_TOP = 19,
    MIXED_LEFT_REAR_CENTER = 20,
    MIXED_RIGHT_REAR_CENTER = 21,
    MIXED_SUBWOOFER_LEFT = 22,
    MIXED_SUBWOOFER_RIGHT = 23,
    MIXED_LEFT_FRONT_HIGH = 24,
    MIXED_RIGHT_FRONT_HIGH = 25,
    MIXED_CENTER_FRONT_HIGH = 26,
    MIXED_CENTER_BOTTOM = 27,
    MIXED_LEFT_CENTER_BOTTOM = 28,
    MIXED_RIGHT_CENTER_BOTTOM = 29,
    MIXED_LEFT_FRONT_CENTER_TOP = 31,
    MIXED_RIGHT_FRONT_CENTER_BOTTOM = 32,
    MIXED_MAX_SPEAKER_COUNT = 33
  };
 
  MIXED_EXPORT enum mixed_segment_field_type{
    MIXED_UNKNOWN = 0, /* See MIXED_ENCODING
    MIXED_INT8 = 1,
    MIXED_UINT8,
    MIXED_INT16,
    MIXED_UINT16,
    MIXED_INT24,
    MIXED_UINT24,
    MIXED_INT32,
    MIXED_UINT32,
    MIXED_FLOAT,
    MIXED_DOUBLE */
    MIXED_BOOL = 11,
    MIXED_SIZE_T,
    MIXED_STRING,
    MIXED_FUNCTION,
    MIXED_POINTER,
    MIXED_SEGMENT_POINTER,
    MIXED_BUFFER_POINTER,
    MIXED_PACK_POINTER,
    MIXED_SEGMENT_SEQUENCE_POINTER,
    MIXED_LOCATION_ENUM,
    MIXED_BIQUAD_FILTER_ENUM,
    MIXED_REPEAT_MODE_ENUM,
    MIXED_NOISE_TYPE_ENUM,
    MIXED_GENERATOR_TYPE_ENUM,
    MIXED_FADE_TYPE_ENUM,
    MIXED_ATTENUATION_ENUM,
    MIXED_ENCODING_ENUM,
    MIXED_ERROR_ENUM,
    MIXED_RESAMPLE_TYPE_ENUM,
    MIXED_CHANNEL_T,
    MIXED_DECIBEL_T,
    MIXED_DURATION_T,
    MIXED_CHANNEL_CONFIGURATION_POINTER,
  };
 
  typedef uint8_t mixed_channel_t;
 
  MIXED_EXPORT struct mixed_channel_configuration{
    mixed_channel_t count;
    mixed_channel_t positions[MIXED_MAX_SPEAKER_COUNT];
  };
 
  typedef float mixed_decibel_t;
 
  typedef float mixed_duration_t;
 
  MIXED_EXPORT struct mixed_buffer{
    float *_data;
    uint32_t size;
    uint32_t read;
    uint32_t write;
    uint32_t reserved;
    char is_virtual;
  };
 
  MIXED_EXPORT struct mixed_pack{
    unsigned char *_data;
    uint32_t size;
    uint32_t read;
    uint32_t write;
    uint32_t reserved;
    enum mixed_encoding encoding;
    mixed_channel_t channels;
    uint32_t samplerate;
  };
 
  MIXED_EXPORT struct mixed_segment_field_info{
    uint32_t field;
    const char *description;
    enum mixed_segment_info_flags flags;
    enum mixed_segment_field_type type;
    uint32_t type_count;
  };
 
  MIXED_EXPORT struct mixed_segment_info{
    const char *name;
    const char *description;
    enum mixed_segment_info_flags flags;
    uint32_t min_inputs;
    uint32_t max_inputs;
    uint32_t outputs;
    struct mixed_segment_field_info fields[32];
  };
 
  MIXED_EXPORT struct mixed_segment{
    int (*free)(struct mixed_segment *segment);
    int (*info)(struct mixed_segment_info *info, struct mixed_segment *segment);
    int (*start)(struct mixed_segment *segment);
    int (*mix)(struct mixed_segment *segment);
    int (*end)(struct mixed_segment *segment);
    int (*set_in)(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
    int (*set_out)(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
    int (*get_in)(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
    int (*get_out)(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
    int (*set)(uint32_t field, void *value, struct mixed_segment *segment);
    int (*get)(uint32_t field, void *value, struct mixed_segment *segment);
    void *data;
  };
 
  MIXED_EXPORT int mixed_make_pack(uint32_t frames, struct mixed_pack *pack);
 
  MIXED_EXPORT void mixed_free_pack(struct mixed_pack *pack);
 
  MIXED_EXPORT int mixed_pack_clear(struct mixed_pack *pack);
 
  MIXED_EXPORT uint32_t mixed_pack_available_write(struct mixed_pack *pack);
 
  MIXED_EXPORT uint32_t mixed_pack_available_read(struct mixed_pack *pack);
 
  MIXED_EXPORT int mixed_pack_request_write(void *restrict *area, uint32_t *size, struct mixed_pack *pack);
 
  MIXED_EXPORT int mixed_pack_finish_write(uint32_t size, struct mixed_pack *pack);
 
  MIXED_EXPORT int mixed_pack_request_read(void *restrict *area, uint32_t *size, struct mixed_pack *pack);
 
  MIXED_EXPORT int mixed_pack_finish_read(uint32_t size, struct mixed_pack *pack); 
 
  MIXED_EXPORT int mixed_make_buffer(uint32_t size, struct mixed_buffer *buffer);
 
  MIXED_EXPORT void mixed_free_buffer(struct mixed_buffer *buffer);
 
  MIXED_EXPORT int mixed_buffer_from_pack(struct mixed_pack *in, struct mixed_buffer **outs, float *volume, float target_volume);
 
  MIXED_EXPORT int mixed_buffer_to_pack(struct mixed_buffer **ins, struct mixed_pack *out, float *volume, float target_volume);
 
  MIXED_EXPORT int mixed_buffer_transfer(struct mixed_buffer *from, struct mixed_buffer *to);
 
  MIXED_EXPORT int mixed_buffer_copy(struct mixed_buffer *from, struct mixed_buffer *to);
 
  MIXED_EXPORT int mixed_buffer_clear(struct mixed_buffer *buffer);
 
  MIXED_EXPORT uint32_t mixed_buffer_available_write(struct mixed_buffer *buffer);
 
  MIXED_EXPORT uint32_t mixed_buffer_available_read(struct mixed_buffer *buffer);
 
  MIXED_EXPORT int mixed_buffer_request_write(float *restrict *area, uint32_t *size, struct mixed_buffer *buffer);
 
  MIXED_EXPORT int mixed_buffer_finish_write(uint32_t size, struct mixed_buffer *buffer);
 
  MIXED_EXPORT int mixed_buffer_request_read(float *restrict *area, uint32_t *size, struct mixed_buffer *buffer);
 
  MIXED_EXPORT int mixed_buffer_finish_read(uint32_t size, struct mixed_buffer *buffer);
 
  MIXED_EXPORT int mixed_buffer_resize(uint32_t size, struct mixed_buffer *buffer);
 
#define with_mixed_buffer_transfer(i, samples, inv, in, outv, out, body){ \
    uint32_t samples = UINT32_MAX;                                      \
    struct mixed_buffer *__in = in;                                     \
    struct mixed_buffer *__out = out;                                   \
    float *restrict inv, *restrict outv;                                \
    if(__in == __out){                                                  \
      mixed_buffer_request_read(&inv, &samples, __in);                  \
      outv = inv;                                                       \
      for(uint32_t i=0; i<samples; ++i)                                 \
        body;                                                           \
    }else{                                                              \
      mixed_buffer_request_read(&inv, &samples, __in);                  \
      mixed_buffer_request_write(&outv, &samples, __out);               \
      for(uint32_t i=0; i<samples; ++i)                                 \
        body;                                                           \
      mixed_buffer_finish_read(samples, __in);                          \
      mixed_buffer_finish_write(samples, __out);                        \
    }                                                                   \
  }
 
  MIXED_EXPORT int mixed_free_segment(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_start(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_mix(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_end(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_set_in(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_set_out(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_get_in(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_get_out(uint32_t field, uint32_t location, void *value, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_info(struct mixed_segment_info *info, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_set(uint32_t field, void *value, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_get(uint32_t field, void *value, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_segment_print(char *str, size_t size, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_unpacker(struct mixed_pack *packed, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_packer(struct mixed_pack *packed, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_basic_mixer(mixed_channel_t channels, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_compressor(uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_volume_control(float volume, float pan, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_fade(float from, float to, float time, enum mixed_fade_type type, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_generator(enum mixed_generator_type type, uint32_t frequency, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_ladspa(const char *file, uint32_t index, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_space_mixer(uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_plane_mixer(uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_delay(float time, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_repeat(float time, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_pitch(float pitch, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_gate(uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_noise(enum mixed_noise_type type, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_biquad_filter(enum mixed_biquad_filter type, float frequency, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_speed_change(double speed, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_distribute(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_fwd_fft(uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_inv_fft(uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_queue(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_queue_add(struct mixed_segment *news, struct mixed_segment *queue);
  
  MIXED_EXPORT int mixed_queue_remove(struct mixed_segment *old, struct mixed_segment *queue);
 
  MIXED_EXPORT int mixed_queue_remove_at(uint32_t pos, struct mixed_segment *queue);
 
  MIXED_EXPORT int mixed_queue_clear(struct mixed_segment *queue);
 
  MIXED_EXPORT int mixed_make_segment_void(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_zero(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_channel_convert(uint8_t in, uint8_t out, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_chain(struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_quantize(uint32_t steps, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_chain_add(struct mixed_segment *segment, struct mixed_segment *chain);
 
  MIXED_EXPORT int mixed_chain_add_at(uint32_t i, struct mixed_segment *segment, struct mixed_segment *chain);
 
  MIXED_EXPORT int mixed_chain_remove(struct mixed_segment *segment, struct mixed_segment *chain);
 
  MIXED_EXPORT int mixed_chain_remove_at(uint32_t i, struct mixed_segment *chain);
 
  MIXED_EXPORT int mixed_make_segment_convolution(uint16_t framesize, float *fir, uint32_t fir_size, uint32_t samplerate, struct mixed_segment *segment);
 
  MIXED_EXPORT int mixed_make_segment_equalizer(float bands[8], uint32_t samplerate, struct mixed_segment *segment);
 
  typedef int (*mixed_make_segment_function)(void *args, struct mixed_segment *segment);
 
  typedef int (*mixed_register_segment_function)(const char *name, uint32_t argc, struct mixed_segment_field_info *args, mixed_make_segment_function function);
 
  typedef int (*mixed_deregister_segment_function)(const char *name);
 
  typedef int (*mixed_make_plugin_function)(mixed_register_segment_function registrar);
 
  typedef int (*mixed_free_plugin_function)(mixed_deregister_segment_function registrar);
 
  MIXED_EXPORT int mixed_load_plugin(const char *file);
 
  MIXED_EXPORT int mixed_close_plugin(const char *file);
 
#define MIXED_MAX_MAKE_ARG_COUNT 32
#define MIXED_MAX_SEGMENT_COUNT 1024
#define MIXED_MAX_SEGMENT_NAME_LENGTH 64
 
  MIXED_EXPORT int mixed_register_segment(const char *name, uint32_t argc, struct mixed_segment_field_info *args, mixed_make_segment_function function);
 
  MIXED_EXPORT int mixed_deregister_segment(const char *name);
 
  MIXED_EXPORT int mixed_list_segments(uint32_t *count, char **names);
 
  MIXED_EXPORT int mixed_make_segment_info(const char *name, uint32_t *argc, const struct mixed_segment_field_info **args);
 
  MIXED_EXPORT int mixed_make_segment(const char *name, void *args, struct mixed_segment *segment);
 
  MIXED_EXPORT uint8_t mixed_samplesize(enum mixed_encoding encoding);
 
  MIXED_EXPORT uint8_t mixed_byte_stride(mixed_channel_t channels, enum mixed_encoding encoding);
 
  MIXED_EXPORT int mixed_default_speaker_position(float position[3], mixed_channel_t channel);
 
  MIXED_EXPORT struct mixed_channel_configuration const* mixed_default_channel_configuration(mixed_channel_t channel_count);
 
  MIXED_EXPORT int mixed_configuration_is_surround(struct mixed_channel_configuration const* configuration);
  
  typedef float (*mixed_transfer_function_from)(void *in, float *out, uint8_t stride, uint32_t samples, float volume, float target_volume);
 
  typedef float (*mixed_transfer_function_to)(float *in, void *out, uint8_t stride, uint32_t samples, float volume, float target_volume);
 
  MIXED_EXPORT mixed_transfer_function_from mixed_translator_from(enum mixed_encoding encoding);
 
  MIXED_EXPORT mixed_transfer_function_to mixed_translator_to(enum mixed_encoding encoding);
 
  MIXED_EXPORT int mixed_fwd_fft(uint16_t framesize, float *in, float *out);
 
  MIXED_EXPORT int mixed_inv_fft(uint16_t framesize, float *in, float *out);
 
  __attribute__((always_inline)) MIXED_EXPORT inline float mixed_from_db(mixed_decibel_t volume){
    return powf(10.0f, 0.05f * volume);
  }
 
  __attribute__((always_inline)) MIXED_EXPORT inline mixed_decibel_t mixed_to_db(float volume){
    return 20.0f * log10f(volume);
  }
 
  MIXED_EXPORT int mixed_error(void);
 
  MIXED_EXPORT const char *mixed_error_string(int error_code);
 
  MIXED_EXPORT const char *mixed_type_string(int code);
 
  MIXED_EXPORT const char *mixed_segment_field_string(int code);
 
  MIXED_EXPORT const char *mixed_location_string(int code);
 
  MIXED_EXPORT const char *mixed_info_flag_string(int code);
 
  MIXED_EXPORT const char *mixed_version(void);
 
#ifdef MIXED_NO_CUSTOM_ALLOCATOR
#define mixed_calloc calloc
#define mixed_free free
#define mixed_realloc realloc
#else
  MIXED_EXPORT extern void *(*mixed_calloc)(size_t num, size_t size);
 
  MIXED_EXPORT extern void (*mixed_free)(void *ptr);
 
  MIXED_EXPORT extern void *(*mixed_realloc)(void *ptr, size_t size);
#endif
 
#ifdef __cplusplus
}
#endif
#endif