rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/apps/audioplayers/app_audio.cpp

719 lines
21 KiB
C++
Raw Blame History

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include "app_bt_trace.h"
#include "cmsis_os.h"
#include "string.h"
#include "app_audio.h"
#include "app_media_player.h"
#include "app_ring_merge.h"
#include "app_thread.h"
#include "cqueue.h"
#include "hal_aud.h"
#include "list.h"
#include "nvrecord.h"
#include "resources.h"
#include <assert.h>
#include "a2dp_api.h"
#include "app_bt_media_manager.h"
#include "btapp.h"
extern uint8_t __StackLimit[];
extern uint8_t __HeapLimit[];
static const size_t heap_size = __StackLimit - __HeapLimit - 512;
static bool app_audio_init = false;
static uint32_t capture_audio_buff_size_used;
// from the bottom of the system available memory pool, size is
// APP_CAPTURE_AUDIO_BUFFER_SIZE can be overlayed with the sco used audio buffer
static uint8_t *capture_audio_buffer =
__HeapLimit + heap_size - APP_CAPTURE_AUDIO_BUFFER_SIZE;
int app_capture_audio_mempool_init(void) {
TRACE_AUD_HDL_I("[CAPMEM][INIT] size %d.", APP_CAPTURE_AUDIO_BUFFER_SIZE);
capture_audio_buff_size_used = 0;
memset((uint8_t *)capture_audio_buffer, 0, APP_CAPTURE_AUDIO_BUFFER_SIZE);
return 0;
}
uint32_t app_capture_audio_mempool_free_buff_size() {
return APP_CAPTURE_AUDIO_BUFFER_SIZE - capture_audio_buff_size_used;
}
int app_capture_audio_mempool_get_buff(uint8_t **buff, uint32_t size) {
uint32_t buff_size_free;
uint8_t *capture_buf_addr = (uint8_t *)capture_audio_buffer;
buff_size_free = app_capture_audio_mempool_free_buff_size();
if (size % 4) {
size = size + (4 - size % 4);
}
TRACE_AUD_HDL_I("[CAPMEM][GET] current free %d to allocate %d",
buff_size_free, size);
ASSERT(size <= buff_size_free, "[%s] size = %d > free size = %d", __func__,
size, buff_size_free);
*buff = capture_buf_addr + capture_audio_buff_size_used;
capture_audio_buff_size_used += size;
TRACE_AUD_HDL_I("[CAPMEM][GET] %d, now used %d left %d", size,
capture_audio_buff_size_used,
app_capture_audio_mempool_free_buff_size());
return 0;
}
osPoolDef(app_audio_status_mempool, 20, APP_AUDIO_STATUS);
osPoolId app_audio_status_mempool = NULL;
// control queue access
osMutexId g_app_audio_queue_mutex_id = NULL;
osMutexDef(g_app_audio_queue_mutex);
// control pcmbuff access
static CQueue app_audio_pcm_queue;
static osMutexId app_audio_pcmbuff_mutex_id = NULL;
osMutexDef(app_audio_pcmbuff_mutex);
#ifdef __AUDIO_QUEUE_SUPPORT__
typedef struct {
list_t *audio_list;
} APP_AUDIO_CONFIG;
APP_AUDIO_CONFIG app_audio_conifg = {.audio_list = NULL};
#endif
void LOCK_APP_AUDIO_QUEUE() {
osMutexWait(g_app_audio_queue_mutex_id, osWaitForever);
}
void UNLOCK_APP_AUDIO_QUEUE() { osMutexRelease(g_app_audio_queue_mutex_id); }
uint32_t app_audio_lr_balance(uint8_t *buf, uint32_t len, int8_t balance) {
short *balance_buf = (short *)buf;
uint32_t balance_len = len / 2;
float factor;
ASSERT((balance >= -100) && (balance <= 100), "balance = %d is invalid!",
balance);
if (balance > 0) {
// reduce L channel
factor = 1 - 0.01 * balance;
for (uint32_t i = 0; i < balance_len; i += 2) {
balance_buf[i] = (short)(factor * balance_buf[i]);
}
} else if (balance < 0) {
// reduce R channel
factor = 1 + 0.01 * balance;
for (uint32_t i = 0; i < balance_len; i += 2) {
balance_buf[i + 1] = (short)(factor * balance_buf[i + 1]);
}
}
return 0;
}
void app_audio_mempool_init_with_specific_size(uint32_t size) {
syspool_init_specific_size(size);
}
int app_audio_pcmbuff_init(uint8_t *buff, uint16_t len) {
if (app_audio_pcmbuff_mutex_id == NULL)
app_audio_pcmbuff_mutex_id =
osMutexCreate((osMutex(app_audio_pcmbuff_mutex)));
if ((buff == NULL) || (app_audio_pcmbuff_mutex_id == NULL))
return -1;
osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
InitCQueue(&app_audio_pcm_queue, len, buff);
memset(buff, 0x00, len);
osMutexRelease(app_audio_pcmbuff_mutex_id);
return 0;
}
int app_audio_pcmbuff_length(void) {
int len;
osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
len = LengthOfCQueue(&app_audio_pcm_queue);
osMutexRelease(app_audio_pcmbuff_mutex_id);
return len;
}
int app_audio_pcmbuff_put(uint8_t *buff, uint16_t len) {
int status;
osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
status = EnCQueue(&app_audio_pcm_queue, buff, len);
osMutexRelease(app_audio_pcmbuff_mutex_id);
return status;
}
int app_audio_pcmbuff_get(uint8_t *buff, uint16_t len) {
unsigned char *e1 = NULL, *e2 = NULL;
unsigned int len1 = 0, len2 = 0;
int status;
osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
status = PeekCQueue(&app_audio_pcm_queue, len, &e1, &len1, &e2, &len2);
if (len == (len1 + len2)) {
memcpy(buff, e1, len1);
memcpy(buff + len1, e2, len2);
DeCQueue(&app_audio_pcm_queue, 0, len1);
DeCQueue(&app_audio_pcm_queue, 0, len2);
} else {
memset(buff, 0x00, len);
status = -1;
}
osMutexRelease(app_audio_pcmbuff_mutex_id);
return status;
}
int app_audio_pcmbuff_discard(uint16_t len) {
int status;
osMutexWait(app_audio_pcmbuff_mutex_id, osWaitForever);
status = DeCQueue(&app_audio_pcm_queue, 0, len);
osMutexRelease(app_audio_pcmbuff_mutex_id);
return status;
}
void __attribute__((section(".fast_text_sram")))
app_audio_memcpy_16bit(int16_t *des, int16_t *src, int len) {
// Check input
for (int i = 0; i < len; i++) {
des[i] = src[i];
}
}
void __attribute__((section(".fast_text_sram")))
app_audio_memset_16bit(int16_t *des, int16_t val, int len) {
// Check input
for (int i = 0; i < len; i++) {
des[i] = val;
}
}
#ifdef __AUDIO_QUEUE_SUPPORT__
int app_audio_sendrequest_param(uint16_t id, uint8_t status, uint32_t ptr,
uint32_t param) {
uint32_t audevt;
APP_MESSAGE_BLOCK msg;
if (app_audio_init == false)
return -1;
msg.mod_id = APP_MODUAL_AUDIO;
APP_AUDIO_SET_MESSAGE(audevt, id, status);
msg.msg_body.message_id = audevt;
msg.msg_body.message_ptr = ptr;
msg.msg_body.message_Param0 = param;
app_mailbox_put(&msg);
return 0;
}
int app_audio_sendrequest(uint16_t id, uint8_t status, uint32_t ptr) {
return app_audio_sendrequest_param(id, status, ptr, 0);
}
extern bool app_audio_list_playback_exist(void);
#ifdef MEDIA_PLAYER_SUPPORT
static uint8_t app_audio_get_list_playback_num(void) {
APP_AUDIO_STATUS *audio_handle = NULL;
list_node_t *node = NULL;
uint8_t num = 0;
for (node = list_begin(app_audio_conifg.audio_list);
node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
audio_handle = (APP_AUDIO_STATUS *)list_node(node);
if (audio_handle == NULL) {
return num;
}
if (audio_handle->id == APP_PLAY_BACK_AUDIO)
num++;
}
return num;
}
#endif
#endif
static bool need_flush_flash_switch_audio = false;
void app_audio_switch_flash_flush_req(void) {
uint32_t lock;
lock = int_lock();
need_flush_flash_switch_audio = true;
int_unlock(lock);
}
static void app_audio_switch_flash_proc(void) {
// no need to do this across the audio switch,
// will use suspend flash erase to assure that no audio
// irq is missing for handling caused by long time global irq disabling
// during flash erase.
// Just flash the nvrecord flash periodically
return;
uint32_t lock;
bool need_flush_flash = false;
lock = int_lock();
if (need_flush_flash_switch_audio) {
need_flush_flash_switch_audio = false;
need_flush_flash = true;
}
int_unlock(lock);
if (need_flush_flash) {
nv_record_flash_flush();
}
}
#ifdef VOICE_DATAPATH
static bool app_audio_handle_pre_processing(APP_MESSAGE_BODY *msg_body) {
uint16_t stream_type;
APP_AUDIO_GET_AUD_ID(msg_body->message_ptr, stream_type);
bool isToResetCaptureStream = false;
if ((BT_STREAM_SBC == stream_type) || (BT_STREAM_MEDIA == stream_type)) {
if (app_audio_manager_capture_is_active()) {
isToResetCaptureStream = true;
}
}
if (isToResetCaptureStream) {
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP, BT_STREAM_CAPTURE,
0, 0);
APP_MESSAGE_BLOCK msg;
msg.msg_body = *msg_body;
msg.mod_id = APP_MODUAL_AUDIO_MANAGE;
app_mailbox_put(&msg);
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_START,
BT_STREAM_CAPTURE, 0, 0);
return false;
} else {
return true;
}
}
#endif
static int app_audio_handle_process(APP_MESSAGE_BODY *msg_body) {
int nRet = -1;
APP_AUDIO_STATUS aud_status;
if (app_audio_init == false)
return -1;
#ifdef VOICE_DATAPATH
bool isContinue = app_audio_handle_pre_processing(msg_body);
if (!isContinue) {
return -1;
}
#endif
APP_AUDIO_GET_ID(msg_body->message_id, aud_status.id);
APP_AUDIO_GET_STATUS(msg_body->message_id, aud_status.status);
APP_AUDIO_GET_AUD_ID(msg_body->message_ptr, aud_status.aud_id);
APP_AUDIO_GET_FREQ(msg_body->message_Param0, aud_status.freq);
switch (aud_status.status) {
case APP_BT_SETTING_OPEN:
#ifdef __AUDIO_QUEUE_SUPPORT__
TRACE_AUD_HDL_I("[OPEN] before status_id: 0x%x%s, aud_id: %d, len = %d",
aud_status.id, player2str(aud_status.id), aud_status.aud_id,
list_length(app_audio_conifg.audio_list));
if (app_audio_list_append(&aud_status)) {
app_bt_stream_open(&aud_status);
TRACE_AUD_HDL_I("[OPEN] after status_id: 0x%x%s, len = %d", aud_status.id,
player2str(aud_status.id),
list_length(app_audio_conifg.audio_list));
}
#else
app_bt_stream_open(&aud_status);
#endif
break;
case APP_BT_SETTING_CLOSE:
app_audio_switch_flash_proc();
#ifdef __AUDIO_QUEUE_SUPPORT__
APP_AUDIO_STATUS next_status;
TRACE_AUD_HDL_I("[CLOSE] current id: 0x%x%s", aud_status.id,
player2str(aud_status.id));
app_bt_stream_close(aud_status.id);
app_audio_switch_flash_proc();
#ifdef MEDIA_PLAYER_SUPPORT
if (aud_status.id == APP_PLAY_BACK_AUDIO) {
TRACE_AUD_HDL_I("[CLOSE] list: %d", app_audio_get_list_playback_num());
if (app_audio_get_list_playback_num() == 1) {
TRACE_AUD_HDL_I("=======>APP_BT_SETTING_CLOSE MEDIA");
bt_media_stop(BT_STREAM_MEDIA, BT_DEVICE_ID_1);
}
}
#endif
if (app_audio_list_rmv_callback(&aud_status, &next_status,
APP_BT_SETTING_Q_POS_HEAD, false)) {
TRACE_AUD_HDL_I("[CLOSE] %p, next id: 0x%x%s, status %d", &next_status,
next_status.id, player2str(next_status.id),
next_status.status);
app_bt_stream_open(&next_status);
}
#else
app_bt_stream_close(aud_status.id);
app_audio_switch_flash_proc();
#endif
break;
case APP_BT_SETTING_SETUP:
app_bt_stream_setup(aud_status.id, msg_body->message_ptr);
break;
case APP_BT_SETTING_RESTART:
app_bt_stream_restart(&aud_status);
break;
case APP_BT_SETTING_CLOSEALL:
app_bt_stream_closeall();
#ifdef __AUDIO_QUEUE_SUPPORT__
app_audio_list_clear();
#endif
app_audio_switch_flash_proc();
break;
default:
break;
}
return nRet;
}
#ifdef __AUDIO_QUEUE_SUPPORT__
static void app_audio_handle_free(void *data) {
#ifdef MEDIA_PLAYER_SUPPORT
APP_AUDIO_STATUS *status = (APP_AUDIO_STATUS *)data;
if (status->id == APP_PLAY_BACK_AUDIO) {
TRACE_AUD_HDL_I("[HANDLE_FREE] , aud_id: 0x%x, type = 0x%x", status->aud_id,
status->aud_type);
}
#endif
osPoolFree(app_audio_status_mempool, data);
}
void app_audio_list_create() {
if (app_audio_conifg.audio_list == NULL) {
app_audio_conifg.audio_list = list_new(app_audio_handle_free, NULL, NULL);
}
}
bool app_audio_list_stream_exist() {
APP_AUDIO_STATUS *audio_handle = NULL;
list_node_t *node = NULL;
for (node = list_begin(app_audio_conifg.audio_list);
node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
audio_handle = (APP_AUDIO_STATUS *)list_node(node);
if (audio_handle == NULL) {
return false;
}
if (audio_handle->id == APP_BT_STREAM_HFP_PCM ||
audio_handle->id == APP_BT_STREAM_HFP_CVSD ||
audio_handle->id == APP_BT_STREAM_HFP_VENDOR ||
audio_handle->id == APP_BT_STREAM_A2DP_SBC ||
audio_handle->id == APP_BT_STREAM_A2DP_AAC ||
#ifdef VOICE_DATAPATH
audio_handle->id == APP_BT_STREAM_VOICEPATH ||
#endif
#ifdef __AI_VOICE__
audio_handle->id == APP_BT_STREAM_AI_VOICE ||
#endif
#ifdef __THIRDPARTY
audio_handle->id == APP_BT_STREAM_THIRDPARTY_VOICE ||
#endif
audio_handle->id == APP_BT_STREAM_A2DP_VENDOR) {
TRACE_AUD_HDL_I("[STREAM_LIST][EXIST] id 0x%x", audio_handle->id);
return true;
}
}
return false;
}
bool app_audio_list_filter_exist(APP_AUDIO_STATUS *aud_status) {
#ifdef MEDIA_PLAYER_SUPPORT
APP_AUDIO_STATUS *audio_handle = NULL;
list_node_t *node = NULL;
uint8_t cnt = 0;
if (aud_status->id == APP_PLAY_BACK_AUDIO) {
if (aud_status->aud_id == AUD_ID_BT_CALL_INCOMING_CALL) {
for (node = list_begin(app_audio_conifg.audio_list);
node != list_end(app_audio_conifg.audio_list);
node = list_next(node)) {
audio_handle = (APP_AUDIO_STATUS *)list_node(node);
if (audio_handle == NULL) {
return false;
}
if (audio_handle->id == APP_PLAY_BACK_AUDIO &&
audio_handle->aud_id == AUD_ID_BT_CALL_INCOMING_CALL) {
TRACE_AUD_HDL_I("[STREAM_LIST][FILTER] id 0x%x", audio_handle->id);
return true;
}
}
} else {
for (node = list_begin(app_audio_conifg.audio_list);
node != list_end(app_audio_conifg.audio_list);
node = list_next(node)) {
audio_handle = (APP_AUDIO_STATUS *)list_node(node);
if (cnt++ > 1) {
TRACE_AUD_HDL_I("[STREAM_LIST][FILTER] cnt %d", cnt);
return true;
}
}
}
}
#endif
return false;
}
bool app_audio_list_playback_exist(void) {
#ifdef MEDIA_PLAYER_SUPPORT
APP_AUDIO_STATUS *audio_handle = NULL;
list_node_t *node = NULL;
for (node = list_begin(app_audio_conifg.audio_list);
node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
audio_handle = (APP_AUDIO_STATUS *)list_node(node);
if (audio_handle == NULL) {
return false;
}
if (audio_handle->id == APP_PLAY_BACK_AUDIO) {
TRACE_AUD_HDL_I("[STREAM_LIST][PLAYBACK_EXIST]");
return true;
}
}
#endif
return false;
}
void app_audio_list_playback_clear(void) {
#ifdef MEDIA_PLAYER_SUPPORT
APP_AUDIO_STATUS *audio_handle = NULL;
list_node_t *node = NULL;
for (node = list_begin(app_audio_conifg.audio_list);
node != list_end(app_audio_conifg.audio_list); node = list_next(node)) {
audio_handle = (APP_AUDIO_STATUS *)list_node(node);
if (audio_handle == NULL) {
TRACE_AUD_HDL_I("[STREAM_LIST][CLR] find null\n ");
return;
}
if (audio_handle->id == APP_PLAY_BACK_AUDIO) {
list_remove(app_audio_conifg.audio_list, list_node(node));
}
}
#endif
}
bool app_audio_list_append(APP_AUDIO_STATUS *aud_status) {
APP_AUDIO_STATUS *data_to_append = NULL;
bool add_data_to_head_of_list = false;
bool ret = true;
TRACE_AUD_HDL_I("[STREAM_LIST][APPEND] id 0x%x%s", aud_status->id,
player2str(aud_status->id));
#ifdef MEDIA_PLAYER_SUPPORT
if (aud_status->id == APP_PLAY_BACK_AUDIO) {
// ignore redundant ring ind from hfp...
if (app_audio_list_filter_exist(aud_status)) {
return false;
}
if (app_audio_list_playback_exist()) {
if (list_length(app_audio_conifg.audio_list) >= MAX_AUDIO_BUF_LIST) {
if (app_audio_list_stream_exist()) {
data_to_append =
(APP_AUDIO_STATUS *)osPoolCAlloc(app_audio_status_mempool);
if (data_to_append == NULL) {
return false;
}
memcpy(data_to_append,
(const void *)list_front(app_audio_conifg.audio_list),
sizeof(APP_AUDIO_STATUS));
add_data_to_head_of_list = true;
}
app_audio_list_clear();
TRACE_AUD_HDL_E("[STREAM_LIST][APPEND] FIXME!!!!\n ");
} else {
ret = false;
}
}
} else
#endif
{
add_data_to_head_of_list = true;
}
if (data_to_append == NULL) {
data_to_append = (APP_AUDIO_STATUS *)osPoolCAlloc(app_audio_status_mempool);
if (data_to_append == NULL) {
return false;
}
memcpy(data_to_append, aud_status, sizeof(APP_AUDIO_STATUS));
}
if (add_data_to_head_of_list) {
list_prepend(app_audio_conifg.audio_list, (void *)data_to_append);
} else {
list_append(app_audio_conifg.audio_list, (void *)data_to_append);
}
TRACE_AUD_HDL_I("[STREAM_LIST][APPEND] id 0x%x%s status %d len %d ret %d",
data_to_append->id, player2str(data_to_append->id),
data_to_append->status,
list_length(app_audio_conifg.audio_list), ret);
return ret;
}
bool app_audio_list_rmv_callback(APP_AUDIO_STATUS *status_close,
APP_AUDIO_STATUS *status_next,
enum APP_BT_AUDIO_Q_POS pos, bool pop_next) {
void *data_to_remove = NULL;
bool ret = false;
// for status: first bt_a2dp->APP_BT_SETTING_CLOSE,then ring->
// APP_BT_SETTING_CLOSE
TRACE_AUD_HDL_I("[STREAM_LIST][RMV] audio list len %d close_id 0x%x%s",
list_length(app_audio_conifg.audio_list), status_close->id,
player2str(status_close->id));
if (list_length(app_audio_conifg.audio_list) == 0) {
return false;
}
#ifdef MEDIA_PLAYER_SUPPORT
APP_AUDIO_STATUS *audio_handle = NULL;
list_node_t *node = NULL;
if (status_close->id == APP_PLAY_BACK_AUDIO) {
for (node = list_begin(app_audio_conifg.audio_list);
node != list_end(app_audio_conifg.audio_list);
node = list_next(node)) {
audio_handle = (APP_AUDIO_STATUS *)list_node(node);
if (audio_handle == NULL) {
return ret;
}
if (audio_handle->id == APP_PLAY_BACK_AUDIO) {
list_node_t *nod_next = list_next(node);
data_to_remove = list_node(node);
if (pop_next) {
memcpy(status_next, list_node(node), sizeof(APP_AUDIO_STATUS));
ret = true;
break;
}
if (nod_next != NULL) {
memcpy(status_next, list_node(nod_next), sizeof(APP_AUDIO_STATUS));
ASSERT(status_next->id == APP_PLAY_BACK_AUDIO,
"[%s] 111ERROR: status_next->id != APP_PLAY_BACK_AUDIO",
__func__);
ret = true;
} else if (app_audio_list_stream_exist()) {
void *indata = list_front(app_audio_conifg.audio_list);
if (indata == NULL) {
return ret;
}
memcpy(status_next, indata, sizeof(APP_AUDIO_STATUS));
ASSERT(status_next->id != APP_PLAY_BACK_AUDIO,
"[%s] 222ERROR: status_next->id != APP_PLAY_BACK_AUDIO",
__func__);
ret = true;
}
break;
}
}
} else // maybe...a2dp send >> APP_BT_SETTING_CLOSE, when ring
#endif
{
if (app_audio_list_stream_exist()) {
if (pos == APP_BT_SETTING_Q_POS_HEAD) {
data_to_remove = list_front(app_audio_conifg.audio_list);
} else if (pos == APP_BT_SETTING_Q_POS_TAIL) {
data_to_remove = list_back(app_audio_conifg.audio_list);
}
}
}
if (data_to_remove) {
list_remove(app_audio_conifg.audio_list, data_to_remove);
}
TRACE_AUD_HDL_I("[STREAM_LIST][RMV] end len:%d ret %d data %p",
list_length(app_audio_conifg.audio_list), ret,
data_to_remove);
return ret;
}
void app_audio_list_clear() { list_clear(app_audio_conifg.audio_list); }
#endif
void app_audio_open(void) {
if (app_audio_init) {
return;
}
if (g_app_audio_queue_mutex_id == NULL) {
g_app_audio_queue_mutex_id =
osMutexCreate((osMutex(g_app_audio_queue_mutex)));
} else {
ASSERT(0, "[%s] ERROR: g_app_audio_queue_mutex_id != NULL", __func__);
}
if (app_audio_status_mempool == NULL)
app_audio_status_mempool = osPoolCreate(osPool(app_audio_status_mempool));
ASSERT(app_audio_status_mempool,
"[%s] ERROR: app_audio_status_mempool != NULL", __func__);
#ifdef __AUDIO_QUEUE_SUPPORT__
app_audio_list_create();
#endif
app_ring_merge_init();
app_set_threadhandle(APP_MODUAL_AUDIO, app_audio_handle_process);
app_bt_stream_init();
app_audio_init = true;
}
void app_audio_close(void) {
app_set_threadhandle(APP_MODUAL_AUDIO, NULL);
app_audio_init = false;
}
Reference in New Issue View Git Blame Copy Permalink