root/ocaml-remix/trunk/FB_impl.c

#include <caml/alloc.h>
#include <caml/callback.h>
#include <caml/fail.h>
#include <caml/memory.h>
#include <caml/misc.h>
#include <caml/mlvalues.h>

#include <string.h>
#include <stdlib.h>

static void finalize_buffer(value block) {
  float *data = (float *)Field(block, 1);
  free(data);
}

#define RETURN_NEW_BUFFER(data)                     \
  CAMLlocal1(block);                                \
  block = alloc_final(2, &finalize_buffer, 1, 100); \
  Field(block, 1) = (value)data;                    \
  CAMLreturn(block)

#define POINTER_FROM_BUFFER(buffer) ((float *)Field(buffer, 1))

CAMLprim c_FB_new_buffer(value ml_length, value ml_channels) {

  CAMLparam2(ml_length, ml_channels);

  int length = Int_val(ml_length);
  int channels = Int_val(ml_channels);

  float *data = calloc(sizeof(float), length * channels);

  RETURN_NEW_BUFFER(data);
  
}

CAMLprim c_FB_free_buffer(value ml_buffer) {

  CAMLparam1(ml_buffer);
  finalize_buffer(ml_buffer);

  CAMLreturn(Val_unit);
};

CAMLprim c_FB_fill_buffer(value ml_buf, value ml_length, value ml_channels, 
                                                          value ml_callback) {

  CAMLparam4(ml_buf, ml_length, ml_channels, ml_callback);

  float *buffer = POINTER_FROM_BUFFER(ml_buf);
  int length = Int_val(ml_length);
  int channels = Int_val(ml_channels);
  int i;
  int j;
  
  for (i = 0; i < length; i++) {
    buffer[i*channels] = (float)(Double_val(callback(ml_callback, Val_int(i))));
    for (j = 1; j < channels; j++) {
      buffer[i*channels+j] = buffer[i*channels];
    }
  }

  CAMLreturn(Val_unit);
  
}

CAMLprim c_FB_fill_buffer_from_buffer(value ml_buf, value ml_size, 
    value ml_fillbuf, value ml_fillsize, value ml_offset) {

  CAMLparam5(ml_buf, ml_size, ml_fillbuf, ml_fillsize, ml_offset);

  float *buffer = POINTER_FROM_BUFFER(ml_buf);
  float *from = POINTER_FROM_BUFFER(ml_fillbuf);
  int size = Int_val(ml_size);
  int from_size = Int_val(ml_fillsize);
  int from_offset = Int_val(ml_offset);
  int pos;
  
  /* offset first */
  if (from_offset > 0) {
    memcpy(buffer, from + from_offset, 
          (from_size - from_offset) * sizeof(float));
  }

  /* whole copies */
  pos = from_offset;
  while ((pos + from_size) < size) {
    memcpy(buffer + pos, from, from_size * sizeof(float));
    pos += from_size;
  }

  /* last bit */
  if (pos < size) {
    memcpy(buffer + pos, from, (size - pos) * sizeof(float));
  }

  CAMLreturn(Val_unit);
  
} 

CAMLprim c_FB_add_buffers(value ml_bufa, value ml_bufb, value ml_size) {

  CAMLparam3(ml_bufa, ml_bufb, ml_size);

  int size = Int_val(ml_size);
  float *bufa = POINTER_FROM_BUFFER(ml_bufa);
  float *bufb = POINTER_FROM_BUFFER(ml_bufb);
  float *data = malloc(sizeof(float) * size);
  int i;
  
  for (i = 0; i < size; i++) {
    data[i] = bufa[i] + bufb[i];
  }

  RETURN_NEW_BUFFER(data);

}

CAMLprim c_FB_mult_buffers(value ml_bufa, value ml_bufb, value ml_size) {

  CAMLparam3(ml_bufa, ml_bufb, ml_size);

  int size = Int_val(ml_size);
  float *bufa = POINTER_FROM_BUFFER(ml_bufa);
  float *bufb = POINTER_FROM_BUFFER(ml_bufb);
  float *data = malloc(sizeof(float) * size);
  int i;

  for (i = 0; i < size; i++) {
    data[i] = bufa[i] * bufb[i];
  }

  RETURN_NEW_BUFFER(data);

}

CAMLprim c_FB_transparency(value ml_bufa, value ml_bufb, value ml_trans, value
    ml_size) {

  CAMLparam4(ml_bufa, ml_bufb, ml_trans, ml_size);

  int size = Int_val(ml_size);
  float *bufa = POINTER_FROM_BUFFER(ml_bufa);
  float *bufb = POINTER_FROM_BUFFER(ml_bufb);
  float *trans = POINTER_FROM_BUFFER(ml_trans);
  float *data = malloc(sizeof(float) * size);
  int i;

  for (i = 0; i < size; i++) {
    data[i] = bufa[i] * trans[i] + bufb[i] * (1 - trans[i]);
  }

  RETURN_NEW_BUFFER(data);
}

CAMLprim c_FB_at(value ml_buffer, value ml_position) {

  CAMLparam2(ml_buffer, ml_position);

  float *buffer = POINTER_FROM_BUFFER(ml_buffer);
  int position = Int_val(ml_position);

  CAMLreturn(copy_double(buffer[position]));

}

CAMLprim c_FB_short_at(value ml_buffer, value ml_position) {

  CAMLparam2(ml_buffer, ml_position);

  float *buffer = POINTER_FROM_BUFFER(ml_buffer);
  int position = Int_val(ml_position);

  CAMLreturn(Val_int((int)(buffer[position]*32767)));

}

CAMLprim c_FB_split_into_channels(value ml_buffer, value ml_buffers, value ml_length) {

  CAMLparam3(ml_buffer, ml_buffers, ml_length);

  float *buffer = POINTER_FROM_BUFFER(ml_buffer);
  int channels = Wosize_val(ml_buffers);
  int length = Int_val(ml_length);
  int i;

  float **odata = malloc(channels * sizeof(float *));

  for (i = 0; i < channels; i++) {
    value b = (value)Field(ml_buffers, i);
    odata[i] = POINTER_FROM_BUFFER(b);
  }

  length *= channels;

  for (i = 0; i < length; i++) {
    odata[i % channels][i / channels] = buffer[i];
  }

  free(odata);

  CAMLreturn(Val_unit);

}

CAMLprim c_FB_merge_channels(value ml_buffers, value ml_buffer, value ml_length) {
  
  CAMLparam3(ml_buffers, ml_buffer, ml_length);
  
  int channels = Wosize_val(ml_buffers);
  int length = Int_val(ml_length);
  int i;

  float **idata = malloc(channels * sizeof(float *));
  float *odata = POINTER_FROM_BUFFER(ml_buffer);

  for (i = 0; i < channels; i++) {
    value b = (value)Field(ml_buffers, i);
    idata[i] = POINTER_FROM_BUFFER(b);
  }

  length *= channels;

  for(i = 0; i < length; i++) {
    odata[i] = idata[i % channels][i / channels];
  }

  free(idata);

  CAMLreturn(Val_unit);

}

CAMLprim c_FB_average(value ml_buffers, value ml_size) {

  CAMLparam2(ml_buffers, ml_size);
  int num_buffers = Wosize_val(ml_buffers);
  int size = Int_val(ml_size);
  int i, j;

  float **idata = malloc(num_buffers * sizeof(float *));
  float *odata = malloc(size * sizeof(float));

  for (i = 0; i < num_buffers; i++) {
    value b = (value)Field(ml_buffers, i);
    idata[i] = POINTER_FROM_BUFFER(b);
  }

  for (i = 0; i < size; i++) {
    odata[i] = 0;
    for (j = 0; j < num_buffers; j++) {
      odata[i] += idata[j][i];
    }
    odata[i] /= num_buffers;
  }

  free(idata);

  RETURN_NEW_BUFFER(odata);

}

CAMLprim c_FB_blit(value ml_src, value ml_srcpos, value ml_dst, value ml_dstpos,
                      value ml_length) {

  CAMLparam5(ml_src, ml_srcpos, ml_dst, ml_dstpos, ml_length);

  float *src = POINTER_FROM_BUFFER(ml_src);
  float *dst = POINTER_FROM_BUFFER(ml_dst);
  int srcpos = Int_val(ml_srcpos);
  int dstpos = Int_val(ml_dstpos);
  int length = Int_val(ml_length);

  memcpy(dst + dstpos, src + srcpos, length * sizeof(float));

  CAMLreturn(Val_unit);

}