{

switch (format) {

case BASS_ASIO_FORMAT_16BIT: return AUDIO_FORMAT_16BIT;

case BASS_ASIO_FORMAT_32BIT: return AUDIO_FORMAT_32BIT;

case BASS_ASIO_FORMAT_FLOAT: return AUDIO_FORMAT_FLOAT;

default: break;

}

return AUDIO_FORMAT_UNKNOWN;

{

switch (format) {

case AUDIO_FORMAT_16BIT:

return BASS_ASIO_FORMAT_16BIT;

// obs doesn't have 24 bit

case AUDIO_FORMAT_32BIT:

return BASS_ASIO_FORMAT_32BIT;

case AUDIO_FORMAT_FLOAT:

default:

return BASS_ASIO_FORMAT_FLOAT;

}

// default to 32 float samples for best quality

{

switch (channels) {

case 1: return SPEAKERS_MONO;

case 2: return SPEAKERS_STEREO;

case 3: return SPEAKERS_2POINT1;

case 4: return SPEAKERS_4POINT0;

case 5: return SPEAKERS_4POINT1;

case 6: return SPEAKERS_5POINT1;

/* no layout for 7 channels */

case 8: return SPEAKERS_7POINT1;

}

return SPEAKERS_UNKNOWN;

uint8_t *data[MAX_AUDIO_CHANNELS];

uint32_t frames;

volatile long speakers;

enum audio_format format;

uint32_t samples_per_sec;

uint64_t timestamp;

switch (format) {

case AUDIO_FORMAT_U8BIT:

return AUDIO_FORMAT_U8BIT_PLANAR;

case AUDIO_FORMAT_16BIT:

return AUDIO_FORMAT_16BIT_PLANAR;

case AUDIO_FORMAT_32BIT:

return AUDIO_FORMAT_32BIT_PLANAR;

case AUDIO_FORMAT_FLOAT:

return AUDIO_FORMAT_FLOAT_PLANAR;

}

return format;

switch (format) {

case AUDIO_FORMAT_U8BIT_PLANAR:

return AUDIO_FORMAT_U8BIT;

case AUDIO_FORMAT_16BIT_PLANAR:

return AUDIO_FORMAT_16BIT;

case AUDIO_FORMAT_32BIT_PLANAR:

return AUDIO_FORMAT_32BIT;

case AUDIO_FORMAT_FLOAT_PLANAR:

return AUDIO_FORMAT_FLOAT;

}

return format;

uint8_t **data;

uint32_t frames;

long input_chs;

enum audio_format format;

uint32_t samples_per_sec;

uint64_t timestamp;

uint8_t* silent_buffer = NULL;

size_t silent_buffer_size = 0;

CRITICAL_SECTION settings_mutex;

obs_source_t *source;

/*asio device and info */

const char *device;

uint8_t device_index;

uint64_t first_ts; //first timestamp

uint32_t retry_limit;

bool device_timeout;

/* channels info */

DWORD input_channels; //total number of input channels

DWORD output_channels; // number of output channels of device (not used)

DWORD recorded_channels; // number of channels passed from device (including muted) to OBS; is at most 8

long route[MAX_AUDIO_CHANNELS]; // stores the channel re-ordering info

std::vector<short> unmuted_chs;

std::vector<short> muted_chs;

std::vector<long> required_signals;

//signals

WinHandle stop_listening_signal;

//WinHandle reconnectThread;

WinHandle captureThread;

bool isASIOActive = false;

bool reconnecting = false;

bool previouslyFailed = false;

bool useDeviceTiming = false;

std::string get_id() {

const void * address = static_cast<const void*>(source);

std::stringstream ss;

ss << "0x" << std::uppercase << (int)address;

std::string name = ss.str();

return name;

}

asio_data() : source(NULL), first_ts(0), device_index(-1) {

device_timeout = false;

retry_limit = 0;

InitializeCriticalSection(&settings_mutex);

memset(&route[0], -1, sizeof(long) * 8);

stop_listening_signal = CreateEvent(nullptr, true, false, nullptr);

}

~asio_data() {

DeleteCriticalSection(&settings_mutex);

if (silent_buffer)

free(silent_buffer);

}

bool disconnect() {

isASIOActive = false;

SetEvent(stop_listening_signal);

if (captureThread.Valid())

WaitForSingleObject(captureThread, INFINITE);

ResetEvent(stop_listening_signal);

return true;

}

bool render_audio(device_source_audio *asio_buffer, long route[], bool force_silent) {

struct obs_audio_info aoi;

obs_get_audio_info(&aoi);

int index = BASS_ASIO_GetDevice();

//blog(LOG_INFO, "dv index in render_audio is %i", index);

obs_source_audio out;

out.format = asio_buffer->format;

if (!is_audio_planar(out.format)) {

blog(LOG_ERROR, "that was a goof %i should be %i", out.format, get_planar_format(out.format));

return false;

}

if (out.format == AUDIO_FORMAT_UNKNOWN) {

blog(LOG_INFO, "unknown format");

return false;

}

out.frames = asio_buffer->frames;

out.samples_per_sec = asio_buffer->samples_per_sec;

out.timestamp = asio_buffer->timestamp;

if (!first_ts) {

first_ts = out.timestamp;

blog(LOG_INFO, "first timestamp");

return false;

}

//cache a silent buffer

size_t buffer_size = (out.frames * sizeof(bytedepth_format(out.format)));

if (silent_buffer_size < buffer_size) {

if (silent_buffer)

free(silent_buffer);

silent_buffer = (uint8_t*)calloc(buffer_size, sizeof(uint8_t));

silent_buffer_size = buffer_size;

blog(LOG_INFO, "caching silent buffer");

}

if (unmuted_chs.size() == 0) {

blog(LOG_INFO, "all chs muted");

return 0;

}

for (short i = 0; i < aoi.speakers; i++) {

if (route[i] >= 0 && route[i] < asio_buffer->input_chs && !force_silent) {

out.data[i] = asio_buffer->data[route[i]];

} else if (route[i] == -1) {

out.data[i] = silent_buffer;

} else {

out.data[i] = silent_buffer;

}

}

out.speakers = aoi.speakers;

obs_source_output_audio(source, &out);

//blog(LOG_DEBUG, "output frames %lu", buffer_size);

return true;

}

static std::vector<short> _get_muted_chs(long route_array[]) {

std::vector<short> silent_chs;

silent_chs.reserve(MAX_AUDIO_CHANNELS);

for (short i = 0; i < MAX_AUDIO_CHANNELS; i++) {

if (route_array[i] == -1)

silent_chs.push_back(i);

}

return silent_chs;

}

static std::vector<short> _get_unmuted_chs(long route_array[]) {

std::vector<short> unmuted_chs;

unmuted_chs.reserve(MAX_AUDIO_CHANNELS);

for (short i = 0; i < MAX_AUDIO_CHANNELS; i++) {

if (route_array[i] >= 0) {

unmuted_chs.push_back(i);

}

}

return unmuted_chs;

}

size_t write_index;

size_t buffer_count;

size_t buffer_size;

uint32_t frames;

long input_chs;

audio_format format;

//not in use...

WinHandle *receive_signals;

//create a square tick signal w/ two events

WinHandle all_received_signal;

WinHandle all_received_signal_2;

//to close out the device

WinHandle stop_listening_signal;

//tell listeners to to reinit

//WinHandle wait_for_reset_signal;

bool all_prepped = false;

bool buffer_prepped = false;

bool circle_buffer_prepped = false;

bool reallocate_buffer = false;

bool events_prepped = false;

circlebuf audio_buffer;

uint32_t samples_per_sec;

uint32_t retry_count;

const WinHandle * get_handles() {

return receive_signals;

}

WinHandle on_buffer() {

return all_received_signal;

}

long get_input_channels() {

return input_chs;

}

long device_index;

BASS_ASIO_DEVICEINFO device_info;

device_source_audio* get_writeable_source_audio() {

return (device_source_audio*)circlebuf_data(&audio_buffer,

write_index * sizeof(device_source_audio));

}

device_source_audio* get_source_audio(size_t index) {

return (device_source_audio*)circlebuf_data(&audio_buffer,

index * sizeof(device_source_audio));

}

device_data() {

all_prepped = false;

buffer_prepped = false;

circle_buffer_prepped = false;

reallocate_buffer = false;

events_prepped = false;

format = AUDIO_FORMAT_UNKNOWN;

write_index = 0;

buffer_count = 32;

retry_count = 0;

all_received_signal = CreateEvent(nullptr, true, false, nullptr);

all_received_signal_2 = CreateEvent(nullptr, true, true, nullptr);

stop_listening_signal = CreateEvent(nullptr, true, false, nullptr);

}

device_data(size_t buffers, audio_format audioformat) {

all_prepped = false;

buffer_prepped = false;

circle_buffer_prepped = false;

reallocate_buffer = false;

events_prepped = false;

format = audioformat;

write_index = 0;

buffer_count = buffers ? buffers : 32;

retry_count = 0;

all_received_signal = CreateEvent(nullptr, true, false, nullptr);

all_received_signal_2 = CreateEvent(nullptr, true, true, nullptr);

stop_listening_signal = CreateEvent(nullptr, true, false, nullptr);

}

~device_data() {

//free resources?

if (all_prepped) {

delete receive_signals;

for (int i = 0; i < buffer_count; i++) {

device_source_audio* _source_audio = get_source_audio(i);

int input_chs = _source_audio->input_chs;

for (int j = 0; j < input_chs; j++) {

if (_source_audio->data[j]) {

bfree(_source_audio->data[j]);

}

}

bfree(_source_audio->data);

}

circlebuf_free(&audio_buffer);

}

}

//check that all the required device settings have been set

void check_all() {

if (buffer_prepped && circle_buffer_prepped && events_prepped) {

all_prepped = true;

} else {

all_prepped = false;

}

}

void prep_circle_buffer(BASS_ASIO_INFO &info) {

prep_circle_buffer(info.bufpref);

}

void prep_circle_buffer(DWORD bufpref) {

if (!circle_buffer_prepped) {

//create a buffer w/ a minimum of 4 slots and a target of a fraction of 2048 samples

buffer_count = max(4, ceil(2048 / bufpref));

circlebuf_init(&audio_buffer);

circlebuf_reserve(&audio_buffer, buffer_count * sizeof(device_source_audio));

for (int i = 0; i < buffer_count; i++) {

circlebuf_push_back(&audio_buffer, &device_source_audio(), sizeof(device_source_audio));

//initialize # of buffers

}

circle_buffer_prepped = true;

}

}

void prep_events(BASS_ASIO_INFO &info) {

prep_events(info.inputs);

}

void prep_events(long input_chs) {

if (!events_prepped) {

receive_signals = (WinHandle*)calloc(input_chs, sizeof(WinHandle));

for (int i = 0; i < input_chs; i++) {

receive_signals[i] = CreateEvent(nullptr, true, false, nullptr);

}

events_prepped = true;

}

}

void re_prep_buffers() {

all_prepped = false;

buffer_prepped = false;

BASS_ASIO_INFO info;

bool ret = BASS_ASIO_GetInfo(&info);

prep_buffers(info, format, samples_per_sec);

}

void re_prep_buffers(BASS_ASIO_INFO &info) {

all_prepped = false;

prep_buffers(info, format, samples_per_sec);

}

void update_sample_rate(uint32_t in_samples_per_sec) {

all_prepped = false;

this->samples_per_sec = in_samples_per_sec;

check_all();

}

void prep_buffers(BASS_ASIO_INFO &info, audio_format in_format, uint32_t in_samples_per_sec) {

prep_buffers(info.bufpref, info.inputs, in_format, in_samples_per_sec);

}

void prep_buffers(uint32_t frames, long in_chs, audio_format format, uint32_t samples_per_sec) {

if (frames * bytedepth_format(format) > this->buffer_size) {

if (buffer_prepped) {

reallocate_buffer = true;

}

} else {

reallocate_buffer = false;

}

prep_events(in_chs);

if (circle_buffer_prepped && (!buffer_prepped || reallocate_buffer)) {

this->frames = frames;

this->input_chs = in_chs;

this->format = format;

this->samples_per_sec = samples_per_sec;

this->buffer_size = frames * bytedepth_format(format);

for (int i = 0; i < buffer_count; i++) {

device_source_audio* _source_audio = get_source_audio(i);

_source_audio->data = (uint8_t **)bzalloc(input_chs * sizeof(uint8_t*))/*calloc(input_chs, sizeof(uint8_t*))*/;

for (int j = 0; j < input_chs; j++) {

if (!buffer_prepped) {

_source_audio->data[j] = (uint8_t*)bzalloc(buffer_size)/*calloc(buffer_size, 1)*/;

} else if (reallocate_buffer) {

uint8_t* tmp = (uint8_t*)realloc(_source_audio->data[j], buffer_size);

if (tmp == NULL) {

buffer_prepped = false;

all_prepped = false;

return;

} else if (tmp == _source_audio->data[j]) {

free(tmp);

tmp = NULL;

} else {

_source_audio->data[j] = tmp;

tmp = NULL;

}

}

}

_source_audio->input_chs = input_chs;

_source_audio->frames = frames;

_source_audio->format = format;

_source_audio->samples_per_sec = samples_per_sec;

}

buffer_prepped = true;

}

check_all();

}

void write_buffer_interleaved(void* buffer, DWORD BufSize) {

if (!all_prepped) {

blog(LOG_INFO, "%s device %i is not prepared", __FUNCTION__, device_index);

return;

}

ResetEvent(all_received_signal);

SetEvent(all_received_signal_2);

//get as much information from the device that called this function

BASS_ASIO_INFO info;

bool ret = BASS_ASIO_GetInfo(&info);

uint8_t * input_buffer = (uint8_t*)buffer;

size_t ch_buffer_size = BufSize / info.inputs;

if (ch_buffer_size > buffer_size) {

blog(LOG_WARNING, "%s device needs to reallocate memory");

}

int byte_depth = bytedepth_format(format);

size_t interleaved_frame_size = info.inputs * byte_depth;

//calculate on the spot

size_t frames_count = BufSize / interleaved_frame_size;

//use cached value

//size_t frames_count = frames;

device_source_audio* _source_audio = get_writeable_source_audio();

if (!_source_audio) {

blog(LOG_INFO, "%s _source_audio = NULL", __FUNCTION__);

return;

}

audio_format planar_format = get_planar_format(format);

//deinterleave directly into buffer (planar)

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

for (size_t j = 0; j < info.inputs; j++) {

memcpy(_source_audio->data[j] + (i * byte_depth), input_buffer + (j * byte_depth) + (i * interleaved_frame_size), byte_depth);

}

}

_source_audio->format = planar_format;

_source_audio->frames = frames_count;

_source_audio->input_chs = info.inputs;

_source_audio->samples_per_sec = samples_per_sec;

_source_audio->timestamp = _source_audio->timestamp = os_gettime_ns() - ((_source_audio->frames * NSEC_PER_SEC) / _source_audio->samples_per_sec);

write_index++;

write_index = write_index % buffer_count;

SetEvent(all_received_signal);

ResetEvent(all_received_signal_2);

}

static DWORD WINAPI capture_thread(void *data) {

listener_pair *pair = static_cast<listener_pair*>(data);

asio_data *source = pair->asio_listener;//static_cast<asio_data*>(data);

device_data *device = pair->device;//static_cast<device_data*>(data);

struct obs_audio_info aoi;

obs_get_audio_info(&aoi);

std::string thread_name = "asio capture: ";//source->device;

thread_name += source->get_id();

thread_name += ":";

thread_name += device->device_info.name;//thread_name += " capture thread";

os_set_thread_name(thread_name.c_str());

HANDLE signals_1[3] = { device->all_received_signal, device->stop_listening_signal, source->stop_listening_signal };

HANDLE signals_2[3] = { device->all_received_signal_2, device->stop_listening_signal, source->stop_listening_signal };

long route[MAX_AUDIO_CHANNELS];

for (short i = 0; i < aoi.speakers; i++) {

route[i] = source->route[i];

}

source->isASIOActive = true;

ResetEvent(source->stop_listening_signal);

blog(LOG_INFO, "listener for device %lu created: source: %x", device->device_index, source->get_id());

size_t read_index = device->write_index;//0;

int waitResult;

uint64_t buffer_time = ((device->frames * NSEC_PER_SEC) / device->samples_per_sec);

DWORD wait_time = DWORD((buffer_time / 1000000L) * 8);

blog(LOG_INFO, "device %lu wait_time=%d", device->device_index, wait_time);

while (source && device) {

DWORD ms = source->device_timeout ? wait_time : INFINITE;

waitResult = WaitForMultipleObjects(3, signals_1, false, ms);

waitResult = WaitForMultipleObjects(3, signals_2, false, ms);

//not entirely sure that all of these conditions are correct (at the very least this is)

if (waitResult == WAIT_OBJECT_0 || waitResult == WAIT_TIMEOUT) {

if (waitResult == WAIT_TIMEOUT) {

// In case of timeout increment the retry_count

device->retry_count++;

if (source->retry_limit != -1 && device->retry_count > source->retry_limit) {

// We reached our retry_limit :(

blog(LOG_INFO, "%s closing due to timeout, device %lu WAIT_TIMEOUT retry_count=%u retry_limit=%u", thread_name.c_str(), device->device_index, device->retry_count, source->retry_limit);

delete pair;

return 0;

}

} else if (device->retry_count >= 1) {

// waitResult is now WAIT_OBJECT_0 after some WAIT_TIMEOUT occurred, reset the retry_count to zero

device->retry_count = 0;

}

while (read_index != device->write_index) {

device_source_audio* in = device->get_source_audio(read_index);//device->get_writeable_source_audio();

source->render_audio(in, route, waitResult == WAIT_TIMEOUT);

read_index++;

read_index = read_index % device->buffer_count;

}

if (source->device_index != device->device_index) {

blog(LOG_INFO, "source device index %lu is not device index %lu", source->device_index, device->device_index);

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

} else if (!source->isASIOActive) {

blog(LOG_INFO, "%x indicated it wanted to disconnect", source->get_id());

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

}

} else if (waitResult == WAIT_OBJECT_0 + 1) {

blog(LOG_INFO, "device %l indicated it wanted to disconnect", device->device_index);

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

} else if (waitResult == WAIT_OBJECT_0 + 2) {

blog(LOG_INFO, "%x indicated it wanted to disconnect", source->get_id());

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

} else if (waitResult == WAIT_ABANDONED_0) {

blog(LOG_INFO, "a mutex for %s was abandoned while listening to", thread_name.c_str(), device->device_index);

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

} else if (waitResult == WAIT_ABANDONED_0 + 1) {

blog(LOG_INFO, "a mutex for %s was abandoned while listening to", thread_name.c_str(), device->device_index);

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

} else if (waitResult == WAIT_ABANDONED_0 + 2) {

blog(LOG_INFO, "a mutex for %s was abandoned while listening to", thread_name.c_str(), device->device_index);

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

} else if (waitResult == WAIT_FAILED) {

blog(LOG_INFO, "listener thread wait %lu failed with 0x%x", device->device_index, GetLastError());

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

} else {

blog(LOG_INFO, "unexpected wait result = %i", waitResult);

blog(LOG_INFO, "%s closing", thread_name.c_str());

delete pair;

return 0;

}

}

delete pair;

return 0;

}

//adds a listener thread between an asio_data object and this device

void add_listener(asio_data *listener) {

if (!all_prepped) {

return;

}

listener_pair* parameters = new listener_pair();

parameters->asio_listener = listener;

parameters->device = this;

blog(LOG_INFO, "disconnecting any previous connections (source_id: %x)", listener->get_id());

listener->disconnect();

//CloseHandle(listener->captureThread);

blog(LOG_INFO, "adding listener for %lu (source: %lu)", device_index, listener->device_index);

listener->captureThread = CreateThread(nullptr, 0, this->capture_thread, parameters, 0, nullptr);

}

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

struct obs_audio_info aoi;

obs_get_audio_info(&aoi);

DWORD recorded_channels = get_audio_channels(aoi.speakers);

return recorded_channels;

uint8_t a, count = 0;

BASS_ASIO_DEVICEINFO info;

for (a = 0; BASS_ASIO_GetDeviceInfo(a, &info); a++) {

blog(LOG_INFO, "device index is : %i and name is : %s", a, info.name);

count++;

}

return count;

int res;

BASS_ASIO_SetUnicode(false);

BASS_ASIO_DEVICEINFO info;

bool ret;

uint32_t i;

for (i = 0; BASS_ASIO_GetDeviceInfo(i, &info); i++) {

res = strcmp(info.name, device_info_name);

if (res == 0) {

return i;

}

}

return -1;

uint32_t i;

for (i = 0; i < device_list.size(); i++) {

if (strcmp(device_list[i]->device_info.name, device_info.name) == 0) {

return i;

}

}

return -1;

obs_property_t *property, void *data) {

if (!BASS_ASIO_ControlPanel()) {

switch (BASS_ASIO_ErrorGetCode()) {

case BASS_ERROR_INIT:

blog(LOG_ERROR, "Init not called\n");

break;

case BASS_ERROR_UNKNOWN:

blog(LOG_ERROR, "Unknown error\n");

}

return false;

} else {

int device_index = BASS_ASIO_GetDevice();

BASS_ASIO_INFO info;

BASS_ASIO_GetInfo(&info);

blog(LOG_INFO, "Console loaded for device %s with index %i\n",

info.name, device_index);

}

return true;

int res;

BASS_ASIO_SetUnicode(false);

BASS_ASIO_DEVICEINFO devinfo;

bool ret;

//int numOfDevices = getDeviceCount();

uint32_t i;

for (i = 0; BASS_ASIO_GetDeviceInfo(i, &devinfo); i++) {

obs_property_list_add_string(list, devinfo.name, devinfo.name);

/* the device list includes all drivers in registry.

ret = BASS_ASIO_Init(i, BASS_ASIO_THREAD);

if (!ret) {

res = BASS_ASIO_ErrorGetCode();

switch (res) {

case BASS_ERROR_DEVICE:

blog(LOG_ERROR, "The device number specified is invalid.\n");

break;

case BASS_ERROR_ALREADY:

blog(LOG_ERROR, "The device has already been initialized\n");

break;

case BASS_ERROR_DRIVER:

blog(LOG_ERROR, "The driver could not be initialized\n");

break;

}

/* Disable entry if device is not connected (BASS_ERROR_DRIVER)

if (res != BASS_ERROR_ALREADY)

obs_property_list_item_disable(list, i, true);

} else {

ret = BASS_ASIO_Free();

if (!ret)

blog(LOG_ERROR, "Should never have reached here, wtf uh oh.\n");

}

}

BASS_ASIO_INFO info;

bool ret = BASS_ASIO_GetInfo(&info);

BASS_ASIO_DEVICEINFO devinfo;

int index = BASS_ASIO_GetDevice();

ret = BASS_ASIO_GetDeviceInfo(index, &devinfo);

if (!ret) {

blog(LOG_ERROR, "Unable to retrieve info on the current driver \n"

"error number is : %i \n; check BASS_ASIO_ErrorGetCode\n",

BASS_ASIO_ErrorGetCode());

}

// DEBUG: check that the current device in bass thread is the correct one

// once code is fine the check can be removed

const char* device = obs_data_get_string(settings, "device_id");

if (ret && strcmp(device, devinfo.name) != 0) {

blog(LOG_ERROR, "Device loaded is not the one in settings\n");

}

//get the device info

DWORD input_channels = ret ? info.inputs : 0;

obs_property_list_clear(list);

obs_property_list_add_int(list, "mute", -1);

BASS_ASIO_CHANNELINFO ch_info;

for (DWORD i = 0; i < input_channels; i++) {

BASS_ASIO_ChannelGetInfo(1, i, &ch_info);

std::string test = info.name;

test = test + " " + std::to_string(i);

test = test + " " + ch_info.name;

obs_property_list_add_int(list, test.c_str(), i);

}

return true;

BASS_ASIO_DEVICEINFO devinfo;

int index = BASS_ASIO_GetDevice();

bool ret = BASS_ASIO_GetDeviceInfo(index, &devinfo);

bool ret2;

if (!ret) {

blog(LOG_ERROR, "Unable to retrieve info on the current driver \n"

"error number is : %i \n; check BASS_ASIO_ErrorGetCode\n",

BASS_ASIO_ErrorGetCode());

}

// DEBUG: check that the current device in bass thread is the correct one

// once code is fine the check can be removed

const char* device = obs_data_get_string(settings, "device_id");

if (ret && strcmp(device, devinfo.name) != 0) {

blog(LOG_ERROR, "Device loaded is not the one in settings\n");

}

obs_property_list_clear(list);

//get the device info

if (ret)

ret2 = BASS_ASIO_CheckRate(44100);

if (ret2) {

std::string rate = "44100 Hz";

char* cstr = new char[rate.length() + 1];

strcpy(cstr, rate.c_str());

obs_property_list_add_int(list, cstr, 44100);

delete cstr;

} else {

blog(LOG_INFO, "Device loaded does not support 44100 Hz sample rate\n");

}

if (ret)

ret2 = BASS_ASIO_CheckRate(48000);

if (ret2) {

std::string rate = "48000 Hz";

char* cstr = new char[rate.length() + 1];

strcpy(cstr, rate.c_str());

obs_property_list_add_int(list, cstr, 48000);

delete cstr;

} else {

blog(LOG_INFO, "Device loaded does not support 48000 Hz sample rate\n");

}

return true;

BASS_ASIO_DEVICEINFO devinfo;

int index = BASS_ASIO_GetDevice();

bool ret = BASS_ASIO_GetDeviceInfo(index, &devinfo);

bool ret2;

if (!ret) {

blog(LOG_ERROR, "Unable to retrieve info on the current driver \n"

"error number is : %i \n; check BASS_ASIO_ErrorGetCode\n",

BASS_ASIO_ErrorGetCode());

}

// DEBUG: check that the current device in bass thread is the correct one

// once code is fine the check can be removed

const char* device = obs_data_get_string(settings, "device_id");

if (ret && strcmp(device, devinfo.name) != 0) {

blog(LOG_ERROR, "Device loaded is not the one in settings\n");

}

//get the device channel info

BASS_ASIO_CHANNELINFO channelInfo;

if (ret)

ret2 = BASS_ASIO_ChannelGetInfo(true, 0, &channelInfo);

if (!ret2) {

blog(LOG_ERROR, "Unable to retrieve channel info on the current driver \n"

"error number is : %i \n; check BASS_ASIO_ErrorGetCode\n",

BASS_ASIO_ErrorGetCode());

}

obs_property_list_clear(list);

//these settings are ignored, optimal is picked between float and native for least

//amount of processing possible

if (ret && ret2) {

if (channelInfo.format == BASS_ASIO_FORMAT_16BIT) {

obs_property_list_add_int(list, "16 bit (native)", AUDIO_FORMAT_16BIT);

obs_property_list_add_int(list, "32 bit", AUDIO_FORMAT_32BIT);

obs_property_list_add_int(list, "32 bit float", AUDIO_FORMAT_FLOAT);

} else if (channelInfo.format == BASS_ASIO_FORMAT_32BIT) {

obs_property_list_add_int(list, "16 bit", AUDIO_FORMAT_16BIT);

obs_property_list_add_int(list, "32 bit (native)", AUDIO_FORMAT_32BIT);

obs_property_list_add_int(list, "32 bit float", AUDIO_FORMAT_FLOAT);

} else if (channelInfo.format == BASS_ASIO_FORMAT_FLOAT) {

obs_property_list_add_int(list, "16 bit", AUDIO_FORMAT_16BIT);

obs_property_list_add_int(list, "32 bit", AUDIO_FORMAT_32BIT);

obs_property_list_add_int(list, "32 bit float (native)", AUDIO_FORMAT_FLOAT);

} else {

blog(LOG_ERROR, "Your device uses unsupported bit depth.\n"

"Only 16 bit, 32 bit signed int and 32 bit float are supported.\n"

"Change accordingly your device settings.\n"

"Forcing bit depth to 32 bit float");

obs_property_list_add_int(list, "32 bit float", AUDIO_FORMAT_FLOAT);

return false;

}

return true;

}

return false;

BASS_ASIO_INFO info;

bool ret = BASS_ASIO_GetInfo(&info);

if (!ret) {

blog(LOG_ERROR, "Unable to retrieve info on the current driver \n"

"error number is : %i \n; check BASS_ASIO_ErrorGetCode\n",

BASS_ASIO_ErrorGetCode());

}

obs_property_list_clear(list);

if (ret) {

if (info.bufgran == -1) {

long long gran_buffer = info.bufmin;

while (gran_buffer <= info.bufmax) {

int n = snprintf(NULL, 0, "%llu%s", gran_buffer, (gran_buffer == info.bufpref ? " (preferred)" : ""));