sine.c

#include <soundio/soundio.h>

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

static const float TWOPI = 2*3.1415926535f;
static float seconds_offset = 0.0f;
static void underflow_callback(struct SoundIoOutStream *outstream) {
  fprintf(stderr, "underflow!\n");
}
static void write_callback(struct SoundIoOutStream *outstream,
        int frame_count_min, int frame_count_max)
{
    const struct SoundIoChannelLayout *layout = &outstream->layout;
    float float_sample_rate = outstream->sample_rate;
    float seconds_per_frame = 1.0f / float_sample_rate;
    struct SoundIoChannelArea *areas;
    int frames_left = frame_count_max;
    int err;

    while (frames_left > 0) {
        int frame_count = frames_left;

        if ((err = soundio_outstream_begin_write(outstream, &areas, &frame_count))) {
            fprintf(stderr, "%s\n", soundio_strerror(err));
            exit(1);
        }

        if (!frame_count)
            break;

        float pitch = 440.0f;
        for (int frame = 0; frame < frame_count; frame += 1) {
          float sample = 0.0f;
          int k = 500;
          float t = seconds_offset + frame * seconds_per_frame;
          for (int i = 0; i < k; i++) {
            sample += sin(t * TWOPI * (pitch + i));
          }
          sample /= k;
          for (int channel = 0; channel < layout->channel_count; channel += 1) {
              float *ptr = (float*)(areas[channel].ptr + areas[channel].step * frame);
              *ptr = sample;
          }
        }
        seconds_offset = fmod(seconds_offset + seconds_per_frame * frame_count, 1.0);

        if ((err = soundio_outstream_end_write(outstream))) {
            fprintf(stderr, "%s\n", soundio_strerror(err));
            exit(1);
        }

        frames_left -= frame_count;
    }
}

int main(int argc, char **argv) {
    int err;
    struct SoundIo *soundio = soundio_create();
    if (!soundio) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    if ((err = soundio_connect(soundio))) {
        fprintf(stderr, "error connecting: %s\n", soundio_strerror(err));
        return 1;
    }

    soundio_flush_events(soundio);

    int default_out_device_index = soundio_default_output_device_index(soundio);
    if (default_out_device_index < 0) {
        fprintf(stderr, "no output device found\n");
        return 1;
    }

    struct SoundIoDevice *device = soundio_get_output_device(soundio, default_out_device_index);
    if (!device) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    fprintf(stderr, "Output device: %s\n", device->name);

    struct SoundIoOutStream *outstream = soundio_outstream_create(device);
    if (!outstream) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }
    outstream->format = SoundIoFormatFloat32NE;
    /* outstream->sample_rate = 44100; */
    /* outstream->software_latency = 0.025f; */

    if ((err = soundio_outstream_open(outstream))) {
        fprintf(stderr, "unable to open device: %s", soundio_strerror(err));
        return 1;
    }

    if (outstream->layout_error)
      fprintf(stderr, "unable to set channel layout: %s\n", soundio_strerror(outstream->layout_error));

    outstream->write_callback = write_callback;
    outstream->underflow_callback = underflow_callback;

    fprintf(stdout, "latency: %f\n", outstream->software_latency);
    fprintf(stdout, "channe_count: %d\n", outstream->layout.channel_count);
    fprintf(stdout, "sample_rate: %d\n", outstream->sample_rate);
    fprintf(stdout, "buffer_size: %f\n", outstream->sample_rate * outstream->software_latency);

    if ((err = soundio_outstream_start(outstream))) {
        fprintf(stderr, "unable to start device: %s\n", soundio_strerror(err));
        return 1;
    }

    for (;;)
        soundio_wait_events(soundio);

    soundio_outstream_destroy(outstream);
    soundio_device_unref(device);
    soundio_destroy(soundio);
    return 0;
}