libaf/af.h

   1 #ifndef __aop_h__
   2 #define __aop_h__
   3
   4 #include <stdio.h>
   5
   6 #include "af_mp.h"
   7 #include "config.h"
   8 #include "control.h"
   9 #include "af_format.h"
  10
  11 struct af_instance_s;
  12
  13 // Audio data chunk
  14 typedef struct af_data_s
  15 {
  16   void* audio;  // data buffer
  17   int len;      // buffer length
  18   int rate;     // sample rate
  19   int nch;      // number of channels
  20   int format;   // format
  21   int bps;      // bytes per sample
  22 } af_data_t;
  23
  24 // Fraction, used to calculate buffer lengths
  25 typedef struct frac_s
  26 {
  27   int n; // Numerator
  28   int d; // Denominator
  29 } frac_t;
  30
  31 int af_gcd(register int a, register int b);
  32 void af_frac_cancel(frac_t *f);
  33 void af_frac_mul(frac_t *out, const frac_t *in);
  34
  35 // Flags used for defining the behavior of an audio filter
  36 #define AF_FLAGS_REENTRANT      0x00000000
  37 #define AF_FLAGS_NOT_REENTRANT  0x00000001
  38
  39 /* Audio filter information not specific for current instance, but for
  40    a specific filter */
  41 typedef struct af_info_s
  42 {
  43   const char *info;
  44   const char *name;
  45   const char *author;
  46   const char *comment;
  47   const int flags;
  48   int (*open)(struct af_instance_s* vf);
  49 } af_info_t;
  50
  51 // Linked list of audio filters
  52 typedef struct af_instance_s
  53 {
  54   af_info_t* info;
  55   int (*control)(struct af_instance_s* af, int cmd, void* arg);
  56   void (*uninit)(struct af_instance_s* af);
  57   af_data_t* (*play)(struct af_instance_s* af, af_data_t* data);
  58   void* setup;    // setup data for this specific instance and filter
  59   af_data_t* data; // configuration for outgoing data stream
  60   struct af_instance_s* next;
  61   struct af_instance_s* prev;
  62   double delay; // Delay caused by the filter [ms]
  63   frac_t mul; /* length multiplier: how much does this instance change
  64                  the length of the buffer. */
  65 }af_instance_t;
  66
  67 // Initialization flags
  68 extern int* af_cpu_speed;
  69
  70 #define AF_INIT_AUTO            0x00000000
  71 #define AF_INIT_SLOW            0x00000001
  72 #define AF_INIT_FAST            0x00000002
  73 #define AF_INIT_FORCE           0x00000003
  74 #define AF_INIT_TYPE_MASK       0x00000003
  75
  76 #define AF_INIT_INT             0x00000000
  77 #define AF_INIT_FLOAT           0x00000004
  78 #define AF_INIT_FORMAT_MASK     0x00000004
  79
  80 // Default init type
  81 #ifndef AF_INIT_TYPE
  82 #if defined(HAVE_SSE) || defined(HAVE_3DNOW)
  83 #define AF_INIT_TYPE (af_cpu_speed?*af_cpu_speed:AF_INIT_FAST)
  84 #else
  85 #define AF_INIT_TYPE (af_cpu_speed?*af_cpu_speed:AF_INIT_SLOW)
  86 #endif
  87 #endif
  88
  89 // Configuration switches
  90 typedef struct af_cfg_s{
  91   int force;    // Initialization type
  92   char** list;  /* list of names of filters that are added to filter
  93                    list during first initialization of stream */
  94 }af_cfg_t;
  95
  96 // Current audio stream
  97 typedef struct af_stream_s
  98 {
  99   // The first and last filter in the list
 100   af_instance_t* first;
 101   af_instance_t* last;
 102   // Storage for input and output data formats
 103   af_data_t input;
 104   af_data_t output;
 105   // Configuration for this stream
 106   af_cfg_t cfg;
 107 }af_stream_t;
 108
 109 /*********************************************
 110 // Return values
 111 */
 112
 113 #define AF_DETACH   2
 114 #define AF_OK       1
 115 #define AF_TRUE     1
 116 #define AF_FALSE    0
 117 #define AF_UNKNOWN -1
 118 #define AF_ERROR   -2
 119 #define AF_FATAL   -3
 120
 121
 122
 123 /*********************************************
 124 // Export functions
 125 */
 126
 127 /**
 128  * \defgroup af_chain Audio filter chain functions
 129  * \{
 130  * \param s filter chain
 131  */
 132
 133 /**
 134  * \brief Initialize the stream "s".
 135  * \return 0 on success, -1 on failure
 136  *
 137  * This function creates a new filter list if necessary, according
 138  * to the values set in input and output. Input and output should contain
 139  * the format of the current movie and the format of the preferred output
 140  * respectively.
 141  * Filters to convert to the preferred output format are inserted
 142  * automatically, except when they are set to 0.
 143  * The function is reentrant i.e. if called with an already initialized
 144  * stream the stream will be reinitialized.
 145  */
 146 int af_init(af_stream_t* s);
 147
 148 /**
 149  * \brief Uninit and remove all filters from audio filter chain
 150  */
 151 void af_uninit(af_stream_t* s);
 152
 153 /**
 154  * \brief This function adds the filter "name" to the stream s.
 155  * \param name name of filter to add
 156  * \return pointer to the new filter, NULL if insert failed
 157  *
 158  * The filter will be inserted somewhere nice in the
 159  * list of filters (i.e. at the beginning unless the
 160  * first filter is the format filter (why??).
 161  */
 162 af_instance_t* af_add(af_stream_t* s, char* name);
 163
 164 /**
 165  * \brief Uninit and remove the filter "af"
 166  * \param af filter to remove
 167  */
 168 void af_remove(af_stream_t* s, af_instance_t* af);
 169
 170 /**
 171  * \brief find filter in chain by name
 172  * \param name name of the filter to find
 173  * \return first filter with right name or NULL if not found
 174  *
 175  * This function is used for finding already initialized filters
 176  */
 177 af_instance_t* af_get(af_stream_t* s, char* name);
 178
 179 /**
 180  * \brief filter data chunk through the filters in the list
 181  * \param data data to play
 182  * \return resulting data
 183  * \ingroup af_chain
 184  */
 185 af_data_t* af_play(af_stream_t* s, af_data_t* data);
 186
 187 /**
 188  * \brief send control to all filters, starting with the last until
 189  *        one accepts the command with AF_OK.
 190  * \param cmd filter control command
 191  * \param arg argument for filter command
 192  * \return the accepting filter or NULL if none was found
 193  */
 194 af_instance_t *af_control_any_rev (af_stream_t* s, int cmd, void* arg);
 195
 196 /**
 197  * \brief Calculate how long the output from the filters will be for a given
 198  *        input length.
 199  * \param len input lenght for which to calculate output length
 200  * \return calculated output length, will always be >= the resulting
 201  *         length when actually calling af_play.
 202  */
 203 int af_outputlen(af_stream_t* s, int len);
 204
 205 /**
 206  * \brief Calculate how long the input to the filters should be to produce a
 207  *        certain output length
 208  * \param len wanted output length
 209  * \return input length required to produce the output length "len". Possibly
 210  *         smaller to avoid overflow of output buffer
 211  */
 212 int af_inputlen(af_stream_t* s, int len);
 213
 214 /**
 215  * \brief calculate required input length for desired output size
 216  * \param len desired minimum output length
 217  * \param max_outsize maximum output length
 218  * \param max_insize maximum input length
 219  * \return input length or -1 on error
 220  *
 221    Calculate how long the input IN to the filters should be to produce
 222    a certain output length OUT but with the following three constraints:
 223    1. IN <= max_insize, where max_insize is the maximum possible input
 224       block length
 225    2. OUT <= max_outsize, where max_outsize is the maximum possible
 226       output block length
 227    3. If possible OUT >= len.
 228  */
 229 int af_calc_insize_constrained(af_stream_t* s, int len,
 230                                int max_outsize,int max_insize);
 231
 232 /**
 233  * \brief Calculate the total delay caused by the filters
 234  * \return delay in seconds
 235  */
 236 double af_calc_delay(af_stream_t* s);
 237
 238 /** \} */ // end of af_chain group
 239
 240 // Helper functions and macros used inside the audio filters
 241
 242 /**
 243  * \defgroup af_filter Audio filter helper functions
 244  * \{
 245  */
 246
 247 /* Helper function called by the macro with the same name only to be
 248    called from inside filters */
 249 int af_resize_local_buffer(af_instance_t* af, af_data_t* data);
 250
 251 /* Helper function used to calculate the exact buffer length needed
 252    when buffers are resized. The returned length is >= than what is
 253    needed */
 254 int af_lencalc(frac_t mul, af_data_t* data);
 255
 256 /**
 257  * \brief convert dB to gain value
 258  * \param n number of values to convert
 259  * \param in [in] values in dB, <= -200 will become 0 gain
 260  * \param out [out] gain values
 261  * \param k input values are divided by this
 262  * \param mi minimum dB value, input will be clamped to this
 263  * \param ma maximum dB value, input will be clamped to this
 264  * \return AF_ERROR on error, AF_OK otherwise
 265  */
 266 int af_from_dB(int n, float* in, float* out, float k, float mi, float ma);
 267
 268 /**
 269  * \brief convert gain value to dB
 270  * \param n number of values to convert
 271  * \param in [in] gain values, 0 wil become -200 dB
 272  * \param out [out] values in dB
 273  * \param k output values will be multiplied by this
 274  * \return AF_ERROR on error, AF_OK otherwise
 275  */
 276 int af_to_dB(int n, float* in, float* out, float k);
 277
 278 /**
 279  * \brief convert milliseconds to sample time
 280  * \param n number of values to convert
 281  * \param in [in] values in milliseconds
 282  * \param out [out] sample time values
 283  * \param rate sample rate
 284  * \param mi minimum ms value, input will be clamped to this
 285  * \param ma maximum ms value, input will be clamped to this
 286  * \return AF_ERROR on error, AF_OK otherwise
 287  */
 288 int af_from_ms(int n, float* in, int* out, int rate, float mi, float ma);
 289
 290 /**
 291  * \brief convert sample time to milliseconds
 292  * \param n number of values to convert
 293  * \param in [in] sample time values
 294  * \param out [out] values in milliseconds
 295  * \param rate sample rate
 296  * \return AF_ERROR on error, AF_OK otherwise
 297  */
 298 int af_to_ms(int n, int* in, float* out, int rate);
 299
 300 /**
 301  * \brief test if output format matches
 302  * \param af audio filter
 303  * \param out needed format, will be overwritten by available
 304  *            format if they do not match
 305  * \return AF_FALSE if formats do not match, AF_OK if they match
 306  *
 307  * compares the format, bps, rate and nch values of af->data with out
 308  */
 309 int af_test_output(struct af_instance_s* af, af_data_t* out);
 310
 311 /**
 312  * \brief soft clipping function using sin()
 313  * \param a input value
 314  * \return clipped value
 315  */
 316 float af_softclip(float a);
 317
 318 /** \} */ // end of af_filter group, but more functions of this group below
 319
 320 /** Print a list of all available audio filters */
 321 void af_help(void);
 322
 323 /**
 324  * \brief fill the missing parameters in the af_data_t structure
 325  * \param data structure to fill
 326  * \ingroup af_filter
 327  *
 328  * Currently only sets bps based on format
 329  */
 330 void af_fix_parameters(af_data_t *data);
 331
 332 /** Memory reallocation macro: if a local buffer is used (i.e. if the
 333    filter doesn't operate on the incoming buffer this macro must be
 334    called to ensure the buffer is big enough.
 335  * \ingroup af_filter
 336  */
 337 #define RESIZE_LOCAL_BUFFER(a,d)\
 338 ((a->data->len < af_lencalc(a->mul,d))?af_resize_local_buffer(a,d):AF_OK)
 339
 340 /* Some other useful macro definitions*/
 341 #ifndef min
 342 #define min(a,b)(((a)>(b))?(b):(a))
 343 #endif
 344
 345 #ifndef max
 346 #define max(a,b)(((a)>(b))?(a):(b))
 347 #endif
 348
 349 #ifndef clamp
 350 #define clamp(a,min,max) (((a)>(max))?(max):(((a)<(min))?(min):(a)))
 351 #endif
 352
 353 #ifndef sign
 354 #define sign(a) (((a)>0)?(1):(-1))
 355 #endif
 356
 357 #ifndef lrnd
 358 #define lrnd(a,b) ((b)((a)>=0.0?(a)+0.5:(a)-0.5))
 359 #endif
 360
 361 /* Error messages */
 362
 363 typedef struct af_msg_cfg_s
 364 {
 365   int level;    /* Message level for debug and error messages max = 2
 366                    min = -2 default = 0 */
 367   FILE* err;    // Stream to print error messages to
 368   FILE* msg;    // Stream to print information messages to
 369 }af_msg_cfg_t;
 370
 371 extern af_msg_cfg_t af_msg_cfg; // Message
 372
 373 //! \addtogroup af_filter
 374 //! \{
 375 #define AF_MSG_FATAL    -3 ///< Fatal error exit immediately
 376 #define AF_MSG_ERROR    -2 ///< Error return gracefully
 377 #define AF_MSG_WARN     -1 ///< Print warning but do not exit (can be suppressed)
 378 #define AF_MSG_INFO      0 ///< Important information
 379 #define AF_MSG_VERBOSE   1 ///< Print this if verbose is enabled
 380 #define AF_MSG_DEBUG0    2 ///< Print if very verbose
 381 #define AF_MSG_DEBUG1    3 ///< Print if very very verbose
 382
 383 //! Macro for printing error messages
 384 #ifndef af_msg
 385 #define af_msg(lev, args... ) \
 386 (((lev)<AF_MSG_WARN)?(fprintf(af_msg_cfg.err?af_msg_cfg.err:stderr, ## args )): \
 387 (((lev)<=af_msg_cfg.level)?(fprintf(af_msg_cfg.msg?af_msg_cfg.msg:stdout, ## args )):0))
 388 #endif
 389 //! \}
 390
 391 #endif /* __aop_h__ */