#pragma once

#include <util/bmem.h>

#include <util/platform.h>

#include <util/threading.h>

#include <obs-module.h>

#include <vector>

#include <stdio.h>

#include <string>

#include <windows.h>

#include "RtAudio.h"

OBS_DECLARE_MODULE()

OBS_MODULE_USE_DEFAULT_LOCALE("win-asio", "en-US")

#define blog(level, msg, ...) blog(level, "asio-input: " msg, ##__VA_ARGS__)

#define NSEC_PER_SEC 1000000000LL

#define TEXT_BUFFER_SIZE obs_module_text("BufferSize")

#define TEXT_BUFFER_64_SAMPLES obs_module_text("64_samples")

#define TEXT_BUFFER_128_SAMPLES obs_module_text("128_samples")

#define TEXT_BUFFER_256_SAMPLES obs_module_text("256_samples")

#define TEXT_BUFFER_512_SAMPLES obs_module_text("512_samples")

#define TEXT_BUFFER_1024_SAMPLES obs_module_text("1024_samples")

#define TEXT_BITDEPTH obs_module_text("BitDepth")

struct asio_data {

};

RtAudio adc;

enum audio_format rtasio_to_obs_audio_format(RtAudioFormat format)

}

enum audio_format get_planar_format(audio_format format)

}

int bytedepth_format(audio_format format)

{

return (int)get_audio_bytes_per_channel(format);

}

int bytedepth_format(RtAudioFormat format) {

return bytedepth_format(rtasio_to_obs_audio_format(format));

}

RtAudioFormat obs_to_rtasio_audio_format(audio_format format)

}

enum speaker_layout asio_channels_to_obs_speakers(unsigned int channels)

}

RtAudio::DeviceInfo get_device_info(const char *device) {

}

uint8_t get_device_index(const char *device) {

}

void asio_update(void *vptr, obs_data_t *settings);

void asio_destroy(void *vptr);

void fill_out_devices(obs_property_t *list) {

}

static bool fill_out_channels_modified(obs_properties_t *props, obs_property_t *list, obs_data_t *settings) {

}

static bool fill_out_sample_rates(obs_properties_t *props, obs_property_t *list, obs_data_t *settings) {

}

static bool fill_out_bit_depths(obs_properties_t *props, obs_property_t *list, obs_data_t *settings) {

}

static bool asio_device_changed(obs_properties_t *props,

}

int mix(uint8_t *inputBuffer, obs_source_audio *out, size_t bytes_per_ch, int route[], unsigned int recorded_device_chs = UINT_MAX) {

}

int create_asio_buffer(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,

}

void asio_init(struct asio_data *data)

}

static void * asio_create(obs_data_t *settings, obs_source_t *source)

{

struct asio_data *data = new asio_data;

data->source = source;

data->first_ts = 0;

data->device = NULL;

asio_update(data, settings);

if (obs_data_get_string(settings, "device_id")) {

asio_init(data);

}

return data;

}

void asio_destroy(void *vptr)

}

void asio_update(void *vptr, obs_data_t *settings)

}

const char * asio_get_name(void *unused)

{

UNUSED_PARAMETER(unused);

return obs_module_text("asioInput");

}

void asio_get_defaults(obs_data_t *settings)

}

obs_properties_t * asio_get_properties(void *unused)

{

obs_properties_t *props;

obs_property_t *devices;

obs_property_t *rate;

obs_property_t *bit_depth;

obs_property_t *buffer_size;

obs_property_t *route[MAX_AUDIO_CHANNELS];

int pad_digits = (int)floor(log10(abs(MAX_AUDIO_CHANNELS))) + 1;

UNUSED_PARAMETER(unused);

props = obs_properties_create();

devices = obs_properties_add_list(props, "device_id",

obs_module_text("Device"), OBS_COMBO_TYPE_LIST,

OBS_COMBO_FORMAT_STRING);

obs_property_set_modified_callback(devices, asio_device_changed);

fill_out_devices(devices);

std::string dev_descr = "ASIO devices.\n"

"OBS-Studio supports for now a single ASIO source.\n"

"But duplication of an ASIO source in different scenes is still possible";

obs_property_set_long_description(devices, dev_descr.c_str());

// get channel number from output speaker layout set by obs

struct obs_audio_info aoi;

obs_get_audio_info(&aoi);

unsigned int recorded_channels = get_audio_channels(aoi.speakers);

std::string route_descr = "For each OBS output channel, pick one\n of the input channels of your ASIO device.\n";

const char* route_name_format = "route %i";

char* route_name = new char[strlen(route_name_format) + pad_digits];

const char* route_obs_format = "Route.%i";

char* route_obs = new char[strlen(route_obs_format) + pad_digits];

for (size_t i = 0; i < recorded_channels; i++) {

sprintf(route_name, route_name_format, i);

sprintf(route_obs, route_obs_format, i);

route[i] = obs_properties_add_list(props, route_name, obs_module_text(route_obs),

OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);

obs_property_set_long_description(route[i], route_descr.c_str());

}

free(route_name);

free(route_obs);

rate = obs_properties_add_list(props, "sample rate",

obs_module_text("SampleRate"), OBS_COMBO_TYPE_LIST,

OBS_COMBO_FORMAT_INT);

std::string rate_descr = "Sample rate : number of samples per channel in one second.\n";

obs_property_set_long_description(rate, rate_descr.c_str());

bit_depth = obs_properties_add_list(props, "bit depth",

TEXT_BITDEPTH, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);

std::string bit_descr = "Bit depth : size of a sample in bits and format.\n"

"Float should be preferred.";

obs_property_set_long_description(bit_depth, bit_descr.c_str());

buffer_size = obs_properties_add_list(props, "buffer", TEXT_BUFFER_SIZE,

OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);

obs_property_list_add_int(buffer_size, "64", 64);

obs_property_list_add_int(buffer_size, "128", 128);

obs_property_list_add_int(buffer_size, "256", 256);

obs_property_list_add_int(buffer_size, "512", 512);

obs_property_list_add_int(buffer_size, "1024", 1024);

std::string buffer_descr = "Buffer : number of samples in a single frame.\n"

"A lower value implies lower latency.\n"

"256 should be OK for most cards.\n"

"Warning: the real buffer returned by the device may differ";

obs_property_set_long_description(buffer_size, buffer_descr.c_str());

return props;

}

bool obs_module_load(void)