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

888 lines
22 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.
*
****************************************************************************/
/* rbplay source */
/* playback control & rockbox codec porting & codec thread */
#ifdef MBED
#include "mbed.h"
#include "rtos.h"
#endif
#include <string.h>
#include <math.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <unistd.h>
#include "SDFileSystem.h"
#include "hal_uart.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "audioflinger.h"
#include "cqueue.h"
#include "app_audio.h"
#include "eq.h"
#include "pga.h"
#include "metadata.h"
#include "dsp_core.h"
#include "codecs.h"
#include "codeclib.h"
#include "compressor.h"
#include "channel_mode.h"
#include "audiohw.h"
#include "codec_platform.h"
#include "metadata_parsers.h"
#include "hal_overlay.h"
#include "app_overlay.h"
#include "rbpcmbuf.h"
#include "rbplay.h"
#include "app_thread.h"
#include "app_utils.h"
#include "app_key.h"
#include "rbplaysd.h"
#include "rb_ctl.h"
/* Internals */
void rb_ctl_wait_lock_thread(bool lock);
void app_rbcodec_ctl_set_play_status(bool st);
extern bool app_rbcodec_check_hfp_active(void );
#include "SDFileSystem.h"
extern "C" void hal_sysfreq_print(void);
#define _LOG_TAG "[rb_ctl] "
#undef __attribute__(a)
#define RBPLAY_DEBUG 1
#if RBPLAY_DEBUG
#define _LOG_DBG(str,...) TRACE(0,_LOG_TAG""str, ##__VA_ARGS__)
#define _LOG_ERR(str,...) TRACE(0,_LOG_TAG"err:"""str, ##__VA_ARGS__)
#else
#define _LOG_DBG(str,...)
#define _LOG_ERR(str,...) TRACE(0,_LOG_TAG"err:"""str, ##__VA_ARGS__)
#endif
#include "rb_ctl.h"
void rb_thread_send_resume(void);
typedef struct {
uint32_t evt;
uint32_t arg;
} RBCTL_MSG_BLOCK;
static osThreadId rb_ctl_tid;
static void rb_ctl_thread(void const *argument);
static int rb_ctl_default_priority;
osThreadDef(rb_ctl_thread, osPriorityHigh, 1, 1024 * 4, "rb_ctl");
#define RBCTL_MAILBOX_MAX (20)
osMailQDef (rb_ctl_mailbox, RBCTL_MAILBOX_MAX, RBCTL_MSG_BLOCK);
static osMailQId rb_ctl_mailbox = NULL;
int rb_ctl_mailbox_put(RBCTL_MSG_BLOCK* msg_src);
//playlist
extern playlist_struct sd_playlist;
rb_ctl_struct rb_ctl_context;
extern void rb_thread_set_decode_vars(int fd, int type ,void* id3);
extern void rb_play_codec_run(void);
extern void rb_codec_set_halt(int halt);
extern void rb_player_sync_set_wait_thread(osThreadId tid);
extern void rb_player_sync_wait_close(void );
extern bool rb_pcmbuf_suspend_play_loop(void);
void app_rbplay_load_playlist(playlist_struct *list );
int rb_thread_post_msg(RB_MODULE_EVT evt,uint32_t arg );
static rb_ctl_status rb_ctl_get_status(void)
{
return rb_ctl_context.status;
}
bool rb_ctl_parse_file(const char* file_path)
{
/* open file */
_LOG_DBG(1,"open file %s\n", file_path);
rb_ctl_context.file_handle = open((const char *)file_path, O_RDWR);
if (rb_ctl_context.file_handle <= 0) {
_LOG_DBG(1,"open file %s failed\n", file_path);
return false;
}
if (!get_metadata(&rb_ctl_context.song_id3, rb_ctl_context.file_handle, rb_ctl_context.rb_fname)) {
_LOG_DBG(0,"get_metadata failed\n");
close(rb_ctl_context.file_handle);
return false;
}
_LOG_DBG(4,"%s bitr:%d,saps %d, freq:%d\n",__func__,rb_ctl_context.song_id3.bitrate,rb_ctl_context.song_id3.samples,rb_ctl_context.song_id3.frequency);
rb_thread_set_decode_vars(rb_ctl_context.file_handle, rb_ctl_context.song_id3.codectype,&rb_ctl_context.song_id3);
return true;
}
void rb_ctl_vol_operation(bool inc )
{
uint32_t ret;
struct AF_STREAM_CONFIG_T *stream_cfg = NULL;
_LOG_DBG(2,"%s inc:%d , ",__func__,inc);
if(inc ) {
if(rb_ctl_context.rb_player_vol < 16 ) {
rb_ctl_context.rb_player_vol++;
}
} else {
if(rb_ctl_context.rb_player_vol > 1 ) {
rb_ctl_context.rb_player_vol--;
}
}
if(rb_ctl_context.status != RB_CTL_PLAYING)
return ;
ret = af_stream_get_cfg(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg, true);
if (ret == 0) {
stream_cfg->vol = rb_ctl_context.rb_player_vol;
af_stream_setup(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, stream_cfg);
}
}
bool rb_ctl_is_playing(void)
{
return (rb_ctl_context.status == RB_CTL_PLAYING);
}
void rb_ctl_set_vol(uint32_t vol)
{
uint32_t ret;
struct AF_STREAM_CONFIG_T *stream_cfg = NULL;
_LOG_DBG(2,"%s set vol as :%d , ",__func__,vol);
if(rb_ctl_context.status != RB_CTL_PLAYING)
return ;
vol = (vol > 16)?16:vol;
rb_ctl_context.rb_player_vol = vol;
ret = af_stream_get_cfg(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, &stream_cfg, true);
if (ret == 0) {
stream_cfg->vol = rb_ctl_context.rb_player_vol;
af_stream_setup(AUD_STREAM_ID_0, AUD_STREAM_PLAYBACK, stream_cfg);
}
}
void rb_ctl_stop_play(void )
{
_LOG_DBG(1,"%s \n",__func__);
rb_codec_set_halt(1);
//close file
_LOG_DBG(0," af stream stop \n");
af_stream_stop(AUD_STREAM_ID_0,AUD_STREAM_PLAYBACK);
_LOG_DBG(0," af stream close \n");
af_stream_close(AUD_STREAM_ID_0,AUD_STREAM_PLAYBACK);
_LOG_DBG(0," close file \n");
if(rb_ctl_context.file_handle != -1)
close(rb_ctl_context.file_handle );
rb_ctl_context.file_handle = -1;
//release frequency
_LOG_DBG(0," release freq \n");
return ;
}
void rb_ctl_sync_stop_play(void )
{
rb_player_sync_set_wait_thread(osThreadGetId());
rb_ctl_stop_play();
rb_player_sync_wait_close();
//close file
_LOG_DBG(0," close file \n");
if(rb_ctl_context.file_handle != -1)
close(rb_ctl_context.file_handle );
rb_ctl_context.file_handle = -1;
}
void rb_ctl_pause_playing(void )
{
af_stream_stop(AUD_STREAM_ID_0,AUD_STREAM_PLAYBACK);
_LOG_DBG(0," af stream close \n");
af_stream_close(AUD_STREAM_ID_0,AUD_STREAM_PLAYBACK);
//wait decoder suspend
//osDelay(200);
// while(!rb_pcmbuf_suspend_play_loop()) {
//osThreadYield();
// osDelay(1);
// }
_LOG_DBG(1,"%s sucessed ",__func__);
}
void rb_ctl_resume_playing(void )
{
#ifndef __TWS__
rb_pcmbuf_init();
#endif
}
void rb_ctl_set_priority(int priority)
{
osThreadSetPriority(rb_ctl_tid, (osPriority)priority);
}
int rb_ctl_get_priority(void)
{
return (int)osThreadGetPriority(rb_ctl_tid);
}
int rb_ctl_get_default_priority(void)
{
return rb_ctl_default_priority;
}
void rb_ctl_reset_priority(void)
{
osThreadSetPriority(rb_ctl_tid, (osPriority)rb_ctl_default_priority);
}
#ifdef __IAG_BLE_INCLUDE__
extern "C" void app_ble_inform_music_switch(uint16_t index);
#endif
static int rb_ctl_handle_event(RBCTL_MSG_BLOCK *msg_body)
{
RB_MODULE_EVT evt =(RB_MODULE_EVT) msg_body->evt;
uint32_t arg = msg_body->arg;
// hal_sysfreq_print();
switch(evt) {
case RB_MODULE_EVT_PLAY:
if(rb_ctl_context.status != RB_CTL_IDLE) {
if(rb_ctl_context.status == RB_CTL_SUSPEND)
rb_thread_send_resume();
else
_LOG_DBG(2,"%s st %d not in idle \n",__func__,rb_ctl_context.status);
break;
}
_LOG_DBG(3," %s start %d/%d ",__func__, rb_ctl_context.curr_song_idx ,sd_playlist.total_songs);
if(sd_playlist.total_songs > 0 ) {
playlist_item *it;
it = app_rbplay_get_playitem(rb_ctl_context.curr_song_idx) ;
if(it == NULL) {
_LOG_DBG(2," %s get item fail idx %d",__func__,rb_ctl_context.curr_song_idx);
}
_LOG_DBG(2,"%s start songidx %d \n",__func__,rb_ctl_context.curr_song_idx);
memcpy(rb_ctl_context.rb_audio_file,it->file_path,sizeof(uint16_t)*FILE_PATH_LEN - 4);
memcpy(rb_ctl_context.rb_fname,it->file_name,sizeof(rb_ctl_context.rb_fname));
if(rb_ctl_parse_file((const char*)rb_ctl_context.rb_audio_file)) {
_LOG_DBG(2,"%s start init, the tid 0x%x\n",__func__,osThreadGetId());
rb_play_codec_init();
_LOG_DBG(1,"%s start run\n",__func__);
rb_play_codec_run();
rb_ctl_context.status = RB_CTL_PLAYING;
app_rbcodec_ctl_set_play_status(true);
break;
} else {
_LOG_DBG(2,"%s evt %d parse fail,find next\n",__func__,msg_body->evt);
rb_thread_post_msg(RB_MODULE_EVT_PLAY_NEXT,true);
}
} else {
_LOG_DBG(2,"%s evt %d no songs\n",__func__,msg_body->evt);
}
break;
case RB_MODULE_EVT_STOP:
if(rb_ctl_context.status == RB_CTL_IDLE) {
_LOG_DBG(2,"%s st %d in idle \n",__func__,rb_ctl_context.status);
break;
}
if(rb_ctl_context.status == RB_CTL_SUSPEND) {
//osDelay(100);
rb_ctl_resume_playing();
rb_ctl_context.status = RB_CTL_PLAYING;
}
rb_ctl_sync_stop_play();
rb_ctl_context.status = RB_CTL_IDLE;
app_rbcodec_ctl_set_play_status(false);
break;
case RB_MODULE_EVT_SUSPEND:
if (rb_ctl_context.status != RB_CTL_PLAYING) {
_LOG_DBG(2,"%s st %d not running \n",__func__,rb_ctl_context.status);
break;
}
rb_ctl_pause_playing();
rb_ctl_context.status = RB_CTL_SUSPEND;
break;
case RB_MODULE_EVT_RESUME:
if (rb_ctl_context.status != RB_CTL_SUSPEND) {
_LOG_DBG(2,"%s st %d not suspend \n",__func__,rb_ctl_context.status);
break;
}
rb_ctl_resume_playing();
rb_ctl_context.status = RB_CTL_PLAYING;
break;
case RB_MODULE_EVT_PLAY_NEXT:
if( rb_ctl_context.status == RB_CTL_PLAYING) {
rb_thread_post_msg(RB_MODULE_EVT_STOP,0 );
} else if( rb_ctl_context.status == RB_CTL_SUSPEND) {
rb_thread_post_msg(RB_MODULE_EVT_STOP,0 );
} else {
}
if(arg == 0) {
rb_ctl_context.curr_song_idx--;
if(rb_ctl_context.curr_song_idx == 0xffff)
rb_ctl_context.curr_song_idx = sd_playlist.total_songs -1;
} else {
rb_ctl_context.curr_song_idx++;
if(rb_ctl_context.curr_song_idx >= sd_playlist.total_songs)
rb_ctl_context.curr_song_idx = 0;
}
#ifdef __IAG_BLE_INCLUDE__
app_ble_inform_music_switch(rb_ctl_context.curr_song_idx);
#endif
rb_thread_post_msg(RB_MODULE_EVT_PLAY,0 );
break;
case RB_MODULE_EVT_CHANGE_VOL:
rb_ctl_vol_operation(arg);
break;
case RB_MODULE_EVT_SET_VOL:
rb_ctl_set_vol(arg);
break;
case RB_MODULE_EVT_CHANGE_IDLE:
rb_ctl_stop_play();
rb_ctl_context.status = RB_CTL_IDLE;
break;
case RB_MODULE_EVT_PLAY_IDX:
if(arg > sd_playlist.total_songs -1 ) {
break;
}
if( rb_ctl_context.status == RB_CTL_PLAYING) {
rb_thread_post_msg(RB_MODULE_EVT_STOP,0 );
} else if( rb_ctl_context.status == RB_CTL_SUSPEND) {
rb_thread_post_msg(RB_MODULE_EVT_STOP,0 );
} else {
}
rb_ctl_context.curr_song_idx = (uint16_t)arg;
rb_thread_post_msg(RB_MODULE_EVT_PLAY,0 );
break;
//for voice cocah
#if 0
case SBCREADER_ACTION_INIT:
//prepare fs
voiceCocah_prepare_fs();
//init the data buff
voiceCocah_read_sbc_data();
break;
case SBCREADER_ACTION_RUN:
//fill sbc queue
voiceCocah_read_sbc_data();
break;
case SBCREADER_ACTION_STOP:
//release the res
voiceCocah_stop_clean();
rb_ctl_reset_priority();
break;
#endif
#ifdef __TWS__
case RB_MODULE_EVT_RESTORE_DUAL_PLAY:
extern void rb_restore_dual_play(uint8_t stream_type);
rb_restore_dual_play(arg);
break;
#endif
case RB_MODULE_EVT_DEL_FILE:
static rb_ctl_status prev_status = rb_ctl_context.status;
if( rb_ctl_context.status == RB_CTL_PLAYING) {
rb_thread_post_msg(RB_MODULE_EVT_STOP,0 );
rb_thread_post_msg(RB_MODULE_EVT_DEL_FILE,arg);
} else if( rb_ctl_context.status == RB_CTL_SUSPEND) {
rb_thread_post_msg(RB_MODULE_EVT_STOP,0 );
rb_thread_post_msg(RB_MODULE_EVT_DEL_FILE,arg);
} else {
app_ctl_remove_file(arg);
if(prev_status == RB_CTL_PLAYING) {
rb_thread_post_msg(RB_MODULE_EVT_PLAY,0 );
}
}
break;
#if defined(TWS_LINEIN_PLAYER)
case RB_MODULE_EVT_LINEIN_START:
extern int app_linein_codec_start(void);
app_linein_codec_start();
break;
case RB_MODULE_EVT_RECONFIG_STREAM:
extern void rb_tws_reconfig_stream(uint32_t arg);
rb_tws_reconfig_stream(arg);
break;
case RB_MODULE_EVT_SET_TWS_MODE:
break;
#endif
#ifdef SBC_RECORD_TEST
case SBC_RECORD_ACTION_START:
{
rb_ctl_context.sbc_record_on = true;
app_rbplay_set_store_flag(true);
app_rbplay_open_sbc_file();
}
break;
case SBC_RECORD_ACTION_DATA_IND:
{
if(rb_ctl_context.sbc_record_on) {
app_rbplay_process_sbc_data();
}
}
break;
case SBC_RECORD_ACTION_STOP:
{
rb_ctl_context.sbc_record_on = false;
app_rbplay_set_store_flag(false);
app_rbplay_close_sbc_file();
}
break;
#endif
default:
break;
}
if(SBC_RECORD_ACTION_DATA_IND !=msg_body->evt)
_LOG_DBG(3,"%s rbcodec evt %d ,st %d ended\n",__func__,msg_body->evt,rb_ctl_context.status);
return 0;
}
int rb_thread_post_msg(RB_MODULE_EVT evt,uint32_t arg )
{
int ret;
RBCTL_MSG_BLOCK msg;
if(!rb_ctl_tid)
return 0;
/* APIs */
msg.evt = (uint32_t)evt;
msg.arg = (uint32_t)arg;
ret = rb_ctl_mailbox_put(&msg);
_LOG_DBG(3,"%s ret %d evt:%d\n",__func__,ret ,evt);
return 0;
}
void app_wait_player_stoped(void )
{
while(rb_ctl_context.status != RB_CTL_IDLE)
osThreadYield();
}
void app_wait_player_suspend(void )
{
if(rb_ctl_context.status == RB_CTL_IDLE)
return;
while(rb_ctl_context.status != RB_CTL_SUSPEND)
osThreadYield();
}
void app_wait_player_resumed(void )
{
if(rb_ctl_context.status == RB_CTL_IDLE)
return;
while(rb_ctl_context.status != RB_CTL_PLAYING)
osThreadYield();
}
void rb_thread_send_play(void )
{
_LOG_DBG(1," %s ",__FUNCTION__);
rb_thread_post_msg(RB_MODULE_EVT_PLAY, (uint32_t)osThreadGetId());
}
void rb_thread_send_stop(void )
{
_LOG_DBG(1," %s ",__FUNCTION__);
rb_thread_post_msg(RB_MODULE_EVT_STOP, (uint32_t)osThreadGetId());
osDelay(200);
app_wait_player_stoped();
}
void rb_thread_send_pause(void)
{
_LOG_DBG(1," %s ",__FUNCTION__);
rb_thread_post_msg(RB_MODULE_EVT_SUSPEND,(uint32_t)osThreadGetId());
app_wait_player_suspend();
_LOG_DBG(1," %s end",__FUNCTION__);
}
void rb_thread_send_resume(void)
{
_LOG_DBG(1," %s ",__FUNCTION__);
rb_thread_post_msg(RB_MODULE_EVT_RESUME,(uint32_t)osThreadGetId());
_LOG_DBG(1," %s end",__FUNCTION__);
}
void rb_play_dual_play_restore(uint8_t stream_type )
{
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
rb_thread_post_msg(RB_MODULE_EVT_RESTORE_DUAL_PLAY, stream_type);
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
}
void rb_thread_send_switch(bool next)
{
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
rb_thread_post_msg(RB_MODULE_EVT_PLAY_NEXT,next);
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
}
void rb_play_linein_start(void )
{
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
rb_thread_post_msg(RB_MODULE_EVT_LINEIN_START, 0);
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
}
void rb_play_reconfig_stream(uint32_t arg )
{
_LOG_DBG(3,"%s %d arg:0x%x\n", __func__, __LINE__, arg);
rb_thread_post_msg(RB_MODULE_EVT_RECONFIG_STREAM, arg);
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
}
void rb_play_set_tws_mode(uint32_t arg )
{
_LOG_DBG(3,"%s %d arg:0x%x\n", __func__, __LINE__, arg);
rb_thread_post_msg(RB_MODULE_EVT_SET_TWS_MODE, arg);
_LOG_DBG(2,"%s %d \n", __func__, __LINE__);
}
void rb_thread_send_play_idx(uint32_t array_subidx)
{
_LOG_DBG(2," %s array_subidx %d, ",__FUNCTION__,array_subidx);
rb_thread_post_msg(RB_MODULE_EVT_PLAY_IDX,array_subidx);
}
void rb_thread_send_vol(bool inc)
{
_LOG_DBG(2," %s inc %d, ",__FUNCTION__,inc);
rb_thread_post_msg(RB_MODULE_EVT_CHANGE_VOL,inc);
}
void rb_thread_send_status_change(void )
{
_LOG_DBG(1," %s , ",__FUNCTION__);
rb_thread_post_msg(RB_MODULE_EVT_CHANGE_IDLE,0);
}
void rb_thread_set_vol(uint32_t vol)
{
_LOG_DBG(1," %s , ",__FUNCTION__);
rb_thread_post_msg(RB_MODULE_EVT_SET_VOL, vol);
}
void rb_thread_send_del_file(uint16_t idx )
{
_LOG_DBG(1," %s , ",__FUNCTION__);
rb_thread_post_msg(RB_MODULE_EVT_DEL_FILE,idx);
}
void rb_thread_send_sbc_record_start(void )
{
_LOG_DBG(1," %s , ",__FUNCTION__);
rb_thread_post_msg(SBC_RECORD_ACTION_START,(uint32_t)osThreadGetId());
}
void rb_thread_send_sbc_record_data_ind(void )
{
if(!rb_ctl_context.sbc_record_on)
return ;
// _LOG_DBG(1," %s , ",__FUNCTION__);
rb_thread_post_msg(SBC_RECORD_ACTION_DATA_IND,(uint32_t)osThreadGetId());
}
void rb_thread_send_sbc_record_stop(void )
{
_LOG_DBG(1," %s , ",__FUNCTION__);
rb_thread_post_msg(SBC_RECORD_ACTION_STOP,(uint32_t)osThreadGetId());
}
//interface for audio module
static bool user_key_pause_stream = false;
void app_rbplay_audio_reset_pause_status(void)
{
user_key_pause_stream = false;
}
int app_rbplay_audio_onoff(bool onoff, uint16_t aud_id)
{
_LOG_DBG(3," %s onoff %d, get status:%d",__FUNCTION__,onoff, rb_ctl_get_status());
if(app_rbcodec_check_hfp_active()&& !onoff) {
if( RB_CTL_PLAYING == rb_ctl_get_status()) {
rb_thread_send_pause();
}
} else if ( !onoff) {
//rb_thread_send_stop();
rb_thread_send_pause();
} else {
if(!user_key_pause_stream) {
if( RB_CTL_SUSPEND == rb_ctl_get_status()) {
rb_thread_send_resume();
app_wait_player_resumed();
} else {
rb_thread_send_play();
}
}
}
return 0;
}
void app_rbplay_pause_resume(void)
{
_LOG_DBG(2," %s get status:%d",__func__, rb_ctl_get_status());
user_key_pause_stream = true;
if( RB_CTL_SUSPEND == rb_ctl_get_status()) {
user_key_pause_stream = false;
rb_thread_send_resume();
}
if( RB_CTL_PLAYING == rb_ctl_get_status()) {
user_key_pause_stream = true;
rb_thread_send_pause();
}
}
//sbc reader run within thread
static int rb_ctl_mailbox_init(void)
{
rb_ctl_mailbox = osMailCreate(osMailQ(rb_ctl_mailbox), NULL);
if (rb_ctl_mailbox == NULL) {
TRACE(0,"Failed to Create rb_ctl_mailbox\n");
return -1;
}
return 0;
}
int rb_ctl_mailbox_put(RBCTL_MSG_BLOCK* msg_src)
{
osStatus status;
RBCTL_MSG_BLOCK *msg_p = NULL;
msg_p = (RBCTL_MSG_BLOCK*)osMailAlloc(rb_ctl_mailbox, 0);
if(!msg_p) {
TRACE(3,"%s fail, evt:%d,arg=%d \n",__func__,msg_src->evt,msg_src->arg);
return -1;
}
ASSERT(msg_p, "osMailAlloc error");
msg_p->evt = msg_src->evt;
msg_p->arg = msg_src->arg;
status = osMailPut(rb_ctl_mailbox, msg_p);
return (int)status;
}
int rb_ctl_mailbox_free(RBCTL_MSG_BLOCK* msg_p)
{
osStatus status;
status = osMailFree(rb_ctl_mailbox, msg_p);
return (int)status;
}
int rb_ctl_mailbox_get(RBCTL_MSG_BLOCK** msg_p)
{
osEvent evt;
evt = osMailGet(rb_ctl_mailbox, osWaitForever);
if (evt.status == osEventMail) {
*msg_p = (RBCTL_MSG_BLOCK *)evt.value.p;
return 0;
}
return -1;
}
#if 0
void rb_ctl_action_init(void)
{
bool ind = voiceCocah_get_indication();
TRACE(2," %s Cocah %d",__func__,ind);
if( !ind) return ;
// rb_ctl_set_priority(osPriorityHigh);
rb_thread_post_msg(SBCREADER_ACTION_INIT,(uint32_t)osThreadGetId());
}
void rb_ctl_action_run(void)
{
bool ind = voiceCocah_get_indication();
TRACE(2," %s Cocah %d",__func__,ind);
if( !ind) return ;
rb_thread_post_msg(SBCREADER_ACTION_RUN,(uint32_t)osThreadGetId());
}
void rb_ctl_action_stop(void)
{
bool ind = voiceCocah_get_indication();
TRACE(2," %s Cocah %d",__func__,ind);
if( !ind) return ;
rb_thread_post_msg(SBCREADER_ACTION_STOP,(uint32_t)osThreadGetId());
}
#endif
static void rb_ctl_thread(void const *argument)
{
osEvent evt;
#if 1
app_sysfreq_req(APP_SYSFREQ_USER_APP_PLAYER, APP_SYSFREQ_208M);
app_rbplay_load_playlist(&sd_playlist);
#endif
memset(&rb_ctl_context,0x0,sizeof(rb_ctl_struct));
rb_ctl_context.rb_player_vol = 6;
rb_ctl_context.status = RB_CTL_IDLE;
rb_ctl_context.curr_song_idx = 0;
//load playlist here
//voiceCocah_init();
rb_ctl_context.init_done = true;
while(1) {
RBCTL_MSG_BLOCK *msg_p = NULL;
app_sysfreq_req(APP_SYSFREQ_USER_APP_PLAYER, APP_SYSFREQ_32K);
if (!rb_ctl_mailbox_get(&msg_p)) {
app_sysfreq_req(APP_SYSFREQ_USER_APP_PLAYER, APP_SYSFREQ_104M);
rb_ctl_handle_event(msg_p);
rb_ctl_mailbox_free(msg_p);
}
}
}
int rb_ctl_init(void)
{
_LOG_DBG(1,"%s \n",__func__);
rb_ctl_context.init_done = false;
rb_ctl_context.sbc_record_on = false;
app_rbplay_open();
rb_ctl_mailbox_init();
rb_ctl_tid = osThreadCreate(osThread(rb_ctl_thread), NULL);
rb_ctl_default_priority = osPriorityAboveNormal;
if (rb_ctl_tid == NULL) {
TRACE(0,"Failed to Create rb_ctl_thread\n");
return 0;
}
_LOG_DBG(1,"Leave %s \n",__func__);
return 0;
}
uint8_t rb_ctl_get_vol(void)
{
return rb_ctl_context.rb_player_vol;
}
bool rb_ctl_is_init_done(void)
{
return rb_ctl_context.init_done;
}
bool rb_ctl_is_paused(void)
{
return ( RB_CTL_SUSPEND == rb_ctl_get_status());
}
uint16_t rb_ctl_songs_count(void)
{
return sd_playlist.total_songs;
}
Reference in New Issue View Git Blame Copy Permalink