diff --git a/audio/audio_driver.c b/audio/audio_driver.c index 824fc36e75..22bd5a9e65 100644 --- a/audio/audio_driver.c +++ b/audio/audio_driver.c @@ -63,15 +63,6 @@ typedef struct audio_driver_input_data uint64_t buffer_free_samples_count; } audio_driver_input_data_t; -static bool audio_active; -static bool audio_data_own; -static const rarch_resampler_t *audio_resampler; -static void *audio_resampler_data; -static const audio_driver_t *current_audio; -static void *context_audio_data; - -static audio_driver_input_data_t audio_data; - static const audio_driver_t *audio_drivers[] = { #ifdef HAVE_ALSA &audio_alsa, @@ -135,6 +126,15 @@ static const audio_driver_t *audio_drivers[] = { NULL, }; +static bool audio_driver_active; +static bool audio_driver_data_own; +static const rarch_resampler_t *audio_driver_resampler; +static void *audio_driver_resampler_data; +static const audio_driver_t *current_audio; +static void *audio_driver_context_audio_data; + +static audio_driver_input_data_t audio_driver_data; + /** * compute_audio_buffer_statistics: * @@ -147,35 +147,35 @@ static void compute_audio_buffer_statistics(void) float avg_filled, deviation; uint64_t accum = 0, accum_var = 0; unsigned low_water_count = 0, high_water_count = 0; - unsigned samples = min(audio_data.buffer_free_samples_count, + unsigned samples = min(audio_driver_data.buffer_free_samples_count, AUDIO_BUFFER_FREE_SAMPLES_COUNT); if (samples < 3) return; for (i = 1; i < samples; i++) - accum += audio_data.buffer_free_samples[i]; + accum += audio_driver_data.buffer_free_samples[i]; avg = accum / (samples - 1); for (i = 1; i < samples; i++) { - int diff = avg - audio_data.buffer_free_samples[i]; + int diff = avg - audio_driver_data.buffer_free_samples[i]; accum_var += diff * diff; } stddev = (unsigned)sqrt((double)accum_var / (samples - 2)); - avg_filled = 1.0f - (float)avg / audio_data.driver_buffer_size; - deviation = (float)stddev / audio_data.driver_buffer_size; + avg_filled = 1.0f - (float)avg / audio_driver_data.driver_buffer_size; + deviation = (float)stddev / audio_driver_data.driver_buffer_size; - low_water_size = audio_data.driver_buffer_size * 3 / 4; - high_water_size = audio_data.driver_buffer_size / 4; + low_water_size = audio_driver_data.driver_buffer_size * 3 / 4; + high_water_size = audio_driver_data.driver_buffer_size / 4; for (i = 1; i < samples; i++) { - if (audio_data.buffer_free_samples[i] >= low_water_size) + if (audio_driver_data.buffer_free_samples[i] >= low_water_size) low_water_count++; - else if (audio_data.buffer_free_samples[i] <= high_water_size) + else if (audio_driver_data.buffer_free_samples[i] <= high_water_size) high_water_count++; } @@ -233,40 +233,40 @@ static bool uninit_audio(void) { settings_t *settings = config_get_ptr(); - if (context_audio_data && current_audio) - current_audio->free(context_audio_data); + if (audio_driver_context_audio_data && current_audio) + current_audio->free(audio_driver_context_audio_data); - if (audio_data.conv_outsamples) - free(audio_data.conv_outsamples); - audio_data.conv_outsamples = NULL; - audio_data.data_ptr = 0; + if (audio_driver_data.conv_outsamples) + free(audio_driver_data.conv_outsamples); + audio_driver_data.conv_outsamples = NULL; + audio_driver_data.data_ptr = 0; - if (audio_data.rewind_buf) - free(audio_data.rewind_buf); - audio_data.rewind_buf = NULL; + if (audio_driver_data.rewind_buf) + free(audio_driver_data.rewind_buf); + audio_driver_data.rewind_buf = NULL; if (!settings->audio.enable) { - audio_active = false; + audio_driver_active = false; return false; } - rarch_resampler_freep(&audio_resampler, - &audio_resampler_data); + rarch_resampler_freep(&audio_driver_resampler, + &audio_driver_resampler_data); - if (audio_data.audio_callback.callback) + if (audio_driver_data.audio_callback.callback) { - audio_data.audio_callback.callback = NULL; - audio_data.audio_callback.set_state = NULL; + audio_driver_data.audio_callback.callback = NULL; + audio_driver_data.audio_callback.set_state = NULL; } - if (audio_data.data) - free(audio_data.data); - audio_data.data = NULL; + if (audio_driver_data.data) + free(audio_driver_data.data); + audio_driver_data.data = NULL; - if (audio_data.outsamples) - free(audio_data.outsamples); - audio_data.outsamples = NULL; + if (audio_driver_data.outsamples) + free(audio_driver_data.outsamples); + audio_driver_data.outsamples = NULL; event_command(EVENT_CMD_DSP_FILTER_DEINIT); @@ -274,8 +274,8 @@ static bool uninit_audio(void) current_audio = NULL; - if (!audio_data_own) - context_audio_data = NULL; + if (!audio_driver_data_own) + audio_driver_context_audio_data = NULL; return true; } @@ -288,7 +288,7 @@ static bool init_audio(void) audio_convert_init_simd(); /* Resource leaks will follow if audio is initialized twice. */ - if (context_audio_data) + if (audio_driver_context_audio_data) return false; /* Accomodate rewind since at some point we might have two full buffers. */ @@ -296,38 +296,38 @@ static bool init_audio(void) settings->slowmotion_ratio; /* Used for recording even if audio isn't enabled. */ - retro_assert(audio_data.conv_outsamples = + retro_assert(audio_driver_data.conv_outsamples = (int16_t*)malloc(outsamples_max * sizeof(int16_t))); - if (!audio_data.conv_outsamples) + if (!audio_driver_data.conv_outsamples) goto error; - audio_data.block_chunk_size = AUDIO_CHUNK_SIZE_BLOCKING; - audio_data.nonblock_chunk_size = AUDIO_CHUNK_SIZE_NONBLOCKING; - audio_data.chunk_size = audio_data.block_chunk_size; + audio_driver_data.block_chunk_size = AUDIO_CHUNK_SIZE_BLOCKING; + audio_driver_data.nonblock_chunk_size = AUDIO_CHUNK_SIZE_NONBLOCKING; + audio_driver_data.chunk_size = audio_driver_data.block_chunk_size; /* Needs to be able to hold full content of a full max_bufsamples * in addition to its own. */ - retro_assert(audio_data.rewind_buf = (int16_t*) + retro_assert(audio_driver_data.rewind_buf = (int16_t*) malloc(max_bufsamples * sizeof(int16_t))); - if (!audio_data.rewind_buf) + if (!audio_driver_data.rewind_buf) goto error; - audio_data.rewind_size = max_bufsamples; + audio_driver_data.rewind_size = max_bufsamples; if (!settings->audio.enable) { - audio_active = false; + audio_driver_active = false; return false; } audio_driver_ctl(RARCH_AUDIO_CTL_FIND_DRIVER, NULL); #ifdef HAVE_THREADS - if (audio_data.audio_callback.callback) + if (audio_driver_data.audio_callback.callback) { RARCH_LOG("Starting threaded audio driver ...\n"); - if (!rarch_threaded_audio_init(¤t_audio, &context_audio_data, + if (!rarch_threaded_audio_init(¤t_audio, &audio_driver_context_audio_data, *settings->audio.device ? settings->audio.device : NULL, settings->audio.out_rate, settings->audio.latency, current_audio)) @@ -339,74 +339,74 @@ static bool init_audio(void) else #endif { - context_audio_data = current_audio->init(*settings->audio.device ? + audio_driver_context_audio_data = current_audio->init(*settings->audio.device ? settings->audio.device : NULL, settings->audio.out_rate, settings->audio.latency); } - if (!context_audio_data) + if (!audio_driver_context_audio_data) { RARCH_ERR("Failed to initialize audio driver. Will continue without audio.\n"); - audio_active = false; + audio_driver_active = false; } - audio_data.use_float = false; - if (audio_active && current_audio->use_float(context_audio_data)) - audio_data.use_float = true; + audio_driver_data.use_float = false; + if (audio_driver_active && current_audio->use_float(audio_driver_context_audio_data)) + audio_driver_data.use_float = true; - if (!settings->audio.sync && audio_active) + if (!settings->audio.sync && audio_driver_active) { event_command(EVENT_CMD_AUDIO_SET_NONBLOCKING_STATE); - audio_data.chunk_size = audio_data.nonblock_chunk_size; + audio_driver_data.chunk_size = audio_driver_data.nonblock_chunk_size; } - if (audio_data.in_rate <= 0.0f) + if (audio_driver_data.in_rate <= 0.0f) { /* Should never happen. */ RARCH_WARN("Input rate is invalid (%.3f Hz). Using output rate (%u Hz).\n", - audio_data.in_rate, settings->audio.out_rate); - audio_data.in_rate = settings->audio.out_rate; + audio_driver_data.in_rate, settings->audio.out_rate); + audio_driver_data.in_rate = settings->audio.out_rate; } - audio_data.orig_src_ratio = audio_data.src_ratio = - (double)settings->audio.out_rate / audio_data.in_rate; + audio_driver_data.orig_src_ratio = audio_driver_data.src_ratio = + (double)settings->audio.out_rate / audio_driver_data.in_rate; - if (!rarch_resampler_realloc(&audio_resampler_data, - &audio_resampler, - settings->audio.resampler, audio_data.orig_src_ratio)) + if (!rarch_resampler_realloc(&audio_driver_resampler_data, + &audio_driver_resampler, + settings->audio.resampler, audio_driver_data.orig_src_ratio)) { RARCH_ERR("Failed to initialize resampler \"%s\".\n", settings->audio.resampler); - audio_active = false; + audio_driver_active = false; } - retro_assert(audio_data.data = (float*) + retro_assert(audio_driver_data.data = (float*) malloc(max_bufsamples * sizeof(float))); - if (!audio_data.data) + if (!audio_driver_data.data) goto error; - audio_data.data_ptr = 0; + audio_driver_data.data_ptr = 0; retro_assert(settings->audio.out_rate < - audio_data.in_rate * AUDIO_MAX_RATIO); - retro_assert(audio_data.outsamples = (float*) + audio_driver_data.in_rate * AUDIO_MAX_RATIO); + retro_assert(audio_driver_data.outsamples = (float*) malloc(outsamples_max * sizeof(float))); - if (!audio_data.outsamples) + if (!audio_driver_data.outsamples) goto error; - audio_data.rate_control = false; - if (!audio_data.audio_callback.callback && audio_active && + audio_driver_data.rate_control = false; + if (!audio_driver_data.audio_callback.callback && audio_driver_active && settings->audio.rate_control) { /* Audio rate control requires write_avail * and buffer_size to be implemented. */ if (current_audio->buffer_size) { - audio_data.driver_buffer_size = - current_audio->buffer_size(context_audio_data); - audio_data.rate_control = true; + audio_driver_data.driver_buffer_size = + current_audio->buffer_size(audio_driver_context_audio_data); + audio_driver_data.rate_control = true; } else RARCH_WARN("Audio rate control was desired, but driver does not support needed features.\n"); @@ -414,11 +414,11 @@ static bool init_audio(void) event_command(EVENT_CMD_DSP_FILTER_INIT); - audio_data.buffer_free_samples_count = 0; + audio_driver_data.buffer_free_samples_count = 0; /* Threaded driver is initially stopped. */ - if (audio_active && !settings->audio.mute_enable && - audio_data.audio_callback.callback) + if (audio_driver_active && !settings->audio.mute_enable && + audio_driver_data.audio_callback.callback) audio_driver_ctl(RARCH_AUDIO_CTL_START, NULL); return true; @@ -435,37 +435,37 @@ error: static void audio_driver_readjust_input_rate(void) { settings_t *settings = config_get_ptr(); - unsigned write_idx = audio_data.buffer_free_samples_count++ & + unsigned write_idx = audio_driver_data.buffer_free_samples_count++ & (AUDIO_BUFFER_FREE_SAMPLES_COUNT - 1); - int half_size = audio_data.driver_buffer_size / 2; - int avail = current_audio->write_avail(context_audio_data); + int half_size = audio_driver_data.driver_buffer_size / 2; + int avail = current_audio->write_avail(audio_driver_context_audio_data); int delta_mid = avail - half_size; double direction = (double)delta_mid / half_size; double adjust = 1.0 + settings->audio.rate_control_delta * direction; #if 0 RARCH_LOG_OUTPUT("Audio buffer is %u%% full\n", - (unsigned)(100 - (avail * 100) / audio_data.driver_buffer_size)); + (unsigned)(100 - (avail * 100) / audio_driver_data.driver_buffer_size)); #endif - audio_data.buffer_free_samples[write_idx] = avail; - audio_data.src_ratio = audio_data.orig_src_ratio * adjust; + audio_driver_data.buffer_free_samples[write_idx] = avail; + audio_driver_data.src_ratio = audio_driver_data.orig_src_ratio * adjust; #if 0 RARCH_LOG_OUTPUT("New rate: %lf, Orig rate: %lf\n", - audio_data.src_ratio, audio_data.orig_src_ratio); + audio_driver_data.src_ratio, audio_driver_data.orig_src_ratio); #endif } void audio_driver_set_nonblocking_state(bool enable) { settings_t *settings = config_get_ptr(); - if (audio_active && context_audio_data) - current_audio->set_nonblock_state(context_audio_data, + if (audio_driver_active && audio_driver_context_audio_data) + current_audio->set_nonblock_state(audio_driver_context_audio_data, settings->audio.sync ? enable : true); - audio_data.chunk_size = enable ? audio_data.nonblock_chunk_size : - audio_data.block_chunk_size; + audio_driver_data.chunk_size = enable ? audio_driver_data.nonblock_chunk_size : + audio_driver_data.block_chunk_size; } /** @@ -499,26 +499,26 @@ static bool audio_driver_flush(const int16_t *data, size_t samples) if (is_paused || settings->audio.mute_enable) return true; - if (!audio_active || !audio_data.data) + if (!audio_driver_active || !audio_driver_data.data) return false; rarch_perf_init(&audio_convert_s16, "audio_convert_s16"); retro_perf_start(&audio_convert_s16); - audio_convert_s16_to_float(audio_data.data, data, samples, - audio_data.volume_gain); + audio_convert_s16_to_float(audio_driver_data.data, data, samples, + audio_driver_data.volume_gain); retro_perf_stop(&audio_convert_s16); - src_data.data_in = audio_data.data; + src_data.data_in = audio_driver_data.data; src_data.input_frames = samples >> 1; - dsp_data.input = audio_data.data; + dsp_data.input = audio_driver_data.data; dsp_data.input_frames = samples >> 1; - if (audio_data.dsp) + if (audio_driver_data.dsp) { rarch_perf_init(&audio_dsp, "audio_dsp"); retro_perf_start(&audio_dsp); - rarch_dsp_filter_process(audio_data.dsp, &dsp_data); + rarch_dsp_filter_process(audio_driver_data.dsp, &dsp_data); retro_perf_stop(&audio_dsp); if (dsp_data.output) @@ -528,12 +528,12 @@ static bool audio_driver_flush(const int16_t *data, size_t samples) } } - src_data.data_out = audio_data.outsamples; + src_data.data_out = audio_driver_data.outsamples; - if (audio_data.rate_control) + if (audio_driver_data.rate_control) audio_driver_readjust_input_rate(); - src_data.ratio = audio_data.src_ratio; + src_data.ratio = audio_driver_data.src_ratio; rarch_main_ctl(RARCH_MAIN_CTL_IS_SLOWMOTION, &is_slowmotion); @@ -542,27 +542,28 @@ static bool audio_driver_flush(const int16_t *data, size_t samples) rarch_perf_init(&resampler_proc, "resampler_proc"); retro_perf_start(&resampler_proc); - rarch_resampler_process(audio_resampler, audio_resampler_data, &src_data); + rarch_resampler_process(audio_driver_resampler, audio_driver_resampler_data, &src_data); retro_perf_stop(&resampler_proc); - output_data = audio_data.outsamples; + output_data = audio_driver_data.outsamples; output_frames = src_data.output_frames; - if (!audio_data.use_float) + if (!audio_driver_data.use_float) { rarch_perf_init(&audio_convert_float, "audio_convert_float"); retro_perf_start(&audio_convert_float); - audio_convert_float_to_s16(audio_data.conv_outsamples, + audio_convert_float_to_s16(audio_driver_data.conv_outsamples, (const float*)output_data, output_frames * 2); retro_perf_stop(&audio_convert_float); - output_data = audio_data.conv_outsamples; + output_data = audio_driver_data.conv_outsamples; output_size = sizeof(int16_t); } - if (current_audio->write(context_audio_data, output_data, output_frames * output_size * 2) < 0) + if (current_audio->write(audio_driver_context_audio_data, + output_data, output_frames * output_size * 2) < 0) { - audio_active = false; + audio_driver_active = false; return false; } @@ -578,15 +579,15 @@ static bool audio_driver_flush(const int16_t *data, size_t samples) **/ void audio_driver_sample(int16_t left, int16_t right) { - audio_data.conv_outsamples[audio_data.data_ptr++] = left; - audio_data.conv_outsamples[audio_data.data_ptr++] = right; + audio_driver_data.conv_outsamples[audio_driver_data.data_ptr++] = left; + audio_driver_data.conv_outsamples[audio_driver_data.data_ptr++] = right; - if (audio_data.data_ptr < audio_data.chunk_size) + if (audio_driver_data.data_ptr < audio_driver_data.chunk_size) return; - audio_driver_flush(audio_data.conv_outsamples, audio_data.data_ptr); + audio_driver_flush(audio_driver_data.conv_outsamples, audio_driver_data.data_ptr); - audio_data.data_ptr = 0; + audio_driver_data.data_ptr = 0; } /** @@ -619,8 +620,8 @@ size_t audio_driver_sample_batch(const int16_t *data, size_t frames) **/ void audio_driver_sample_rewind(int16_t left, int16_t right) { - audio_data.rewind_buf[--audio_data.rewind_ptr] = right; - audio_data.rewind_buf[--audio_data.rewind_ptr] = left; + audio_driver_data.rewind_buf[--audio_driver_data.rewind_ptr] = right; + audio_driver_data.rewind_buf[--audio_driver_data.rewind_ptr] = left; } /** @@ -640,33 +641,33 @@ size_t audio_driver_sample_batch_rewind(const int16_t *data, size_t frames) size_t samples = frames << 1; for (i = 0; i < samples; i++) - audio_data.rewind_buf[--audio_data.rewind_ptr] = data[i]; + audio_driver_data.rewind_buf[--audio_driver_data.rewind_ptr] = data[i]; return frames; } void audio_driver_set_volume_gain(float gain) { - audio_data.volume_gain = gain; + audio_driver_data.volume_gain = gain; } void audio_driver_dsp_filter_free(void) { - if (audio_data.dsp) - rarch_dsp_filter_free(audio_data.dsp); - audio_data.dsp = NULL; + if (audio_driver_data.dsp) + rarch_dsp_filter_free(audio_driver_data.dsp); + audio_driver_data.dsp = NULL; } void audio_driver_dsp_filter_init(const char *device) { - audio_data.dsp = rarch_dsp_filter_new(device, audio_data.in_rate); - if (!audio_data.dsp) + audio_driver_data.dsp = rarch_dsp_filter_new(device, audio_driver_data.in_rate); + if (!audio_driver_data.dsp) RARCH_ERR("[DSP]: Failed to initialize DSP filter \"%s\".\n", device); } void audio_driver_set_buffer_size(size_t bufsize) { - audio_data.driver_buffer_size = bufsize; + audio_driver_data.driver_buffer_size = bufsize; } void audio_driver_set_callback(const void *data) @@ -675,7 +676,7 @@ void audio_driver_set_callback(const void *data) (const struct retro_audio_callback*)data; if (cb) - audio_data.audio_callback = *cb; + audio_driver_data.audio_callback = *cb; } void audio_driver_callback_set_state(bool state) @@ -683,8 +684,8 @@ void audio_driver_callback_set_state(bool state) if (!audio_driver_ctl(RARCH_AUDIO_CTL_HAS_CALLBACK, NULL)) return; - if (audio_data.audio_callback.set_state) - audio_data.audio_callback.set_state(state); + if (audio_driver_data.audio_callback.set_state) + audio_driver_data.audio_callback.set_state(state); } static void audio_monitor_adjust_system_rates(void) @@ -701,13 +702,13 @@ static void audio_monitor_adjust_system_rates(void) return; timing_skew = fabs(1.0f - info->fps / settings->video.refresh_rate); - audio_data.in_rate = info->sample_rate; + audio_driver_data.in_rate = info->sample_rate; if (timing_skew <= settings->audio.max_timing_skew) - audio_data.in_rate *= (settings->video.refresh_rate / info->fps); + audio_driver_data.in_rate *= (settings->video.refresh_rate / info->fps); RARCH_LOG("Set audio input rate to: %.2f Hz.\n", - audio_data.in_rate); + audio_driver_data.in_rate); } static void audio_driver_setup_rewind(void) @@ -715,18 +716,18 @@ static void audio_driver_setup_rewind(void) unsigned i; /* Push audio ready to be played. */ - audio_data.rewind_ptr = audio_data.rewind_size; + audio_driver_data.rewind_ptr = audio_driver_data.rewind_size; - for (i = 0; i < audio_data.data_ptr; i += 2) + for (i = 0; i < audio_driver_data.data_ptr; i += 2) { - audio_data.rewind_buf[--audio_data.rewind_ptr] = - audio_data.conv_outsamples[i + 1]; + audio_driver_data.rewind_buf[--audio_driver_data.rewind_ptr] = + audio_driver_data.conv_outsamples[i + 1]; - audio_data.rewind_buf[--audio_data.rewind_ptr] = - audio_data.conv_outsamples[i + 0]; + audio_driver_data.rewind_buf[--audio_driver_data.rewind_ptr] = + audio_driver_data.conv_outsamples[i + 0]; } - audio_data.data_ptr = 0; + audio_driver_data.data_ptr = 0; } static bool find_audio_driver(void) @@ -772,13 +773,13 @@ bool audio_driver_ctl(enum rarch_audio_ctl_state state, void *data) audio_driver_setup_rewind(); return true; case RARCH_AUDIO_CTL_HAS_CALLBACK: - return audio_data.audio_callback.callback; + return audio_driver_data.audio_callback.callback; case RARCH_AUDIO_CTL_CALLBACK: if (!audio_driver_ctl(RARCH_AUDIO_CTL_HAS_CALLBACK, NULL)) return false; - if (audio_data.audio_callback.callback) - audio_data.audio_callback.callback(); + if (audio_driver_data.audio_callback.callback) + audio_driver_data.audio_callback.callback(); return true; case RARCH_AUDIO_CTL_MONITOR_ADJUST_SYSTEM_RATES: audio_monitor_adjust_system_rates(); @@ -786,14 +787,14 @@ bool audio_driver_ctl(enum rarch_audio_ctl_state state, void *data) case RARCH_AUDIO_CTL_MONITOR_SET_REFRESH_RATE: { double new_src_ratio = (double)settings->audio.out_rate / - audio_data.in_rate; + audio_driver_data.in_rate; - audio_data.orig_src_ratio = new_src_ratio; - audio_data.src_ratio = new_src_ratio; + audio_driver_data.orig_src_ratio = new_src_ratio; + audio_driver_data.src_ratio = new_src_ratio; } return true; case RARCH_AUDIO_CTL_MUTE_TOGGLE: - if (!context_audio_data || !audio_active) + if (!audio_driver_context_audio_data || !audio_driver_active) return false; settings->audio.mute_enable = !settings->audio.mute_enable; @@ -802,38 +803,38 @@ bool audio_driver_ctl(enum rarch_audio_ctl_state state, void *data) event_command(EVENT_CMD_AUDIO_STOP); else if (!event_command(EVENT_CMD_AUDIO_START)) { - audio_active = false; + audio_driver_active = false; return false; } return true; case RARCH_AUDIO_CTL_ALIVE: - if (!context_audio_data) + if (!audio_driver_context_audio_data) return false; - return current_audio->alive(context_audio_data); + return current_audio->alive(audio_driver_context_audio_data); case RARCH_AUDIO_CTL_START: - return current_audio->start(context_audio_data); + return current_audio->start(audio_driver_context_audio_data); case RARCH_AUDIO_CTL_STOP: - return current_audio->stop(context_audio_data); + return current_audio->stop(audio_driver_context_audio_data); case RARCH_AUDIO_CTL_FIND_DRIVER: return find_audio_driver(); case RARCH_AUDIO_CTL_SET_OWN_DRIVER: - audio_data_own = true; + audio_driver_data_own = true; break; case RARCH_AUDIO_CTL_UNSET_OWN_DRIVER: - audio_data_own = false; + audio_driver_data_own = false; break; case RARCH_AUDIO_CTL_OWNS_DRIVER: - return audio_data_own; + return audio_driver_data_own; case RARCH_AUDIO_CTL_SET_ACTIVE: - audio_active = true; + audio_driver_active = true; break; case RARCH_AUDIO_CTL_UNSET_ACTIVE: - audio_active = false; + audio_driver_active = false; break; case RARCH_AUDIO_CTL_FRAME_IS_REVERSE: /* We just rewound. Flush rewind audio buffer. */ - audio_driver_flush(audio_data.rewind_buf + audio_data.rewind_ptr, - audio_data.rewind_size - audio_data.rewind_ptr); + audio_driver_flush(audio_driver_data.rewind_buf + audio_driver_data.rewind_ptr, + audio_driver_data.rewind_size - audio_driver_data.rewind_ptr); return true; }