set(MODULE_NAME "media")
set(AUTO_DEF_FILE_ID TRUE)
add_subdirectory(foundation)
- set(COMPONENT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/component)
+ set(COMPONENT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/component/hmf_demuxer)
if (EXISTS ${COMPONENT_DIR})
add_subdirectory(${COMPONENT_DIR})
endif()
MEDIA_UNUSED(thisVal);\r
MEDIA_UNUSED(args);\r
MEDIA_UNUSED(argsSize);\r
- const char *pars[6] = { "", "", "16000", "1", "16", "/user/log/xiaodu/xiaodu.pcm" };\r
+ const char *pars[6] = { "", "opus", "16000", "1", "16", "/user/log/xiaodu/xiaodu.opus" };\r
return JSI::CreateBoolean(AudioCaptureStartSample(PARAM_NUMBER, pars));\r
}\r
\r
return JSI::CreateBoolean(0);\r
}\r
\r
+JSIValue AudioCapturerModule::Cancel(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)\r
+{\r
+ MEDIA_UNUSED(thisVal);\r
+ MEDIA_UNUSED(args);\r
+ MEDIA_UNUSED(argsSize);\r
+ msg_center_xiaodu_audio_pcm_clear_res();\r
+ return JSI::CreateBoolean(0);\r
+}\r
+\r
void AudioCapturerModule::ExceptionStop(void)\r
{\r
if (g_sample.needStop == false) {\r
{\r
JSI::SetModuleAPI(exports, "Start", AudioCapturerModule::Start);\r
JSI::SetModuleAPI(exports, "Stop", AudioCapturerModule::Stop);\r
+ JSI::SetModuleAPI(exports, "cancel", AudioCapturerModule::Cancel);\r
}\r
\r
}\r
handle exception\r
*/\r
static void ExceptionStop(void);\r
+\r
+ /**\r
+ * Cancel\r
+ */\r
+ static JSIValue Cancel(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);\r
};\r
\r
void InitAudioCapturerModule(JSIValue exports);\r
{
(void)(DISPATCHER_THREAD_PRIORITY); // Dependent chip
// stack size 0xC00: obtained from construct function deepest path scene, and upward adjust 512 bytes
- MediaThreadattr attr = { "DispatcherThread", 0xC00u, THREAD_SCHED_RR, 0, false };
+ MediaThreadattr attr = { "DispatcherThread", 0x1000u, THREAD_SCHED_RR, 0, false };
thread_ = MediaThreadCreate(ThreadLoop, dispatcher_, &attr);
if (thread_ == nullptr) {
ALOGE("thread create failed");
#define PRIORITY_8 8
#define PRIORITY_9 9
#define PRIORITY_10 10
+#define PRIORITY_11 11
-#define INPUT_STRATEGY_MAP_COLUMN_SIZE 5
-#define OUTPUT_STRATEGY_MAP_COLUMN_SIZE 11
+#define INPUT_STRATEGY_MAP_COLUMN_SIZE 6
+#define OUTPUT_STRATEGY_MAP_COLUMN_SIZE 12
static AudioDeviceType g_ringSupportDevices[] = {
OUT_BUILTIN_SPEAKER
{
.streamType = AUDIO_STREAM_VOICE_CALL_VOLTE,
.streamDir = AUDIO_STREAM_OUT_IN,
- .priority = PRIORITY_1,
+ .priority = PRIORITY_2,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_voiceCallVolteOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_RING,
.streamDir = AUDIO_STREAM_OUT,
- .priority = PRIORITY_2,
+ .priority = PRIORITY_3,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_ringSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_TTS,
.streamDir = AUDIO_STREAM_OUT,
- .priority = PRIORITY_3,
+ .priority = PRIORITY_4,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_commonOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_VOICE_ASSISTANT,
.streamDir = AUDIO_STREAM_OUT_IN,
- .priority = PRIORITY_4,
+ .priority = PRIORITY_5,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_commonOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_ALARM_CLOCK,
.streamDir = AUDIO_STREAM_OUT,
- .priority = PRIORITY_5,
+ .priority = PRIORITY_6,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_commonOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_FITNESS_VIDEO,
.streamDir = AUDIO_STREAM_OUT,
- .priority = PRIORITY_6,
+ .priority = PRIORITY_7,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_fitnessVideoSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_NOTIFICATION_SYSTEM,
.streamDir = AUDIO_STREAM_OUT,
- .priority = PRIORITY_7,
+ .priority = PRIORITY_8,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_commonOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_NOTIFICATION_PROMPT,
.streamDir = AUDIO_STREAM_OUT,
- .priority = PRIORITY_8,
+ .priority = PRIORITY_9,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_commonOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_MUSIC,
.streamDir = AUDIO_STREAM_OUT,
- .priority = PRIORITY_9,
+ .priority = PRIORITY_10,
.routeAllDevices = false,
.needResume = true,
.supportDeviceCount = sizeof(g_commonOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_A2DP_MUSIC,
.streamDir = AUDIO_STREAM_OUT_IN,
- .priority = PRIORITY_10,
+ .priority = PRIORITY_11,
.routeAllDevices = false,
.needResume = true,
.supportDeviceCount = sizeof(g_commonOutputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_VOICE_CALL_VOLTE,
.streamDir = AUDIO_STREAM_OUT_IN,
- .priority = PRIORITY_0,
+ .priority = PRIORITY_1,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_voiceCallVolteInputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_VOICE_ASSISTANT,
.streamDir = AUDIO_STREAM_OUT_IN,
- .priority = PRIORITY_1,
+ .priority = PRIORITY_2,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_commonInputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_VOICE_RECORD,
.streamDir = AUDIO_STREAM_IN,
- .priority = PRIORITY_2,
+ .priority = PRIORITY_3,
.routeAllDevices = false,
.needResume = false,
.supportDeviceCount = sizeof(g_commonInputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_VOICE_RECOGNITION,
.streamDir = AUDIO_STREAM_IN,
- .priority = PRIORITY_3,
+ .priority = PRIORITY_4,
.routeAllDevices = false,
.needResume = true,
.supportDeviceCount = sizeof(g_commonInputSupportDevices) / sizeof(AudioDeviceType),
{
.streamType = AUDIO_STREAM_A2DP_MUSIC,
.streamDir = AUDIO_STREAM_OUT_IN,
- .priority = PRIORITY_4,
+ .priority = PRIORITY_5,
.routeAllDevices = false,
.needResume = true,
.supportDeviceCount = sizeof(g_musicInputSupportDevices) / sizeof(AudioDeviceType),
};
static AudioStrategy g_defaultPriorityToStrategies[][OUTPUT_STRATEGY_MAP_COLUMN_SIZE] = {
- {STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_REJECT,
+ {STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_REJECT,
STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_DELAY, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_REJECT,
+ {STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_REJECT,
STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_DELAY, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_REJECT,
+ {STRATEGY_EXCLUSIVE, STRATEGY_REJECT, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT,
+ STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_DELAY, STRATEGY_DELAY},
+ {STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_REJECT,
STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_DELAY, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT,
STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_DELAY, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE,
STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_MIX},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_NONE, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_MIX},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_NONE, STRATEGY_MIX, STRATEGY_MIX},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_NONE, STRATEGY_EXCLUSIVE},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE,
STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_MIX, STRATEGY_REJECT, STRATEGY_NONE},
};
static AudioStrategy g_defaultInputPriorityToStrategies[][INPUT_STRATEGY_MAP_COLUMN_SIZE] = {
- {STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_MIX},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_DELAY},
- {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_EXCLUSIVE, STRATEGY_NONE},
+ {STRATEGY_NONE, STRATEGY_EXCLUSIVE, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_DELAY},
+ {STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_DELAY},
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_REJECT, STRATEGY_DELAY},
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_REJECT, STRATEGY_MIX},
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_NONE, STRATEGY_DELAY},
+ {STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_EXCLUSIVE, STRATEGY_MIX, STRATEGY_EXCLUSIVE, STRATEGY_NONE},
};
#endif // AUDIO_BASE_H
static AudioStreamStrategy *GetStrategyForStreamResume(const AudioStreamDescriptor *streamDesc, bool isOutput)
{
+ CHK_NULL_RETURN(streamDesc, NULL, "streamDesc is NULL");
ResetActiveStreams();
/* 获取流和对应的混音权重 */
if (!InterruptMgrGetActiveStream(&g_policyMgrCtx.streamStrategy, streamDesc->streamType, isOutput)) {
static int32_t UpdateMixWeigthWhenResume(TrackHandleContext *context)
{
+ AudioStreamDescriptor newStreamDesc = {context->streamId, context->streamInfo.streamType,
+ context->typeVolume, context->streamInfo.linkDir};
AudioStreamStrategy *strategy = PolicyMgrGetStrategyForStream(context->streamInfo.sessionID,
- NULL, STREAM_OUT_RESUME);
+ &newStreamDesc, STREAM_OUT_RESUME);
CHK_NULL_RETURN(strategy, false, "strategy is NULL");
// 检查
bool find = false;
MEDIA_ERR_LOG("SetUriSource failed, uri source do not set uri parameter");
return -1;
}
- char filePath[PATH_MAX];
+ if (uri.find("http") != 0) {
+ char filePath[PATH_MAX];
#if !defined(_WIN32)
- if (realpath(uri.c_str(), filePath) == nullptr) {
+ if (realpath(uri.c_str(), filePath) == nullptr) {
#else
- if (_fullpath(filePath, uri.c_str(), PATH_MAX) == nullptr) {
+ if (_fullpath(filePath, uri.c_str(), PATH_MAX) == nullptr) {
#endif
- MEDIA_ERR_LOG("Realpath input file failed");
- return -1;
- }
- if (access(filePath, R_OK) == -1) {
- MEDIA_ERR_LOG("No permission to read the file");
- return -1;
+ MEDIA_ERR_LOG("Realpath input file failed");
+ return -1;
+ }
+ if (access(filePath, R_OK) == -1) {
+ MEDIA_ERR_LOG("No permission to read the file");
+ return -1;
+ }
}
int32_t ret = player_->SetDataSource(uri.c_str());
if (ret != 0) {
if (!params.GetStringValue(FORMAT_KEY, value)) {
MEDIA_ERR_LOG("get GetParameter key fail");
}
- if (value.compare(FORMAT_GET_ABLUM_INFO) == 0) {
+ if (value.compare(FORMAT_GET_ALBUM_INFO) == 0) {
if (formatFileInfo_.albumInfoCnt == 0 || formatFileInfo_.albumInfo == nullptr) {
goto EXIT;
}
*/
static JSIValue BackgroundPlayGetter(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+ /**
+ *the GetAlbumInfo method of audio.
+ *
+ * @param thisVal Indicates function execute context
+ * @param args Indicates the function arguments
+ * @param argsSize Indicates the size of function arguments
+ */
+ static JSIValue GetAlbumInfo(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
+
private:
+ static void SuccessCallBack(const JSIValue thisVal, const JSIValue args, JSIValue outputValue);
+
+ static void FailCallBack(const JSIValue thisVal, const JSIValue args, const char *errStr);
+
static JSIValue GetEventCallback(const AudioEventListener *listener);
static AudioEventListener *CreateAudioEventListener(const JSIValue *args, uint8_t argsSize);
+
+ static bool CheckInputParam(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize);
};
/*
int32_t GetSrcInnerPrefix(const char *src, char *dest);
bool IsSysSrc();
+
+ void GetAlbumInfo(AudioPlayerAlbumInfo &albumInfo, const char *src);
+
private:
AudioPlayer();
~AudioPlayer();
namespace OHOS {
namespace ACELite {
constexpr char PROP_SUCCESS[] = "success";
+constexpr char PROP_FAIL[] = "fail";
constexpr char PROP_COMPLETE[] = "complete";
+constexpr char ALBUMINFO_SOURCE[] = "src";
+constexpr char ALBUMINFO_TITLE[] = "title";
+constexpr char ALBUMINFO_ARTIST[] = "artist";
constexpr char DECRYPT_FILE_PATH[] = "/user/app/user/ace/data/%s/rawfile/lib/audio_decode.bin";
constexpr uint32_t MAX_PATH_LEN = 256;
constexpr char PATH_PREFIX[] = "internal://";
static AudioStreamType g_streamType = AUDIO_STREAM_MUSIC;
+void AudioModule::SuccessCallBack(const JSIValue thisVal, const JSIValue args, JSIValue outputValue)
+{
+ if (JSI::ValueIsUndefined(args)) {
+ return;
+ }
+ JSIValue successCB = JSI::GetNamedProperty(args, PROP_SUCCESS);
+ if (!JSI::ValueIsUndefined(successCB)) {
+ if (!JSI::ValueIsUndefined(outputValue)) {
+ JSI::CallFunction(successCB, thisVal, &outputValue, 1);
+ } else {
+ JSI::CallFunction(successCB, thisVal, nullptr, 1);
+ }
+ }
+ JSI::ReleaseValue(successCB);
+}
+
+void AudioModule::FailCallBack(const JSIValue thisVal, const JSIValue args, const char *errStr)
+{
+ if (JSI::ValueIsUndefined(args)) {
+ return;
+ }
+ JSIValue failCB = JSI::GetNamedProperty(args, PROP_FAIL);
+ if (!JSI::ValueIsUndefined(failCB)) {
+ JSIValue errLog = JSI::CreateString(errStr);
+ JSI::CallFunction(failCB, thisVal, &errLog, 1);
+ JSI::ReleaseValue(errLog);
+ }
+ JSI::ReleaseValue(failCB);
+}
+
void AudioModule::OnTerminate()
{
AudioPlayer *audioPlayer = AudioPlayer::GetInstance();
return JSI::CreateBoolean(ret);
}
+bool AudioModule::CheckInputParam(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)
+{
+ if (argsSize < 1 || args == nullptr) {
+ MEDIA_ERR_LOG("invalid input parameter.");
+ return false;
+ }
+ if (!JSI::ValueIsObject(args[0])) {
+ MEDIA_ERR_LOG("invalid input parameter.");
+ return false;
+ }
+ return true;
+}
+
+JSIValue AudioModule::GetAlbumInfo(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)
+{
+ if (!CheckInputParam(thisVal, args, argsSize)) {
+ return JSI::CreateBoolean(false);
+ }
+ JSIValue srcListArray = JSI::AcquireValue(args[1]);
+ if (!JSI::ValueIsArray(srcListArray)) {
+ FailCallBack(thisVal, args[0], "src List is required.");
+ JSI::ReleaseValue(srcListArray);
+ return JSI::CreateBoolean(false);
+ }
+ uint32_t srcListLen = JSI::GetArrayLength(srcListArray);
+ JSIValue params = JSI::CreateArray(srcListLen);
+ if (!JSI::ValueIsArray(params)) {
+ FailCallBack(thisVal, args[0], "get output params failed.");
+ JSI::ReleaseValue(params);
+ return JSI::CreateBoolean(false);
+ }
+ for (uint32_t index = 0; index < srcListLen; ++index) {
+ AudioPlayerAlbumInfo albumInfo = {"", "", ""};
+ JSIValue src = JSI::GetPropertyByIndex(srcListArray, index);
+ char *strValue = JSI::JSIValueToString(src);
+ JSIValue data = JSI::CreateObject();
+ AudioPlayer::GetInstance()->GetAlbumInfo(albumInfo, strValue);
+ JSI::SetStringProperty(data, ALBUMINFO_SOURCE, albumInfo.src.c_str());
+ JSI::SetStringProperty(data, ALBUMINFO_TITLE, albumInfo.title.c_str());
+ JSI::SetStringProperty(data, ALBUMINFO_ARTIST, albumInfo.artist.c_str());
+ JSI::SetPropertyByIndex(params, index, data);
+ JSI::ReleaseValue(data);
+ JSI::ReleaseString(strValue);
+ }
+ SuccessCallBack(thisVal, args[0], params);
+ JSI::ReleaseValueList(params);
+ return JSI::CreateBoolean(true);
+}
+
JSIValue AudioModule::CurrentTimeGetter(const JSIValue thisVal, const JSIValue *args, uint8_t argsSize)
{
MEDIA_UNUSED(thisVal);
return isSysSrc_;
}
+void AudioPlayer::GetAlbumInfo(AudioPlayerAlbumInfo &albumInfo, const char *src)
+{
+ AudioPlayerService::GetInstance()->GetAlbumInfo(albumInfo, src);
+}
+
} // namespace ACELite
} // namespace OHOS
)
set(OPENMG_DIR ${ROOT_DIR}/open_source/openharmony)
-
+set(OGG_INCLUDE ${OPENMG_DIR}/../libogg/libogg-1.3.5/include)
set(PRIVATE_HEADER
${CMAKE_CURRENT_SOURCE_DIR}/../../audiomanager/interfaces/kits/audiomanager
${CMAKE_CURRENT_SOURCE_DIR}/../../audiomanager/frameworks/audiostream/include
${OPENMG_DIR}/drivers/peripheral/display/interfaces/include
${ROOT_DIR}/include/middleware/services/bts/br
${ROOT_DIR}/include/middleware/services/bts/common
+ ${OGG_INCLUDE}
+ ${OGG_INCLUDE}/ogg/
)
if ("ENABLE_LVGL" IN_LIST DEFINES)
set(LVGL_DIR ${ROOT_DIR}/middleware/services/gui/lvgl)
#include <stdio.h>
#include <string.h>
#include <climits>
-#include <stdlib.h>
+#include <cstdlib>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include "audio_manager.h"
#include "media_log.h"
#include "media_thread_adapt.h"
+#include "ogg.h"
#ifdef __cplusplus
extern "C" {
using namespace OHOS::Media;
using namespace OHOS::Audio;
-using namespace::Audio;
+using namespace Audio;
using Audio::InterruptListener;
using Audio::AudioInterrupt;
using Audio::AudioManager;
#define READ_COUNT_MAX 17000*2 //改过的 20分钟
#define GET_AUDIO_TIME_INTERVAL_TIMES 100
#define MAX_ARGC 5
+#define CHK_NULL_RETURN(ptr, printfString) \
+do { \
+ if ((ptr) == nullptr) { \
+ MEDIA_ERR_LOG("%s", printfString); \
+ return MEDIA_ERR; \
+ } \
+} while (0)
+#define CHK_OK_RETURN(ret, printfString) \
+do { \
+ if ((ret) != MEDIA_OK || (ret) != 0) { \
+ MEDIA_ERR_LOG("%s", printfString); \
+ return MEDIA_ERR; \
+ } \
+} while (0)
+const uint32_t MILLSECOND_TO_SECOND = 1000;
+const uint32_t HEADER_STRLEN = 8;
+const uint32_t OPUS_DELAY_TIME_DIVISOR = 0;
+const uint32_t OPUS_DELAY_TIME_DIVIDED = 100;
+const uint32_t OPUS_ID_HEADER_LEN = 19;
+const uint32_t OPUS_COMMENT_HEADER_LEN = 25;
+const uint32_t OPUS_COMMENT_TAIL_LEN = 4;
+const uint32_t OPUS_ENCODE_HEADER_SIZE = 8;
+const uint32_t OPUS_OPUSTAGS_LEN = 12;
+const uint32_t OPUS_SAMPLERATE = 48000;
typedef struct {
size_t framesize;
AudioSession sessionID = AUDIO_SESSION_ID_NONE;
};
+typedef struct CaptureOggContext{
+ ogg_stream_state oggStream;
+ int64_t sampleRate;
+ int64_t channels;
+ int64_t granulepos;
+ int64_t packetCount;
+ int32_t serialno;
+ bool isEnd;
+ ogg_page *page;
+ ogg_packet *packet;
+ unsigned char *idHeader;
+ unsigned char *commentHeader;
+} CaptureOggContext;
+
+static CaptureOggContext g_oggCtx = {};
static bool g_interruptHintStop = false;
static std::shared_ptr<AudioCapturer> g_audioCap;
static NameAudioFormat g_audioCodecFormat[] = {
MEDIA_INFO_LOG("OnInterrupt resume not supported");
}
if (type == INTERRUPT_TYPE_BEGIN && hint == INTERRUPT_HINT_STOP) {
+ MEDIA_INFO_LOG("OnInterrupt stop");
g_interruptHintStop = true;
}
if (type == INTERRUPT_TYPE_END && hint == INTERRUPT_HINT_STOP) {
static TestSample g_sample;
static std::shared_ptr<CaptureInterruptListener> g_captureInterruptListener;
+static void MediaMemFree(void **src)
+{
+ if (src == nullptr || *src == nullptr) {
+ MEDIA_ERR_LOG("%s", "don't need to free!");
+ return;
+ }
+ free(*src);
+ *src = nullptr;
+}
+
+static void *MediaMemCalloc(const size_t bytesNum)
+{
+ void *tmp = malloc(bytesNum);
+
+ if (tmp == nullptr) {
+ MEDIA_ERR_LOG("%s", "malloc failed!");
+ return nullptr;
+ }
+
+ if (memset_s(tmp, bytesNum, 0, bytesNum) != EOK) {
+ MEDIA_ERR_LOG("%s", "memset_s failed!");
+ MediaMemFree(&tmp);
+ return nullptr;
+ }
+ return tmp;
+}
+
+static int32_t AudioCapturerOggHeaderInit(SampleAudioCapturerInfo &info)
+{
+ g_oggCtx.idHeader = static_cast<unsigned char*>(MediaMemCalloc(OPUS_ID_HEADER_LEN));
+ CHK_NULL_RETURN(g_oggCtx.idHeader, "malloc failed!");
+ if (memcpy_s(g_oggCtx.idHeader, HEADER_STRLEN, "OpusHead", HEADER_STRLEN) != 0) {
+ MEDIA_ERR_LOG("memcpy failed!");
+ return MEDIA_ERR;
+ }
+ g_oggCtx.idHeader[0x8] = 0x01;
+ g_oggCtx.idHeader[0x9] = info.channelCount;
+ uint32_t preSkip = g_oggCtx.sampleRate * OPUS_DELAY_TIME_DIVISOR / OPUS_DELAY_TIME_DIVIDED;
+ g_oggCtx.idHeader[0xA] = preSkip & 0xFF;
+ g_oggCtx.idHeader[0xB] = (preSkip >> 0x8); // 8 for Little-endian byte order
+ g_oggCtx.idHeader[0xC] = g_oggCtx.sampleRate & 0xFF;
+ g_oggCtx.idHeader[0xD] = (g_oggCtx.sampleRate >> 0x8) & 0xFF; // 8 for Little-endian byte order
+ g_oggCtx.idHeader[0xE] = (g_oggCtx.sampleRate >> 0x10) & 0xFF; // 16 for Little-endian byte order
+ g_oggCtx.idHeader[0xF] = (g_oggCtx.sampleRate >> 0x18) & 0xFF; // 24 for Little-endian byte order
+
+ g_oggCtx.commentHeader = static_cast<unsigned char*>(MediaMemCalloc(OPUS_COMMENT_HEADER_LEN));
+ CHK_NULL_RETURN(g_oggCtx.commentHeader, "malloc failed!");
+ if (memcpy_s(g_oggCtx.commentHeader, HEADER_STRLEN, "OpusTags", HEADER_STRLEN) != 0) {
+ MEDIA_ERR_LOG("Opus idHeader memcpy failed!");
+ return MEDIA_ERR;
+ }
+ const char *vendor = "libogg-1.3.5";
+ uint32_t vendorLen = std::strlen(vendor);
+ g_oggCtx.commentHeader[0x8] = vendorLen & 0xFF;
+ g_oggCtx.commentHeader[0x9] = (vendorLen >> 0x8) & 0xFF; // 8 for Little-endian byte order
+ g_oggCtx.commentHeader[0xA] = (vendorLen >> 0x10) & 0xFF; // 16 for Little-endian byte order
+ g_oggCtx.commentHeader[0xB] = (vendorLen >> 0x18) & 0xFF; // 24 for Little-endian byte order
+
+ if (memcpy_s(g_oggCtx.commentHeader + OPUS_OPUSTAGS_LEN, vendorLen, vendor, vendorLen) != 0) {
+ MEDIA_ERR_LOG("Opus commentHeader memcpy failed!");
+ return MEDIA_ERR;
+ }
+ return MEDIA_OK;
+}
+
+static int32_t AudioCaptureOggStreamFlush(FILE *pfd)
+{
+ while (ogg_stream_flush(&g_oggCtx.oggStream, g_oggCtx.page)) {
+ int32_t ret = fwrite(g_oggCtx.page->header, 1, g_oggCtx.page->header_len, pfd);
+ if (ret != g_oggCtx.page->header_len) {
+ MEDIA_ERR_LOG("errno:%d, errmsg:%s", errno, strerror(errno));
+ return MEDIA_ERR;
+ }
+ ret = fwrite(g_oggCtx.page->body, 1, g_oggCtx.page->body_len, pfd);
+ if (ret != g_oggCtx.page->body_len) {
+ MEDIA_ERR_LOG("errno:%d, errmsg:%s", errno, strerror(errno));
+ return MEDIA_ERR;
+ }
+ }
+ return MEDIA_OK;
+}
+
+static int32_t AudioCapturerOggCtxInit(FILE *pfd, SampleAudioCapturerInfo &info)
+{
+ g_oggCtx.packet = (ogg_packet *)MediaMemCalloc(sizeof(ogg_packet));
+ CHK_NULL_RETURN(g_oggCtx.packet, "malloc failed!");
+ g_oggCtx.page = (ogg_page *)MediaMemCalloc(sizeof(ogg_page));
+ CHK_NULL_RETURN(g_oggCtx.page, "malloc failed!");
+ g_oggCtx.sampleRate = info.sampleRate;
+ g_oggCtx.channels = info.channelCount;
+ g_oggCtx.granulepos = -1; // -1 means start page
+ g_oggCtx.packetCount = 0;
+ g_oggCtx.isEnd = false;
+ g_oggCtx.serialno = 0x1; // unique serialno
+ CHK_OK_RETURN(ogg_stream_init(&g_oggCtx.oggStream, g_oggCtx.serialno), "ogg stream init failed");
+ CHK_OK_RETURN(AudioCapturerOggHeaderInit(info), "Header init failed!");
+ g_oggCtx.packet->packet = g_oggCtx.idHeader;
+ g_oggCtx.packet->bytes = OPUS_ID_HEADER_LEN;
+ g_oggCtx.packet->b_o_s = 1; // 1 means begining of ogg stream
+ g_oggCtx.packet->e_o_s = 0;
+ g_oggCtx.packet->granulepos = g_oggCtx.granulepos;
+ g_oggCtx.packetCount = g_oggCtx.packetCount;
+ g_oggCtx.packet->packetno = g_oggCtx.packetCount++;
+ g_oggCtx.granulepos = 0;
+ ogg_stream_packetin(&g_oggCtx.oggStream, g_oggCtx.packet);
+ CHK_OK_RETURN(AudioCaptureOggStreamFlush(pfd), "flush failed!");
+ g_oggCtx.packet->packet = g_oggCtx.commentHeader;
+ g_oggCtx.packet->bytes = OPUS_COMMENT_HEADER_LEN;
+ g_oggCtx.packet->b_o_s = 0;
+ g_oggCtx.packet->e_o_s = 0;
+ g_oggCtx.packet->granulepos = 0;
+ g_oggCtx.packet->packetno = g_oggCtx.packetCount++;
+ ogg_stream_packetin(&g_oggCtx.oggStream, g_oggCtx.packet);
+ CHK_OK_RETURN(AudioCaptureOggStreamFlush(pfd), "flush failed!");
+ return MEDIA_OK;
+}
+
+static void AudioCapturerOggCtxDeInit()
+{
+ g_oggCtx.sampleRate = 0;
+ g_oggCtx.channels = 0;
+ g_oggCtx.granulepos = 0;
+ g_oggCtx.packetCount = 0;
+ MediaMemFree((void **)&g_oggCtx.packet);
+ MediaMemFree((void **)&g_oggCtx.page);
+ MediaMemFree((void **)&g_oggCtx.idHeader);
+ MediaMemFree((void **)&g_oggCtx.commentHeader);
+ ogg_stream_clear(&g_oggCtx.oggStream);
+}
+
static void AudioCaptureStop()
{
MediaMutexLock(g_sample.mutex);
(void)MediaMutexDestroy(&g_sample.mutex);
}
+static int32_t AudioCaptureWritePage(FILE *pfd)
+{
+ if (ogg_stream_pageout(&g_oggCtx.oggStream, g_oggCtx.page)) {
+ int32_t ret = fwrite(g_oggCtx.page->header, 1, g_oggCtx.page->header_len, pfd);
+ if (ret != g_oggCtx.page->header_len) {
+ MEDIA_ERR_LOG("errno:%d, errmsg:%s", errno, strerror(errno));
+ return MEDIA_ERR;
+ }
+ ret = fwrite(g_oggCtx.page->body, 1, g_oggCtx.page->body_len, pfd);
+ if (ret != g_oggCtx.page->body_len) {
+ MEDIA_ERR_LOG("errno:%d, errmsg:%s", errno, strerror(errno));
+ return MEDIA_ERR;
+ }
+ }
+ return MEDIA_OK;
+}
+
+static int32_t AudioCapturerWriteInOGG(uint8_t *buffer, int64_t bufferLen, FILE *pfd, bool isEos)
+{
+ if (bufferLen < 0) {
+ MEDIA_ERR_LOG("input buffer invalid");
+ return MEDIA_ERR;
+ }
+ g_oggCtx.packet->packet = (unsigned char *)(buffer + OPUS_ENCODE_HEADER_SIZE);
+ g_oggCtx.packet->bytes = bufferLen - OPUS_ENCODE_HEADER_SIZE;
+ g_oggCtx.packet->b_o_s = 0;
+ g_oggCtx.packet->e_o_s = isEos ? 1 : 0;
+ g_oggCtx.packet->granulepos = g_oggCtx.granulepos;
+ g_oggCtx.packet->packetno = g_oggCtx.packetCount++;
+ g_oggCtx.granulepos += OPUS_SAMPLERATE * 10 / MILLSECOND_TO_SECOND; //capture frequency is 10ms for each frame
+ ogg_stream_packetin(&g_oggCtx.oggStream, g_oggCtx.packet);
+ if (!isEos) {
+ return AudioCaptureWritePage(pfd);
+ } else {
+ return AudioCaptureOggStreamFlush(pfd);
+ }
+}
+
static void* AudioCaptureProcess(void* arg)
{
FILE *pfd = (FILE *)arg;
int32_t readCnt = 0;
Timestamp timeStamp;
g_audioSourceProcessInput.bThreadRun = true;
- while (!g_sample.needStop && !g_interruptHintStop) {
+ bool isEos = false;
+ while (true) {
int32_t ret = g_audioCap->Read(g_audioSourceProcessInput.buffer, g_audioSourceProcessInput.framesize, false);
- if (ret == -1) {
- MEDIA_ERR_LOG("audioCap Read failed:0x%x", ret);
+ if (ret <= 0) {
+ MEDIA_INFO_LOG("audioCap Read failed:0x%x", ret);
continue;
}
if (ret == ERR_RETRY_READ) {
usleep(READ_RETRY_TIME_US);
continue;
}
- int32_t writeLen = fwrite(g_audioSourceProcessInput.buffer, 1, ret, pfd);
- if (writeLen != ret) {
- MEDIA_ERR_LOG("errno:%d, errmsg:%s", errno, strerror(errno));
- break;
+
+ if (g_sample.needStop || g_interruptHintStop || readCnt++ > READ_COUNT_MAX ) {
+ isEos = true;
}
- if (readCnt++ > READ_COUNT_MAX) {
+
+ if (g_audioSourceProcessInput.audioFormat == OPUS) {
+ if(AudioCapturerWriteInOGG(g_audioSourceProcessInput.buffer, ret, pfd, isEos) != MEDIA_OK) {
+ MEDIA_ERR_LOG("Write file failed!");
+ break;
+ }
+ } else {
+ int32_t writeLen = fwrite(g_audioSourceProcessInput.buffer, 1, ret, pfd);
+ if (writeLen != ret) {
+ MEDIA_ERR_LOG("errno:%d, errmsg:%s", errno, strerror(errno));
+ break;
+ }
+ }
+ if (isEos) {
+ MEDIA_ERR_LOG("quit capture process");
break;
}
if (readCnt % GET_AUDIO_TIME_INTERVAL_TIMES == 0) {
}
MEDIA_INFO_LOG("audioCap Read readCnt = %d, size = %d", readCnt, ret);
}
+ if (g_audioSourceProcessInput.audioFormat == OPUS) {
+ AudioCapturerOggCtxDeInit();
+ }
fclose(pfd);
AudioCaptureStop();
MEDIA_INFO_LOG("AudioCaptureProcess end");
- return NULL;
+ return nullptr;
}
static void AudioCaptureGetFormat(const char **argv, AudioCodecFormat &audioFormat)
{
AudioCapturerInfo info = {};
ConvertCaptureInfo(info, audioCapturerInfo);
- printf("info.audioFormat = %d\n",info.audioFormat);
if (g_audioCap->SetCapturerInfo(info) != 0) {
MEDIA_ERR_LOG("Can't SetCapturerInfo");
return -1;
return -1;
}
MEDIA_INFO_LOG("GetFrameCount:%d", frameCount);
- g_audioSourceProcessInput.framesize = frameCount * info.channelCount * info.bitWidth / sizeof(uint8_t);
+ g_audioSourceProcessInput.audioFormat = info.audioFormat;
+ g_audioSourceProcessInput.framesize = frameCount * info.channelCount;
g_audioSourceProcessInput.buffer = new uint8_t[g_audioSourceProcessInput.framesize];
if (g_audioSourceProcessInput.buffer == nullptr) {
(void)g_audioCap->Release();
static int32_t CheckInputParam(int32_t argc, const char **argv)
{
+ MEDIA_UNUSED(argv);
if (argc != 0x6) { // must be 6 parameters
MEDIA_ERR_LOG("argc:%d is invalid, record start must be 6 parameters", argc);
return -1;
audioCapturerInfo.streamType = AUDIO_STREAM_VOICE_RECORD;
ret = AudioCaptureSetInfo(audioCapturerInfo);
if (ret != 0) {
- fclose(pfd);
- g_audioCap.reset();
- (void)g_amInstance.DeactivateAudioInterrupt(g_sample.interrupt);
- goto EXIT;
+ MEDIA_ERR_LOG("AudioCapture set failed");
+ goto FCLOSE_EXIT;
+ }
+ if (audioCapturerInfo.audioFormat == OPUS) {
+ ret = AudioCapturerOggCtxInit(pfd, audioCapturerInfo);
+ if (ret != 0) {
+ MEDIA_ERR_LOG("OggCtx init failed");
+ goto FCLOSE_EXIT;
+ }
}
g_sample.audioCaptureProcess = MediaThreadCreate(AudioCaptureProcess, pfd, &attr);
if (g_sample.audioCaptureProcess == nullptr) {
MEDIA_ERR_LOG("thread create failed");
- goto EXIT;
+ goto FCLOSE_EXIT;
}
return 0;
+
+FCLOSE_EXIT:
+ fclose(pfd);
+ g_audioCap.reset();
+ (void)g_amInstance.DeactivateAudioInterrupt(g_sample.interrupt);
EXIT:
g_audioSourceProcessInput.bThreadRun = false;
return -1;
AudioPlayerService::~AudioPlayerService()\r
{\r
Reset();\r
+#ifdef HMF_DECRYPT_DATA_ENABLE\r
if (loadDecryptPath_ != nullptr) {\r
delete[] loadDecryptPath_;\r
loadDecryptPath_ = nullptr;\r
loadDecryptPathLen_ = 0;\r
}\r
+#endif\r
+ if (albumInfoPlayer_ != nullptr) {\r
+ albumInfoPlayer_.reset();\r
+ albumInfoPlayer_ = nullptr;\r
+ }\r
}\r
\r
std::shared_ptr<AudioPlayerService> AudioPlayerService::GetInstance()\r
callBack_->OnStop();\r
}\r
\r
-}
\ No newline at end of file
+void AudioPlayerService::GetAlbumInfo(AudioPlayerAlbumInfo &albumInfo, const char *src)\r
+{\r
+ if (src == nullptr) {\r
+ MEDIA_ERR_LOG("src is nullptr!");\r
+ return;\r
+ }\r
+ if (albumInfoPlayer_ == nullptr) {\r
+ albumInfoPlayer_= std::make_shared<Player>();\r
+ }\r
+ albumInfo.src = src;\r
+ Source source = Source(src);\r
+ Format fmtAlbumInfo;\r
+ fmtAlbumInfo.PutStringValue(FORMAT_KEY, FORMAT_GET_ALBUM_INFO);\r
+ (void)albumInfoPlayer_->SetSource(source);\r
+ (void)albumInfoPlayer_->Prepare();\r
+ int32_t ret = albumInfoPlayer_->GetParameter(fmtAlbumInfo);\r
+ if (ret != MEDIA_OK) {\r
+ MEDIA_ERR_LOG("albumInfoPlayer_ GetfmtAlbumInfo failed:%d", ret);\r
+ albumInfo.title = "";\r
+ albumInfo.artist = "";\r
+ albumInfoPlayer_->Reset();\r
+ return;\r
+ }\r
+ std::string value;\r
+ fmtAlbumInfo.GetStringValue(FORMAT_KEY_TITLE, value);\r
+ albumInfo.title = value;\r
+ fmtAlbumInfo.GetStringValue(FORMAT_KEY_ARTIST, value);\r
+ albumInfo.artist = value;\r
+ albumInfoPlayer_->Reset();\r
+ return;\r
+}\r
+} // namespace OHOS
\ No newline at end of file
using namespace OHOS::Media;\r
using OHOS::Media::Player;\r
\r
+typedef struct AudioPlayerAlbumInfo {\r
+ std::string src;\r
+ std::string title;\r
+ std::string artist;\r
+} AudioPlayerAlbumInfo;\r
+\r
enum class AudioPlayerStates : int32_t {\r
AUDIO_PLAYER_IDLE,\r
AUDIO_PLAYER_ENTERED,\r
bool IsPlaying(void);\r
std::string GetCurrentPlaySource(void);\r
int32_t GetDuration(int64_t &durationMs);\r
+ void GetAlbumInfo(AudioPlayerAlbumInfo &albumInfo, const char *src);\r
protected:\r
void OnPlaybackComplete() override;\r
void OnError(int32_t errorType, int32_t errorCode) override;\r
AudioStreamType streamType_ = AUDIO_STREAM_MUSIC;\r
static std::shared_ptr<AudioPlayerService> instance_;\r
shared_ptr<AudioPlayerServiceCallback> callBack_ = nullptr;\r
+ shared_ptr<Player> albumInfoPlayer_ = nullptr;\r
};\r
}\r
#endif
\ No newline at end of file
const uint32_t STREAM_FLAG_PARTIAL_FRAME = 8;\r
const uint32_t MAX_ARGC = 5;\r
#define MEDIA_PATH_MAX 260\r
+#define MEDIA_PATH_KEY_LEN 20\r
#define MEDIA_MAX_PLAYER_TASK 6\r
+#define DEFAULE_HTTP_1 "http://openaudio.cos.tx.xmcdn.com/group64/M0B/02/30/wKgMaV1whaLAcRGQAE_0uZWMCp8270.mp3"\r
+#define DEFAULE_HTTP_2 "http://cdn.gohudong.com/Public/Hudong/Games/GameShake2019/assets/audio/game_running.mp3"\r
+\r
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))\r
\r
#define IS_OK(ret) \\r
MEDIA_AUDIO_MAX_PLAY_ID,\r
} PlaySampleCmd;\r
\r
+typedef struct {\r
+ char key[MEDIA_PATH_KEY_LEN];\r
+ char value[MEDIA_PATH_MAX];\r
+} PlaySampleHttpPath;\r
+\r
typedef struct {\r
PlaySampleCmd cmdId;\r
char cmd[64];\r
} PlaySampleType;\r
\r
+static PlaySampleHttpPath g_httpPathlist[] = {\r
+ { "http1://", DEFAULE_HTTP_1 },\r
+ { "http2://", DEFAULE_HTTP_2 },\r
+};\r
+\r
PlaySampleType g_funlist[] = {\r
{ MEDIA_AUDIO_PLAY_PAUSE, "pause" },\r
{ MEDIA_AUDIO_PLAY_RESUME, "resume" },\r
}\r
\r
Format albumInfo;\r
- albumInfo.PutStringValue(FORMAT_KEY, FORMAT_GET_ABLUM_INFO);\r
+ albumInfo.PutStringValue(FORMAT_KEY, FORMAT_GET_ALBUM_INFO);\r
int32_t ret = sampleParam->player->GetParameter(albumInfo);\r
if (ret != 0) {\r
MEDIA_ERR_LOG("GetAlbuminfo failed:%d", ret);\r
MediaMutexUnLock(g_playerTaskMutex);\r
}\r
\r
+static void GetRealPath(SampleParam *sampleParam, int32_t argc, const char **argv)\r
+{\r
+ bool isFound = false;\r
+ for (uint32_t i = 0; i < ARRAY_SIZE(g_httpPathlist); i++) {\r
+ bool matchCmd = (strncasecmp(argv[1], g_httpPathlist[i].key, strlen(g_httpPathlist[i].key)) == 0);\r
+ if (matchCmd) {\r
+ if (memcpy_s(sampleParam->filePath, MEDIA_PATH_MAX, g_httpPathlist[i].value,\r
+ strlen(g_httpPathlist[i].value) + 1) != EOK) {\r
+ MEDIA_ERR_LOG("memcpy_s failed");\r
+ }\r
+ isFound = true;\r
+ break;\r
+ }\r
+ }\r
+ if (!isFound) {\r
+ if (memcpy_s(sampleParam->filePath, MEDIA_PATH_MAX, argv[0x1], strlen(argv[0x1]) + 1) != EOK) {\r
+ MEDIA_ERR_LOG("memcpy_s failed");\r
+ }\r
+ }\r
+}\r
+\r
int32_t PlayerSample(int32_t argc, const char** argv)\r
{\r
SourceType sourceType = SourceType::SOURCE_TYPE_URI;\r
}\r
\r
if (strlen(argv[0x1]) < PATH_MAX) {\r
- if (memcpy_s(g_sampleParam->filePath, MEDIA_PATH_MAX, argv[0x1], strlen(argv[0x1]) + 1) != EOK) {\r
- MEDIA_ERR_LOG("memcpy_s failed");\r
- }\r
+ GetRealPath(g_sampleParam, argc, argv);\r
} else {\r
MEDIA_ERR_LOG("input path too long");\r
goto FREE;\r
}\r
\r
if (strlen(argv[0x1]) < PATH_MAX) {\r
- if (memcpy_s(g_tonePlayersampleParam->filePath, MEDIA_PATH_MAX, argv[0x1], strlen(argv[0x1]) + 1) != EOK) {\r
- MEDIA_ERR_LOG("memcpy_s failed");\r
- }\r
+ GetRealPath(g_tonePlayersampleParam, argc, argv);\r
} else {\r
MEDIA_ERR_LOG("input path too long");\r
goto FREE;\r
\r
/** Indicates the albumInfo, which is the type key. */\r
extern const char *FORMAT_KEY;\r
-extern const char *FORMAT_GET_ABLUM_INFO;\r
+extern const char *FORMAT_GET_ALBUM_INFO;\r
extern const char *FORMAT_KEY_ALBUM;\r
extern const char *FORMAT_KEY_TITLE;\r
extern const char *FORMAT_KEY_ARTIST;\r
const char *MIME_AUDIO_RAW = "audio/raw";
const char *PAUSE_AFTER_PLAY = "pause_after_play";
const char *FORMAT_KEY = "key";
-const char *FORMAT_GET_ABLUM_INFO = "albuminfo";
+const char *FORMAT_GET_ALBUM_INFO = "albuminfo";
const char *FORMAT_KEY_ALBUM = "album";
const char *FORMAT_KEY_TITLE = "title";
const char *FORMAT_KEY_ARTIST = "artist";
#===============================================================================\r
set(COMPONENT_NAME "format_hw")\r
\r
-set(COMPONENT_DIR ${ROOT_DIR}/middleware/services/media/component)\r
+set(COMPONENT_DIR ${ROOT_DIR}/middleware/services/media/component/hmf_demuxer)\r
if (EXISTS ${COMPONENT_DIR})\r
add_subdirectory(plugins/hmf_demuxer)\r
add_subdirectory(plugins/protocol_https)\r
HalHandle demuxer = NULL;
bool found = false;
int32_t probeScore = 0;
+ if (strncmp(member->url, "http", strlen("http")) == 0) {
+ MEDIA_HAL_LOGI(MODULE_NAME, "http demuxer not suitable");
+ return MEDIA_HAL_ERR;
+ }
RawDemuxerManagerInit();
for (uint32_t i = 0; i < g_rawDemuxerManager.count; i++) {
if (g_rawDemuxerManager.intf[i] == NULL) {
set(PROJECT_NAME hal_release)
-set(COMPONENT_DIR ${ROOT_DIR}/middleware/services/media/component)
+set(COMPONENT_DIR ${ROOT_DIR}/middleware/services/media/component/hmf_demuxer)
if (EXISTS ${COMPONENT_DIR})
set(DEPEND_LIBS plugin_demuxer_hmf plugin_protocol_https plugin_demuxer_mjpeg hmf_demuxer)
if("MEMORY_MINI" IN_LIST DEFINES)
set(LIBRARY_OUTPUT_PATH ${BIN_DIR}/${CHIP}/libs/media/${BOARD}_${APPLICATION}/${OS}/mini)
+elseif("SUPPORT_OHOSFWK" IN_LIST DEFINES)
+ set(LIBRARY_OUTPUT_PATH ${BIN_DIR}/${CHIP}/libs/media/${BOARD}_${APPLICATION}/${OS}/js)
else()
set(LIBRARY_OUTPUT_PATH ${BIN_DIR}/${CHIP}/libs/media/${BOARD}_${APPLICATION}/${OS}/normal)
endif()
if("MEMORY_MINI" IN_LIST DEFINES)
set(FORMAT_LIBS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${OS}/format/libs/mini)
+elseif("SUPPORT_OHOSFWK" IN_LIST DEFINES)
+ set(FORMAT_LIBS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${OS}/format/libs/js)
else()
set(FORMAT_LIBS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${OS}/format/libs/normal)
endif()
projects / mirrors / FD230.git / commitdiff