jack-capture/vringbuffer.h

   1
   2 #include <stdbool.h>
   3
   4 #include <unistd.h>
   5
   6 #include <pthread.h>
   7 #include <semaphore.h>
   8
   9
  10 #include <jack/ringbuffer.h>
  11
  12
  13 struct vringbuffer_t;
  14
  15 typedef  int (*Vringbuffer_autoincrease_callback) (struct vringbuffer_t *vrb, bool first_time, int reading_size, int writing_size);
  16 typedef  void (*Vringbuffer_receiver_callback) (struct vringbuffer_t *vrb, bool first_time, void *buffer);
  17
  18 typedef struct vringbuffer_list_t{
  19   struct vringbuffer_list_t *next;
  20 }vringbuffer_list_t;
  21
  22
  23 typedef struct vringbuffer_t{
  24   jack_ringbuffer_t *for_writer1;
  25   jack_ringbuffer_t *for_writer2;
  26   jack_ringbuffer_t *for_reader;
  27
  28   size_t element_size;
  29
  30   int curr_num_elements;
  31   int max_num_elements;
  32   vringbuffer_list_t *allocated_mem;
  33
  34   pthread_mutex_t increase_lock;
  35
  36   bool please_stop;
  37
  38   // Receiver callback
  39   pthread_t receiver_thread;
  40   sem_t receiver_trigger;
  41   sem_t receiver_started;
  42   Vringbuffer_receiver_callback receiver_callback;
  43
  44   // Autoincrease callback
  45   pthread_t autoincrease_thread;
  46   sem_t autoincrease_trigger;
  47   sem_t autoincrease_started;
  48   Vringbuffer_autoincrease_callback autoincrease_callback;
  49   useconds_t autoincrease_interval;
  50 }vringbuffer_t;
  51
  52
  53
  54
  55 vringbuffer_t* vringbuffer_create       (int num_elements_during_startup, int max_num_elements,size_t element_size);
  56 void vringbuffer_stop_callbacks(vringbuffer_t* vrb);
  57 void vringbuffer_delete(vringbuffer_t* vrb);
  58
  59 void    vringbuffer_increase            (vringbuffer_t *vrb, int num_elements, void **elements);
  60
  61 // Creates a new autoincrease thread. The callback is called each 'interval' microseconds.
  62 // The callback does not have to allocate memory itself, but instead the function returns the number of elements (not bytes) to allocate.
  63 // The callback is also responsible for setting nicety and priority of the thread. This should be done when called the first time (i.e. when first_time==true).
  64 //
  65 // The return value for autoincrease_callback is also ignored the first time, and both reading_size and writing_size will have the values 0.
  66 // Furthermore, the first time autoincrease_callback is called, it is called before vringbuffer_set_autoincrease_callback() returns
  67 //
  68 // An autoincrease callback could be implemented like this:
  69 /*
  70   static int autoincrease_callback(vringbuffer_t *vrb, bool first_call, size_t reading_size, size_t writing_size){
  71      if(first_call){
  72        set_high_priority();
  73        return 0;
  74      }
  75      if(writing_size < 1024)
  76        return 2;
  77      return 0;
  78   }
  79
  80   int main(){
  81     ...
  82     vringbuffer_t *vrg = vrngbuffer_create(quite_large_number,very_large_number,element_size);
  83     vringbuffer_set_autoincrease_callback(vrg,autoincrease_callback,quite_often);
  84     ...
  85   }
  86 */
  87
  88 // Set interval==0 if you wan't the callback to be triggered if using the trigger_autoincrease_callback function.
  89 void    vringbuffer_set_autoincrease_callback  (vringbuffer_t *vrg, Vringbuffer_autoincrease_callback callback, useconds_t interval);
  90
  91 // Don't call unless interval==0
  92 void vringbuffer_trigger_autoincrease_callback(vringbuffer_t *vrb);
  93
  94 void*   vringbuffer_get_reading         (vringbuffer_t *vrb);
  95 void    vringbuffer_return_reading      (vringbuffer_t *vrb, void *data);
  96 // Returns available number of elements in the ringbuffer
  97 int     vringbuffer_reading_size        (vringbuffer_t *vrb);
  98
  99 void vringbuffer_set_receiver_callback(vringbuffer_t *vrb,Vringbuffer_receiver_callback receiver_callback);
 100
 101 void*   vringbuffer_get_writing         (vringbuffer_t *vrb);
 102 void    vringbuffer_return_writing      (vringbuffer_t *vrb, void *data);
 103 // Returns available number of elements in the ringbuffer
 104 int     vringbuffer_writing_size        (vringbuffer_t *vrb);
 105
 106
 107
 108
 109