rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/services/bt_app/app_ring_merge.cpp
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

380 lines
13 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_ring_merge.h"
#include "audioflinger.h"
#include "cmsis_os.h"
#include "hal_trace.h"
#include "res_audio_ring.h"
// control queue access
osMutexId app_ring_merge_mutex_id = NULL;
osMutexDef(app_ring_merge_mutex);
extern "C" void app_stop_a2dp_media_stream(uint8_t devId);
extern "C" void app_stop_sco_media_stream(uint8_t devId);
static void app_ring_merge_finished_callback(void);
enum APP_RING_MERGE_STATUS {
APP_RING_MERGE_STATUS_STOP,
APP_RING_MERGE_STATUS_START,
APP_RING_MERGE_STATUS_RUNNING
};
struct APP_RING_MERGE_CONFIG_T {
APP_RING_MERGE_STATUS status;
int16_t *pbuf;
uint32_t len;
uint32_t next;
AUD_BITS_T bits;
enum APP_RING_MERGE_PLAY_T play;
AF_STREAM_HANDLER_T handler;
uint8_t pendingStopOp;
int8_t savedStoppedStreamId;
};
struct APP_RING_MERGE_CONFIG_T app_ring_merge_config = {
.status = APP_RING_MERGE_STATUS_STOP,
.pbuf = NULL,
.len = 0,
.next = 0,
.bits = AUD_BITS_16,
.play = APP_RING_MERGE_PLAY_QTY,
.handler = NULL};
template <typename DataType> static DataType convertTo(int16_t x) {
return (x);
}
template <> int32_t convertTo<int32_t>(int16_t x) { return (x << 8); }
template <typename DataType>
static void app_ring_merge_track_2_in_1(DataType *src_buf0, int16_t *src_buf1,
DataType *dst_buf, uint32_t src_len) {
uint32_t i = 0;
for (i = 0; i < src_len; i++) {
dst_buf[i] = (src_buf0[i] >> 1) + ((convertTo<DataType>(src_buf1[i])) >> 1);
}
}
/*
static void app_ring_merge_track_2_in_1_16bits(int16_t *src_buf0, int16_t
*src_buf1, int16_t *dst_buf, uint32_t src_len)
{
app_ring_merge_track_2_in_1<int16_t>(src_buf0, src_buf1, dst_buf, src_len);
}
static void app_ring_merge_track_2_in_1_24bits(int32_t *src_buf0, int16_t
*src_buf1, int32_t *dst_buf, uint32_t src_len)
{
app_ring_merge_track_2_in_1<int32_t>(src_buf0, src_buf1, dst_buf, src_len);
}
*/
template <typename DataType>
static uint32_t app_ring_merge_oneshot_more_data_impl(uint8_t *buf,
uint32_t len) {
uint32_t need_len = len / sizeof(DataType);
DataType *pBuf = (DataType *)buf;
uint32_t curr_size = 0;
if (app_ring_merge_config.next == app_ring_merge_config.len) {
return len;
}
if (need_len > app_ring_merge_config.len) {
app_ring_merge_track_2_in_1(pBuf, app_ring_merge_config.pbuf, pBuf,
app_ring_merge_config.len);
app_ring_merge_config.next = app_ring_merge_config.len;
app_ring_merge_finished_callback();
} else {
if ((app_ring_merge_config.len - app_ring_merge_config.next) >= need_len) {
app_ring_merge_track_2_in_1(
pBuf, app_ring_merge_config.pbuf + app_ring_merge_config.next, pBuf,
need_len);
app_ring_merge_config.next += need_len;
} else {
curr_size = app_ring_merge_config.len - app_ring_merge_config.next;
app_ring_merge_track_2_in_1(
pBuf, app_ring_merge_config.pbuf + app_ring_merge_config.next, pBuf,
curr_size);
app_ring_merge_config.next = app_ring_merge_config.len;
app_ring_merge_finished_callback();
}
}
return len;
}
static uint32_t app_ring_merge_oneshot_more_data(uint8_t *buf, uint32_t len) {
uint32_t ret = 0;
if (app_ring_merge_config.bits == AUD_BITS_16)
ret = app_ring_merge_oneshot_more_data_impl<int16_t>(buf, len);
else if (app_ring_merge_config.bits == AUD_BITS_24)
ret = app_ring_merge_oneshot_more_data_impl<int32_t>(buf, len);
else
TRACE(1, "[%s] warning not suitable callback available", __func__);
return ret;
}
template <typename DataType>
static uint32_t app_ring_merge_periodic_more_data_impl(uint8_t *buf,
uint32_t len) {
uint32_t need_len = len / sizeof(DataType);
uint32_t remain_size = len / sizeof(DataType);
uint32_t curr_size = 0;
DataType *pBuf = (DataType *)buf;
if (need_len > app_ring_merge_config.len) {
do {
if (app_ring_merge_config.next) {
curr_size = app_ring_merge_config.len - app_ring_merge_config.next;
app_ring_merge_track_2_in_1(
pBuf, app_ring_merge_config.pbuf + app_ring_merge_config.next, pBuf,
curr_size);
remain_size -= curr_size;
app_ring_merge_config.next = 0;
} else if (remain_size > app_ring_merge_config.len) {
app_ring_merge_track_2_in_1(
pBuf + curr_size, app_ring_merge_config.pbuf, pBuf + curr_size,
app_ring_merge_config.len);
curr_size += app_ring_merge_config.len;
remain_size -= app_ring_merge_config.len;
} else {
app_ring_merge_track_2_in_1(pBuf + curr_size,
app_ring_merge_config.pbuf,
pBuf + curr_size, remain_size);
app_ring_merge_config.next = remain_size;
remain_size = 0;
}
} while (remain_size);
} else {
if ((app_ring_merge_config.len - app_ring_merge_config.next) >= need_len) {
app_ring_merge_track_2_in_1(
pBuf, app_ring_merge_config.pbuf + app_ring_merge_config.next, pBuf,
need_len);
app_ring_merge_config.next += need_len;
} else {
curr_size = app_ring_merge_config.len - app_ring_merge_config.next;
app_ring_merge_track_2_in_1(
pBuf, app_ring_merge_config.pbuf + app_ring_merge_config.next, pBuf,
curr_size);
app_ring_merge_config.next = need_len - curr_size;
app_ring_merge_track_2_in_1(pBuf + curr_size, app_ring_merge_config.pbuf,
pBuf + curr_size, app_ring_merge_config.next);
}
}
return len;
}
static uint32_t app_ring_merge_periodic_more_data(uint8_t *buf, uint32_t len) {
uint32_t ret = 0;
if (app_ring_merge_config.bits == AUD_BITS_16)
ret = app_ring_merge_periodic_more_data_impl<int16_t>(buf, len);
else if (app_ring_merge_config.bits == AUD_BITS_24)
ret = app_ring_merge_periodic_more_data_impl<int32_t>(buf, len);
else
TRACE(1, "[%s] warning not suitable callback available", __func__);
return ret;
}
uint32_t app_ring_merge_more_data(uint8_t *buf, uint32_t len) {
uint32_t nRet = len;
osMutexWait(app_ring_merge_mutex_id, osWaitForever);
if (app_ring_merge_config.handler &&
app_ring_merge_config.status != APP_RING_MERGE_STATUS_STOP) {
if (app_ring_merge_config.status == APP_RING_MERGE_STATUS_START) {
app_ring_merge_config.status = APP_RING_MERGE_STATUS_RUNNING;
}
nRet = app_ring_merge_config.handler(buf, len);
}
osMutexRelease(app_ring_merge_mutex_id);
return nRet;
}
int app_ring_merge_setup(int16_t *buf, uint32_t len,
enum APP_RING_MERGE_PLAY_T play) {
TRACE(3, "%s mode:%d len:%d", __func__, play, len);
osMutexWait(app_ring_merge_mutex_id, osWaitForever);
app_ring_merge_config.status = APP_RING_MERGE_STATUS_STOP;
app_ring_merge_config.pbuf = (int16_t *)buf;
app_ring_merge_config.len = len;
app_ring_merge_config.next = 0;
app_ring_merge_config.play = play;
if (play == APP_RING_MERGE_PLAY_ONESHOT) {
app_ring_merge_config.handler = app_ring_merge_oneshot_more_data;
} else if (play == APP_RING_MERGE_PLAY_PERIODIC) {
app_ring_merge_config.handler = app_ring_merge_periodic_more_data;
}
osMutexRelease(app_ring_merge_mutex_id);
return 0;
}
int app_ring_merge_init(void) {
if (app_ring_merge_mutex_id == NULL) {
app_ring_merge_mutex_id = osMutexCreate((osMutex(app_ring_merge_mutex)));
}
app_ring_merge_config.savedStoppedStreamId = -1;
return 0;
}
int app_ring_merge_deinit(void) {
osMutexWait(app_ring_merge_mutex_id, osWaitForever);
app_ring_merge_config.status = APP_RING_MERGE_STATUS_STOP;
app_ring_merge_config.pbuf = NULL;
app_ring_merge_config.len = 0;
app_ring_merge_config.next = 0;
app_ring_merge_config.bits = AUD_BITS_16;
app_ring_merge_config.play = APP_RING_MERGE_PLAY_QTY;
app_ring_merge_config.handler = NULL;
app_ring_merge_config.savedStoppedStreamId = -1;
osMutexRelease(app_ring_merge_mutex_id);
return 0;
}
int app_ring_merge_start(void) {
uint32_t ret;
struct AF_STREAM_CONFIG_T *stream_cfg = NULL;
ret = af_stream_get_cfg(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg,
true);
if (ret != 0) {
TRACE(0, "Failed to get stream cfg");
return 0;
}
TRACE(4, "%s: sample_rate: %d, bits: %d, channel: %d\n", __func__,
stream_cfg->sample_rate, stream_cfg->bits, stream_cfg->channel_num);
osMutexWait(app_ring_merge_mutex_id, osWaitForever);
#ifdef __BT_WARNING_TONE_MERGE_INTO_STREAM_SBC__
switch (stream_cfg->sample_rate) {
case AUD_SAMPRATE_8000:
app_ring_merge_setup((int16_t *)RES_AUD_RING_SAMPRATE_8000,
sizeof(RES_AUD_RING_SAMPRATE_8000) / sizeof(int16_t),
APP_RING_MERGE_PLAY_ONESHOT);
app_ring_merge_config.next = 0;
app_ring_merge_config.status = APP_RING_MERGE_STATUS_START;
break;
case AUD_SAMPRATE_16000:
TRACE(0, "sample rate 16000 merge");
app_ring_merge_setup((int16_t *)RES_AUD_RING_SAMPRATE_16000,
sizeof(RES_AUD_RING_SAMPRATE_16000) / sizeof(int16_t),
APP_RING_MERGE_PLAY_ONESHOT);
app_ring_merge_config.next = 0;
app_ring_merge_config.status = APP_RING_MERGE_STATUS_START;
break;
case AUD_SAMPRATE_44100:
app_ring_merge_setup((int16_t *)RES_AUD_RING_SAMPRATE_44100,
sizeof(RES_AUD_RING_SAMPRATE_44100) / sizeof(int16_t),
APP_RING_MERGE_PLAY_ONESHOT);
app_ring_merge_config.next = 0;
app_ring_merge_config.status = APP_RING_MERGE_STATUS_START;
break;
case AUD_SAMPRATE_48000:
app_ring_merge_setup((int16_t *)RES_AUD_RING_SAMPRATE_48000,
sizeof(RES_AUD_RING_SAMPRATE_48000) / sizeof(int16_t),
APP_RING_MERGE_PLAY_ONESHOT);
app_ring_merge_config.next = 0;
app_ring_merge_config.status = APP_RING_MERGE_STATUS_START;
break;
case AUD_SAMPRATE_22050:
case AUD_SAMPRATE_24000:
case AUD_SAMPRATE_96000:
case AUD_SAMPRATE_192000:
case AUD_SAMPRATE_NULL:
default:
app_ring_merge_config.next = 0;
app_ring_merge_config.status = APP_RING_MERGE_STATUS_START;
break;
}
#else
app_ring_merge_setup((int16_t *)RES_AUD_RING_SAMPRATE_8000,
sizeof(RES_AUD_RING_SAMPRATE_8000) / sizeof(int16_t),
APP_RING_MERGE_PLAY_ONESHOT);
app_ring_merge_config.next = 0;
app_ring_merge_config.status = APP_RING_MERGE_STATUS_START;
#endif
app_ring_merge_config.bits = stream_cfg->bits;
app_ring_merge_config.savedStoppedStreamId = -1;
osMutexRelease(app_ring_merge_mutex_id);
return 0;
}
int app_ring_merge_stop(void) {
osMutexWait(app_ring_merge_mutex_id, osWaitForever);
app_ring_merge_config.status = APP_RING_MERGE_STATUS_STOP;
app_ring_merge_config.next = 0;
osMutexRelease(app_ring_merge_mutex_id);
app_ring_merge_finished_callback();
return 0;
}
bool app_ring_merge_isrun(void) {
bool running = false;
osMutexWait(app_ring_merge_mutex_id, osWaitForever);
if (app_ring_merge_config.status == APP_RING_MERGE_STATUS_RUNNING) {
running = true;
}
osMutexRelease(app_ring_merge_mutex_id);
return running;
}
void app_ring_merge_save_pending_start_stream_op(uint8_t pendingStopOp,
uint8_t deviceId) {
app_ring_merge_config.pendingStopOp = pendingStopOp;
app_ring_merge_config.savedStoppedStreamId = deviceId;
}
static void app_ring_merge_finished_callback(void) {
TRACE(1, "%s", __func__);
app_ring_merge_config.status = APP_RING_MERGE_STATUS_STOP;
if (app_ring_merge_config.savedStoppedStreamId >= 0) {
if (PENDING_TO_STOP_A2DP_STREAMING == app_ring_merge_config.pendingStopOp) {
TRACE(0, "Stop the pending stopped a2dp media stream.");
app_stop_a2dp_media_stream(app_ring_merge_config.savedStoppedStreamId);
} else if (PENDING_TO_STOP_SCO_STREAMING ==
app_ring_merge_config.pendingStopOp) {
TRACE(0, "Stop the pending stopped sco media stream.");
app_stop_sco_media_stream(app_ring_merge_config.savedStoppedStreamId);
}
}
app_ring_merge_config.savedStoppedStreamId = -1;
}
Reference in a new issue View git blame Copy permalink