diff --git a/src/core/libraries/avplayer/avplayer.cpp b/src/core/libraries/avplayer/avplayer.cpp index 176fda137..c58bf42e1 100644 --- a/src/core/libraries/avplayer/avplayer.cpp +++ b/src/core/libraries/avplayer/avplayer.cpp @@ -9,23 +9,22 @@ namespace Libraries::AvPlayer { -s32 PS4_SYSV_ABI sceAvPlayerAddSource(SceAvPlayerHandle handle, const char* filename) { +s32 PS4_SYSV_ABI sceAvPlayerAddSource(AvPlayerHandle handle, const char* filename) { LOG_TRACE(Lib_AvPlayer, "filename = {}", filename); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->AddSource(filename); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->AddSource(filename); } -s32 PS4_SYSV_ABI sceAvPlayerAddSourceEx(SceAvPlayerHandle handle, SceAvPlayerUriType uriType, - SceAvPlayerSourceDetails* sourceDetails) { +s32 PS4_SYSV_ABI sceAvPlayerAddSourceEx(AvPlayerHandle handle, AvPlayerUriType uri_type, + AvPlayerSourceDetails* source_details) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); - if (handle == nullptr) { + if (handle == nullptr || uri_type != AvPlayerUriType::Source) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - return ORBIS_OK; + const auto path = std::string_view(source_details->uri.name, source_details->uri.length); + return handle->AddSourceEx(path, source_details->source_type); } int PS4_SYSV_ABI sceAvPlayerChangeStream() { @@ -33,28 +32,24 @@ int PS4_SYSV_ABI sceAvPlayerChangeStream() { return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerClose(SceAvPlayerHandle handle) { +s32 PS4_SYSV_ABI sceAvPlayerClose(AvPlayerHandle handle) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr) { - LOG_TRACE(Lib_AvPlayer, "returning ORBIS_AVPLAYER_ERROR_INVALID_PARAMS"); return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } delete handle; - LOG_TRACE(Lib_AvPlayer, "returning ORBIS_OK"); return ORBIS_OK; } -u64 PS4_SYSV_ABI sceAvPlayerCurrentTime(SceAvPlayerHandle handle) { +u64 PS4_SYSV_ABI sceAvPlayerCurrentTime(AvPlayerHandle handle) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->CurrentTime(); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->CurrentTime(); } -s32 PS4_SYSV_ABI sceAvPlayerDisableStream(SceAvPlayerHandle handle, u32 stream_id) { +s32 PS4_SYSV_ABI sceAvPlayerDisableStream(AvPlayerHandle handle, u32 stream_id) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -62,60 +57,49 @@ s32 PS4_SYSV_ABI sceAvPlayerDisableStream(SceAvPlayerHandle handle, u32 stream_i return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerEnableStream(SceAvPlayerHandle handle, u32 stream_id) { +s32 PS4_SYSV_ABI sceAvPlayerEnableStream(AvPlayerHandle handle, u32 stream_id) { LOG_TRACE(Lib_AvPlayer, "stream_id = {}", stream_id); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->EnableStream(stream_id); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->EnableStream(stream_id); } -bool PS4_SYSV_ABI sceAvPlayerGetAudioData(SceAvPlayerHandle handle, SceAvPlayerFrameInfo* p_info) { +bool PS4_SYSV_ABI sceAvPlayerGetAudioData(AvPlayerHandle handle, AvPlayerFrameInfo* p_info) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr || p_info == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->GetAudioData(*p_info); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->GetAudioData(*p_info); } -s32 PS4_SYSV_ABI sceAvPlayerGetStreamInfo(SceAvPlayerHandle handle, u32 stream_id, - SceAvPlayerStreamInfo* p_info) { +s32 PS4_SYSV_ABI sceAvPlayerGetStreamInfo(AvPlayerHandle handle, u32 stream_id, + AvPlayerStreamInfo* p_info) { LOG_TRACE(Lib_AvPlayer, "stream_id = {}", stream_id); if (handle == nullptr || p_info == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->GetStreamInfo(stream_id, *p_info); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->GetStreamInfo(stream_id, *p_info); } -bool PS4_SYSV_ABI sceAvPlayerGetVideoData(SceAvPlayerHandle handle, - SceAvPlayerFrameInfo* video_info) { +bool PS4_SYSV_ABI sceAvPlayerGetVideoData(AvPlayerHandle handle, AvPlayerFrameInfo* video_info) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr || video_info == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->GetVideoData(*video_info); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->GetVideoData(*video_info); } -bool PS4_SYSV_ABI sceAvPlayerGetVideoDataEx(SceAvPlayerHandle handle, - SceAvPlayerFrameInfoEx* video_info) { +bool PS4_SYSV_ABI sceAvPlayerGetVideoDataEx(AvPlayerHandle handle, + AvPlayerFrameInfoEx* video_info) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr || video_info == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->GetVideoData(*video_info); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->GetVideoData(*video_info); } -SceAvPlayerHandle PS4_SYSV_ABI sceAvPlayerInit(SceAvPlayerInitData* data) { +AvPlayerHandle PS4_SYSV_ABI sceAvPlayerInit(AvPlayerInitData* data) { LOG_TRACE(Lib_AvPlayer, "called"); if (data == nullptr) { return nullptr; @@ -125,15 +109,14 @@ SceAvPlayerHandle PS4_SYSV_ABI sceAvPlayerInit(SceAvPlayerInitData* data) { data->memory_replacement.allocate_texture == nullptr || data->memory_replacement.deallocate == nullptr || data->memory_replacement.deallocate_texture == nullptr) { - LOG_ERROR(Lib_AvPlayer, "All allocators are required for AVPlayer Initialisation."); + LOG_ERROR(Lib_AvPlayer, "All allocators are required for AvPlayer Initialisation."); return nullptr; } return new AvPlayer(*data); } -s32 PS4_SYSV_ABI sceAvPlayerInitEx(const SceAvPlayerInitDataEx* p_data, - SceAvPlayerHandle* p_player) { +s32 PS4_SYSV_ABI sceAvPlayerInitEx(const AvPlayerInitDataEx* p_data, AvPlayerHandle* p_player) { LOG_TRACE(Lib_AvPlayer, "called"); if (p_data == nullptr || p_player == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -143,11 +126,11 @@ s32 PS4_SYSV_ABI sceAvPlayerInitEx(const SceAvPlayerInitDataEx* p_data, p_data->memory_replacement.allocate_texture == nullptr || p_data->memory_replacement.deallocate == nullptr || p_data->memory_replacement.deallocate_texture == nullptr) { - LOG_ERROR(Lib_AvPlayer, "All allocators are required for AVPlayer Initialisation."); + LOG_ERROR(Lib_AvPlayer, "All allocators are required for AvPlayer Initialisation."); return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - SceAvPlayerInitData data = {}; + AvPlayerInitData data = {}; data.memory_replacement = p_data->memory_replacement; data.file_replacement = p_data->file_replacement; data.event_replacement = p_data->event_replacement; @@ -159,18 +142,15 @@ s32 PS4_SYSV_ABI sceAvPlayerInitEx(const SceAvPlayerInitDataEx* p_data, return ORBIS_OK; } -bool PS4_SYSV_ABI sceAvPlayerIsActive(SceAvPlayerHandle handle) { +bool PS4_SYSV_ABI sceAvPlayerIsActive(AvPlayerHandle handle) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr) { - LOG_TRACE(Lib_AvPlayer, "returning false"); return false; } - const auto res = handle->IsActive(); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->IsActive(); } -s32 PS4_SYSV_ABI sceAvPlayerJumpToTime(SceAvPlayerHandle handle, uint64_t time) { +s32 PS4_SYSV_ABI sceAvPlayerJumpToTime(AvPlayerHandle handle, uint64_t time) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called, time (msec) = {}", time); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -178,7 +158,7 @@ s32 PS4_SYSV_ABI sceAvPlayerJumpToTime(SceAvPlayerHandle handle, uint64_t time) return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerPause(SceAvPlayerHandle handle) { +s32 PS4_SYSV_ABI sceAvPlayerPause(AvPlayerHandle handle) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -186,14 +166,12 @@ s32 PS4_SYSV_ABI sceAvPlayerPause(SceAvPlayerHandle handle) { return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerPostInit(SceAvPlayerHandle handle, SceAvPlayerPostInitData* data) { +s32 PS4_SYSV_ABI sceAvPlayerPostInit(AvPlayerHandle handle, AvPlayerPostInitData* data) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr || data == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->PostInit(*data); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->PostInit(*data); } s32 PS4_SYSV_ABI sceAvPlayerPrintf(const char* format, ...) { @@ -201,7 +179,7 @@ s32 PS4_SYSV_ABI sceAvPlayerPrintf(const char* format, ...) { return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerResume(SceAvPlayerHandle handle) { +s32 PS4_SYSV_ABI sceAvPlayerResume(AvPlayerHandle handle) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -209,8 +187,7 @@ s32 PS4_SYSV_ABI sceAvPlayerResume(SceAvPlayerHandle handle) { return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerSetAvSyncMode(SceAvPlayerHandle handle, - SceAvPlayerAvSyncMode sync_mode) { +s32 PS4_SYSV_ABI sceAvPlayerSetAvSyncMode(AvPlayerHandle handle, AvPlayerAvSyncMode sync_mode) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -218,12 +195,12 @@ s32 PS4_SYSV_ABI sceAvPlayerSetAvSyncMode(SceAvPlayerHandle handle, return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerSetLogCallback(SceAvPlayerLogCallback log_cb, void* user_data) { +s32 PS4_SYSV_ABI sceAvPlayerSetLogCallback(AvPlayerLogCallback log_cb, void* user_data) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerSetLooping(SceAvPlayerHandle handle, bool loop_flag) { +s32 PS4_SYSV_ABI sceAvPlayerSetLooping(AvPlayerHandle handle, bool loop_flag) { LOG_TRACE(Lib_AvPlayer, "called, looping = {}", loop_flag); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -234,7 +211,7 @@ s32 PS4_SYSV_ABI sceAvPlayerSetLooping(SceAvPlayerHandle handle, bool loop_flag) return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerSetTrickSpeed(SceAvPlayerHandle handle, s32 trick_speed) { +s32 PS4_SYSV_ABI sceAvPlayerSetTrickSpeed(AvPlayerHandle handle, s32 trick_speed) { LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; @@ -242,35 +219,28 @@ s32 PS4_SYSV_ABI sceAvPlayerSetTrickSpeed(SceAvPlayerHandle handle, s32 trick_sp return ORBIS_OK; } -s32 PS4_SYSV_ABI sceAvPlayerStart(SceAvPlayerHandle handle) { +s32 PS4_SYSV_ABI sceAvPlayerStart(AvPlayerHandle handle) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->Start(); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->Start(); } -s32 PS4_SYSV_ABI sceAvPlayerStop(SceAvPlayerHandle handle) { +s32 PS4_SYSV_ABI sceAvPlayerStop(AvPlayerHandle handle) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr) { - LOG_TRACE(Lib_AvPlayer, "returning ORBIS_AVPLAYER_ERROR_INVALID_PARAMS"); return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->Stop(); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->Stop(); } -s32 PS4_SYSV_ABI sceAvPlayerStreamCount(SceAvPlayerHandle handle) { +s32 PS4_SYSV_ABI sceAvPlayerStreamCount(AvPlayerHandle handle) { LOG_TRACE(Lib_AvPlayer, "called"); if (handle == nullptr) { return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; } - const auto res = handle->GetStreamCount(); - LOG_TRACE(Lib_AvPlayer, "returning {}", res); - return res; + return handle->GetStreamCount(); } s32 PS4_SYSV_ABI sceAvPlayerVprintf(const char* format, va_list args) { diff --git a/src/core/libraries/avplayer/avplayer.h b/src/core/libraries/avplayer/avplayer.h index 2d472f801..2312acaec 100644 --- a/src/core/libraries/avplayer/avplayer.h +++ b/src/core/libraries/avplayer/avplayer.h @@ -16,38 +16,38 @@ namespace Libraries::AvPlayer { class AvPlayer; -using SceAvPlayerHandle = AvPlayer*; +using AvPlayerHandle = AvPlayer*; -enum class SceAvPlayerUriType : u32 { +enum class AvPlayerUriType : u32 { Source = 0, }; -struct SceAvPlayerUri { +struct AvPlayerUri { const char* name; u32 length; }; -enum class SceAvPlayerSourceType { +enum class AvPlayerSourceType { Unknown = 0, FileMp4 = 1, Hls = 8, }; -enum class SceAvPlayerStreamType : u32 { +enum class AvPlayerStreamType : u32 { Video, Audio, TimedText, Unknown, }; -struct SceAvPlayerSourceDetails { - SceAvPlayerUri uri; +struct AvPlayerSourceDetails { + AvPlayerUri uri; u8 reserved1[64]; - SceAvPlayerSourceType source_type; + AvPlayerSourceType source_type; u8 reserved2[44]; }; -struct SceAvPlayerAudio { +struct AvPlayerAudio { u16 channel_count; u8 reserved1[2]; u32 sample_rate; @@ -55,50 +55,50 @@ struct SceAvPlayerAudio { u8 language_code[4]; }; -struct SceAvPlayerVideo { +struct AvPlayerVideo { u32 width; u32 height; f32 aspect_ratio; char language_code[4]; }; -struct SceAvPlayerTextPosition { +struct AvPlayerTextPosition { u16 top; u16 left; u16 bottom; u16 right; }; -struct SceAvPlayerTimedText { +struct AvPlayerTimedText { u8 language_code[4]; u16 text_size; u16 font_size; - SceAvPlayerTextPosition position; + AvPlayerTextPosition position; }; -union SceAvPlayerStreamDetails { +union AvPlayerStreamDetails { u8 reserved[16]; - SceAvPlayerAudio audio; - SceAvPlayerVideo video; - SceAvPlayerTimedText subs; + AvPlayerAudio audio; + AvPlayerVideo video; + AvPlayerTimedText subs; }; -struct SceAvPlayerFrameInfo { - u8* pData; +struct AvPlayerFrameInfo { + u8* p_data; u8 reserved[4]; u64 timestamp; - SceAvPlayerStreamDetails details; + AvPlayerStreamDetails details; }; -struct SceAvPlayerStreamInfo { - SceAvPlayerStreamType type; +struct AvPlayerStreamInfo { + AvPlayerStreamType type; u8 reserved[4]; - SceAvPlayerStreamDetails details; + AvPlayerStreamDetails details; u64 duration; u64 start_time; }; -struct SceAvPlayerAudioEx { +struct AvPlayerAudioEx { u16 channel_count; u8 reserved[2]; u32 sample_rate; @@ -107,7 +107,7 @@ struct SceAvPlayerAudioEx { u8 reserved1[64]; }; -struct SceAvPlayerVideoEx { +struct AvPlayerVideoEx { u32 width; u32 height; f32 aspect_ratio; @@ -124,53 +124,53 @@ struct SceAvPlayerVideoEx { u8 reserved1[37]; }; -struct SceAvPlayerTimedTextEx { +struct AvPlayerTimedTextEx { u8 language_code[4]; u8 reserved[12]; u8 reserved1[64]; }; -union SceAvPlayerStreamDetailsEx { - SceAvPlayerAudioEx audio; - SceAvPlayerVideoEx video; - SceAvPlayerTimedTextEx subs; +union AvPlayerStreamDetailsEx { + AvPlayerAudioEx audio; + AvPlayerVideoEx video; + AvPlayerTimedTextEx subs; u8 reserved1[80]; }; -struct SceAvPlayerFrameInfoEx { - void* pData; +struct AvPlayerFrameInfoEx { + void* p_data; u8 reserved[4]; u64 timestamp; - SceAvPlayerStreamDetailsEx details; + AvPlayerStreamDetailsEx details; }; -using SceAvPlayerAllocate = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size); -using SceAvPlayerDeallocate = void PS4_SYSV_ABI (*)(void* p, void* mem); -using SceAvPlayerAllocateTexture = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size); -using SceAvPlayerDeallocateTexture = void PS4_SYSV_ABI (*)(void* p, void* mem); +using AvPlayerAllocate = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size); +using AvPlayerDeallocate = void PS4_SYSV_ABI (*)(void* p, void* mem); +using AvPlayerAllocateTexture = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size); +using AvPlayerDeallocateTexture = void PS4_SYSV_ABI (*)(void* p, void* mem); -struct SceAvPlayerMemAllocator { +struct AvPlayerMemAllocator { void* object_ptr; - SceAvPlayerAllocate allocate; - SceAvPlayerDeallocate deallocate; - SceAvPlayerAllocateTexture allocate_texture; - SceAvPlayerDeallocateTexture deallocate_texture; + AvPlayerAllocate allocate; + AvPlayerDeallocate deallocate; + AvPlayerAllocateTexture allocate_texture; + AvPlayerDeallocateTexture deallocate_texture; }; -using SceAvPlayerOpenFile = s32 PS4_SYSV_ABI (*)(void* p, const char* name); -using SceAvPlayerCloseFile = s32 PS4_SYSV_ABI (*)(void* p); -using SceAvPlayerReadOffsetFile = s32 PS4_SYSV_ABI (*)(void* p, u8* buf, u64 pos, u32 len); -using SceAvPlayerSizeFile = u64 PS4_SYSV_ABI (*)(void* p); +using AvPlayerOpenFile = s32 PS4_SYSV_ABI (*)(void* p, const char* name); +using AvPlayerCloseFile = s32 PS4_SYSV_ABI (*)(void* p); +using AvPlayerReadOffsetFile = s32 PS4_SYSV_ABI (*)(void* p, u8* buf, u64 pos, u32 len); +using AvPlayerSizeFile = u64 PS4_SYSV_ABI (*)(void* p); -struct SceAvPlayerFileReplacement { +struct AvPlayerFileReplacement { void* object_ptr; - SceAvPlayerOpenFile open; - SceAvPlayerCloseFile close; - SceAvPlayerReadOffsetFile readOffset; - SceAvPlayerSizeFile size; + AvPlayerOpenFile open; + AvPlayerCloseFile close; + AvPlayerReadOffsetFile read_offset; + AvPlayerSizeFile size; }; -enum class SceAvPlayerEvents { +enum class AvPlayerEvents { StateStop = 0x01, StateReady = 0x02, StatePlay = 0x03, @@ -182,26 +182,26 @@ enum class SceAvPlayerEvents { DrmError = 0x40, }; -using SceAvPlayerEventCallback = void PS4_SYSV_ABI (*)(void* p, SceAvPlayerEvents event, s32 src_id, - void* data); +using AvPlayerEventCallback = void PS4_SYSV_ABI (*)(void* p, AvPlayerEvents event, s32 src_id, + void* data); -struct SceAvPlayerEventReplacement { +struct AvPlayerEventReplacement { void* object_ptr; - SceAvPlayerEventCallback event_callback; + AvPlayerEventCallback event_callback; }; -enum class SceAvPlayerDebuglevels { +enum class AvPlayerDebuglevels { None, Info, Warnings, All, }; -struct SceAvPlayerInitData { - SceAvPlayerMemAllocator memory_replacement; - SceAvPlayerFileReplacement file_replacement; - SceAvPlayerEventReplacement event_replacement; - SceAvPlayerDebuglevels debug_level; +struct AvPlayerInitData { + AvPlayerMemAllocator memory_replacement; + AvPlayerFileReplacement file_replacement; + AvPlayerEventReplacement event_replacement; + AvPlayerDebuglevels debug_level; u32 base_priority; s32 num_output_video_framebuffers; bool auto_start; @@ -209,13 +209,13 @@ struct SceAvPlayerInitData { const char* default_language; }; -struct SceAvPlayerInitDataEx { +struct AvPlayerInitDataEx { size_t this_size; - SceAvPlayerMemAllocator memory_replacement; - SceAvPlayerFileReplacement file_replacement; - SceAvPlayerEventReplacement event_replacement; + AvPlayerMemAllocator memory_replacement; + AvPlayerFileReplacement file_replacement; + AvPlayerEventReplacement event_replacement; const char* default_language; - SceAvPlayerDebuglevels debug_level; + AvPlayerDebuglevels debug_level; u32 audio_decoder_priority; u32 audio_decoder_affinity; u32 video_decoder_priority; @@ -233,25 +233,25 @@ struct SceAvPlayerInitDataEx { u8 reserved[3]; }; -enum class SceAvPlayerVideoDecoderType { +enum class AvPlayerVideoDecoderType { Default = 0, Reserved1, Software, Software2, }; -enum class SceAvPlayerAudioDecoderType { +enum class AvPlayerAudioDecoderType { Default = 0, Reserved1, Reserved2, }; -struct SceAvPlayerDecoderInit { +struct AvPlayerDecoderInit { union { - SceAvPlayerVideoDecoderType video_type; - SceAvPlayerAudioDecoderType audio_type; + AvPlayerVideoDecoderType video_type; + AvPlayerAudioDecoderType audio_type; u8 reserved[4]; - } decoderType; + } decoder_type; union { struct { s32 cpu_affinity_mask; @@ -261,34 +261,34 @@ struct SceAvPlayerDecoderInit { u8 compute_queue_id; u8 enable_interlaced; u8 reserved[16]; - } avcSw2; + } avc_sw2; struct { u8 audio_channel_order; u8 reserved[27]; } aac; u8 reserved[28]; - } decoderParams; + } decoder_params; }; -struct SceAvPlayerHTTPCtx { +struct AvPlayerHTTPCtx { u32 http_context_id; u32 ssl_context_id; }; -struct SceAvPlayerPostInitData { +struct AvPlayerPostInitData { u32 demux_video_buffer_size; - SceAvPlayerDecoderInit video_decoder_init; - SceAvPlayerDecoderInit audio_decoder_init; - SceAvPlayerHTTPCtx http_context; + AvPlayerDecoderInit video_decoder_init; + AvPlayerDecoderInit audio_decoder_init; + AvPlayerHTTPCtx http_context; u8 reserved[56]; }; -enum class SceAvPlayerAvSyncMode { +enum class AvPlayerAvSyncMode { Default = 0, None, }; -using SceAvPlayerLogCallback = int PS4_SYSV_ABI (*)(void* p, const char* format, va_list args); +using AvPlayerLogCallback = int PS4_SYSV_ABI (*)(void* p, const char* format, va_list args); void RegisterlibSceAvPlayer(Core::Loader::SymbolsResolver* sym); diff --git a/src/core/libraries/avplayer/avplayer_common.cpp b/src/core/libraries/avplayer/avplayer_common.cpp index 28d7803a1..f42f690ed 100644 --- a/src/core/libraries/avplayer/avplayer_common.cpp +++ b/src/core/libraries/avplayer/avplayer_common.cpp @@ -13,9 +13,9 @@ static bool iequals(std::string_view l, std::string_view r) { return std::ranges::equal(l, r, [](u8 a, u8 b) { return std::tolower(a) == std::tolower(b); }); } -SceAvPlayerSourceType GetSourceType(std::string_view path) { +AvPlayerSourceType GetSourceType(std::string_view path) { if (path.empty()) { - return SceAvPlayerSourceType::Unknown; + return AvPlayerSourceType::Unknown; } std::string_view name = path; @@ -25,14 +25,14 @@ SceAvPlayerSourceType GetSourceType(std::string_view path) { // -> schema://server.domain/path/to/file.ext/and/beyond name = path.substr(0, path.find_first_of("?#")); if (name.empty()) { - return SceAvPlayerSourceType::Unknown; + return AvPlayerSourceType::Unknown; } } // schema://server.domain/path/to/file.ext/and/beyond -> .ext/and/beyond auto ext = name.substr(name.rfind('.')); if (ext.empty()) { - return SceAvPlayerSourceType::Unknown; + return AvPlayerSourceType::Unknown; } // .ext/and/beyond -> .ext @@ -40,14 +40,14 @@ SceAvPlayerSourceType GetSourceType(std::string_view path) { if (iequals(ext, ".mp4") || iequals(ext, ".m4v") || iequals(ext, ".m3d") || iequals(ext, ".m4a") || iequals(ext, ".mov")) { - return SceAvPlayerSourceType::FileMp4; + return AvPlayerSourceType::FileMp4; } if (iequals(ext, ".m3u8")) { - return SceAvPlayerSourceType::Hls; + return AvPlayerSourceType::Hls; } - return SceAvPlayerSourceType::Unknown; + return AvPlayerSourceType::Unknown; } } // namespace Libraries::AvPlayer diff --git a/src/core/libraries/avplayer/avplayer_common.h b/src/core/libraries/avplayer/avplayer_common.h index dc3cd787f..eddd10d5e 100644 --- a/src/core/libraries/avplayer/avplayer_common.h +++ b/src/core/libraries/avplayer/avplayer_common.h @@ -84,6 +84,6 @@ private: std::queue m_queue{}; }; -SceAvPlayerSourceType GetSourceType(std::string_view path); +AvPlayerSourceType GetSourceType(std::string_view path); } // namespace Libraries::AvPlayer diff --git a/src/core/libraries/avplayer/avplayer_file_streamer.cpp b/src/core/libraries/avplayer/avplayer_file_streamer.cpp index 19faeb273..c610012a5 100644 --- a/src/core/libraries/avplayer/avplayer_file_streamer.cpp +++ b/src/core/libraries/avplayer/avplayer_file_streamer.cpp @@ -14,7 +14,7 @@ constexpr u32 AVPLAYER_AVIO_BUFFER_SIZE = 4096; namespace Libraries::AvPlayer { -AvPlayerFileStreamer::AvPlayerFileStreamer(const SceAvPlayerFileReplacement& file_replacement) +AvPlayerFileStreamer::AvPlayerFileStreamer(const AvPlayerFileReplacement& file_replacement) : m_file_replacement(file_replacement) {} AvPlayerFileStreamer::~AvPlayerFileStreamer() { @@ -51,7 +51,7 @@ s32 AvPlayerFileStreamer::ReadPacket(void* opaque, u8* buffer, s32 size) { if (self->m_position + size > self->m_file_size) { size = self->m_file_size - self->m_position; } - const auto read_offset = self->m_file_replacement.readOffset; + const auto read_offset = self->m_file_replacement.read_offset; const auto ptr = self->m_file_replacement.object_ptr; const auto bytes_read = read_offset(ptr, buffer, self->m_position, size); if (bytes_read == 0 && size != 0) { diff --git a/src/core/libraries/avplayer/avplayer_file_streamer.h b/src/core/libraries/avplayer/avplayer_file_streamer.h index bc096bccc..c0cdb4a07 100644 --- a/src/core/libraries/avplayer/avplayer_file_streamer.h +++ b/src/core/libraries/avplayer/avplayer_file_streamer.h @@ -13,7 +13,7 @@ namespace Libraries::AvPlayer { class AvPlayerFileStreamer : public IDataStreamer { public: - AvPlayerFileStreamer(const SceAvPlayerFileReplacement& file_replacement); + AvPlayerFileStreamer(const AvPlayerFileReplacement& file_replacement); ~AvPlayerFileStreamer(); bool Init(std::string_view path) override; @@ -26,7 +26,7 @@ private: static s32 ReadPacket(void* opaque, u8* buffer, s32 size); static s64 Seek(void* opaque, s64 buffer, int whence); - SceAvPlayerFileReplacement m_file_replacement; + AvPlayerFileReplacement m_file_replacement; int m_fd = -1; u64 m_position{}; diff --git a/src/core/libraries/avplayer/avplayer_impl.cpp b/src/core/libraries/avplayer/avplayer_impl.cpp index d9a67134c..411908ae3 100644 --- a/src/core/libraries/avplayer/avplayer_impl.cpp +++ b/src/core/libraries/avplayer/avplayer_impl.cpp @@ -58,7 +58,7 @@ int PS4_SYSV_ABI AvPlayer::ReadOffsetFile(void* handle, u8* buffer, u64 position auto const self = reinterpret_cast(handle); std::lock_guard guard(self->m_file_io_mutex); - const auto read_offset = self->m_init_data_original.file_replacement.readOffset; + const auto read_offset = self->m_init_data_original.file_replacement.read_offset; const auto ptr = self->m_init_data_original.file_replacement.object_ptr; return Core::ExecuteGuest(read_offset, ptr, buffer, position, length); } @@ -72,38 +72,46 @@ u64 PS4_SYSV_ABI AvPlayer::SizeFile(void* handle) { return Core::ExecuteGuest(size, ptr); } -SceAvPlayerInitData AvPlayer::StubInitData(const SceAvPlayerInitData& data) { - SceAvPlayerInitData result = data; +AvPlayerInitData AvPlayer::StubInitData(const AvPlayerInitData& data) { + AvPlayerInitData result = data; result.memory_replacement.object_ptr = this; result.memory_replacement.allocate = &AvPlayer::Allocate; result.memory_replacement.deallocate = &AvPlayer::Deallocate; result.memory_replacement.allocate_texture = &AvPlayer::AllocateTexture; result.memory_replacement.deallocate_texture = &AvPlayer::DeallocateTexture; if (data.file_replacement.open == nullptr || data.file_replacement.close == nullptr || - data.file_replacement.readOffset == nullptr || data.file_replacement.size == nullptr) { + data.file_replacement.read_offset == nullptr || data.file_replacement.size == nullptr) { result.file_replacement = {}; } else { result.file_replacement.object_ptr = this; result.file_replacement.open = &AvPlayer::OpenFile; result.file_replacement.close = &AvPlayer::CloseFile; - result.file_replacement.readOffset = &AvPlayer::ReadOffsetFile; + result.file_replacement.read_offset = &AvPlayer::ReadOffsetFile; result.file_replacement.size = &AvPlayer::SizeFile; } return result; } -AvPlayer::AvPlayer(const SceAvPlayerInitData& data) +AvPlayer::AvPlayer(const AvPlayerInitData& data) : m_init_data(StubInitData(data)), m_init_data_original(data), m_state(std::make_unique(m_init_data)) {} -s32 AvPlayer::PostInit(const SceAvPlayerPostInitData& data) { +s32 AvPlayer::PostInit(const AvPlayerPostInitData& data) { m_state->PostInit(data); return ORBIS_OK; } s32 AvPlayer::AddSource(std::string_view path) { - if (path.empty()) { - return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; + return AddSourceEx(path, AvPlayerSourceType::Unknown); +} + +s32 AvPlayer::AddSourceEx(std::string_view path, AvPlayerSourceType source_type) { + if (source_type == AvPlayerSourceType::Unknown) { + source_type = GetSourceType(path); + } + if (source_type == AvPlayerSourceType::Hls) { + LOG_ERROR(Lib_AvPlayer, "HTTP Live Streaming is not implemented"); + return ORBIS_AVPLAYER_ERROR_NOT_SUPPORTED; } if (!m_state->AddSource(path, GetSourceType(path))) { return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED; @@ -122,7 +130,7 @@ s32 AvPlayer::GetStreamCount() { return res; } -s32 AvPlayer::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info) { +s32 AvPlayer::GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info) { if (!m_state->GetStreamInfo(stream_index, info)) { return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED; } @@ -146,21 +154,21 @@ s32 AvPlayer::Start() { return ORBIS_OK; } -bool AvPlayer::GetVideoData(SceAvPlayerFrameInfo& video_info) { +bool AvPlayer::GetVideoData(AvPlayerFrameInfo& video_info) { if (m_state == nullptr) { return false; } return m_state->GetVideoData(video_info); } -bool AvPlayer::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { +bool AvPlayer::GetVideoData(AvPlayerFrameInfoEx& video_info) { if (m_state == nullptr) { return false; } return m_state->GetVideoData(video_info); } -bool AvPlayer::GetAudioData(SceAvPlayerFrameInfo& audio_info) { +bool AvPlayer::GetAudioData(AvPlayerFrameInfo& audio_info) { if (m_state == nullptr) { return false; } diff --git a/src/core/libraries/avplayer/avplayer_impl.h b/src/core/libraries/avplayer/avplayer_impl.h index 984d81499..7033e191c 100644 --- a/src/core/libraries/avplayer/avplayer_impl.h +++ b/src/core/libraries/avplayer/avplayer_impl.h @@ -19,17 +19,18 @@ namespace Libraries::AvPlayer { class AvPlayer { public: - AvPlayer(const SceAvPlayerInitData& data); + AvPlayer(const AvPlayerInitData& data); - s32 PostInit(const SceAvPlayerPostInitData& data); + s32 PostInit(const AvPlayerPostInitData& data); s32 AddSource(std::string_view filename); + s32 AddSourceEx(std::string_view path, AvPlayerSourceType source_type); s32 GetStreamCount(); - s32 GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info); + s32 GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info); s32 EnableStream(u32 stream_index); s32 Start(); - bool GetAudioData(SceAvPlayerFrameInfo& audio_info); - bool GetVideoData(SceAvPlayerFrameInfo& video_info); - bool GetVideoData(SceAvPlayerFrameInfoEx& video_info); + bool GetAudioData(AvPlayerFrameInfo& audio_info); + bool GetVideoData(AvPlayerFrameInfo& video_info); + bool GetVideoData(AvPlayerFrameInfoEx& video_info); bool IsActive(); u64 CurrentTime(); s32 Stop(); @@ -48,10 +49,10 @@ private: static int PS4_SYSV_ABI ReadOffsetFile(void* handle, u8* buffer, u64 position, u32 length); static u64 PS4_SYSV_ABI SizeFile(void* handle); - SceAvPlayerInitData StubInitData(const SceAvPlayerInitData& data); + AvPlayerInitData StubInitData(const AvPlayerInitData& data); - SceAvPlayerInitData m_init_data{}; - SceAvPlayerInitData m_init_data_original{}; + AvPlayerInitData m_init_data{}; + AvPlayerInitData m_init_data_original{}; std::mutex m_file_io_mutex{}; std::atomic_bool m_has_source{}; diff --git a/src/core/libraries/avplayer/avplayer_source.cpp b/src/core/libraries/avplayer/avplayer_source.cpp index cf783403c..cc90a1a49 100644 --- a/src/core/libraries/avplayer/avplayer_source.cpp +++ b/src/core/libraries/avplayer/avplayer_source.cpp @@ -29,7 +29,7 @@ AvPlayerSource::~AvPlayerSource() { Stop(); } -bool AvPlayerSource::Init(const SceAvPlayerInitData& init_data, std::string_view path) { +bool AvPlayerSource::Init(const AvPlayerInitData& init_data, std::string_view path) { m_memory_replacement = init_data.memory_replacement, m_num_output_video_framebuffers = std::min(std::max(2, init_data.num_output_video_framebuffers), 16); @@ -76,17 +76,17 @@ s32 AvPlayerSource::GetStreamCount() { return m_avformat_context->nb_streams; } -static SceAvPlayerStreamType CodecTypeToStreamType(AVMediaType codec_type) { +static AvPlayerStreamType CodecTypeToStreamType(AVMediaType codec_type) { switch (codec_type) { case AVMediaType::AVMEDIA_TYPE_VIDEO: - return SceAvPlayerStreamType::Video; + return AvPlayerStreamType::Video; case AVMediaType::AVMEDIA_TYPE_AUDIO: - return SceAvPlayerStreamType::Audio; + return AvPlayerStreamType::Audio; case AVMediaType::AVMEDIA_TYPE_SUBTITLE: - return SceAvPlayerStreamType::TimedText; + return AvPlayerStreamType::TimedText; default: LOG_ERROR(Lib_AvPlayer, "Unexpected AVMediaType {}", magic_enum::enum_name(codec_type)); - return SceAvPlayerStreamType::Unknown; + return AvPlayerStreamType::Unknown; } } @@ -94,7 +94,7 @@ static f32 AVRationalToF32(const AVRational rational) { return f32(rational.num) / rational.den; } -bool AvPlayerSource::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info) { +bool AvPlayerSource::GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info) { info = {}; if (m_avformat_context == nullptr || stream_index >= m_avformat_context->nb_streams) { LOG_ERROR(Lib_AvPlayer, "Could not get stream {} info.", stream_index); @@ -115,7 +115,7 @@ bool AvPlayerSource::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info LOG_WARNING(Lib_AvPlayer, "Stream {} language is unknown", stream_index); } switch (info.type) { - case SceAvPlayerStreamType::Video: { + case AvPlayerStreamType::Video: { LOG_INFO(Lib_AvPlayer, "Stream {} is a video stream.", stream_index); info.details.video.aspect_ratio = f32(p_stream->codecpar->width) / p_stream->codecpar->height; @@ -133,7 +133,7 @@ bool AvPlayerSource::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info } break; } - case SceAvPlayerStreamType::Audio: { + case AvPlayerStreamType::Audio: { LOG_INFO(Lib_AvPlayer, "Stream {} is an audio stream.", stream_index); info.details.audio.channel_count = p_stream->codecpar->ch_layout.nb_channels; info.details.audio.sample_rate = p_stream->codecpar->sample_rate; @@ -144,7 +144,7 @@ bool AvPlayerSource::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info } break; } - case SceAvPlayerStreamType::TimedText: { + case AvPlayerStreamType::TimedText: { LOG_WARNING(Lib_AvPlayer, "Stream {} is a timedtext stream.", stream_index); info.details.subs.font_size = 12; info.details.subs.text_size = 12; @@ -280,25 +280,25 @@ bool AvPlayerSource::Stop() { return true; } -bool AvPlayerSource::GetVideoData(SceAvPlayerFrameInfo& video_info) { +bool AvPlayerSource::GetVideoData(AvPlayerFrameInfo& video_info) { if (!IsActive()) { return false; } - SceAvPlayerFrameInfoEx info{}; + AvPlayerFrameInfoEx info{}; if (!GetVideoData(info)) { return false; } video_info = {}; video_info.timestamp = u64(info.timestamp); - video_info.pData = reinterpret_cast(info.pData); + video_info.p_data = reinterpret_cast(info.p_data); video_info.details.video.aspect_ratio = info.details.video.aspect_ratio; video_info.details.video.width = info.details.video.width; video_info.details.video.height = info.details.video.height; return true; } -bool AvPlayerSource::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { +bool AvPlayerSource::GetVideoData(AvPlayerFrameInfoEx& video_info) { if (!IsActive()) { return false; } @@ -333,7 +333,7 @@ bool AvPlayerSource::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { return true; } -bool AvPlayerSource::GetAudioData(SceAvPlayerFrameInfo& audio_info) { +bool AvPlayerSource::GetAudioData(AvPlayerFrameInfo& audio_info) { if (!IsActive()) { return false; } @@ -367,7 +367,7 @@ bool AvPlayerSource::GetAudioData(SceAvPlayerFrameInfo& audio_info) { audio_info = {}; audio_info.timestamp = frame->info.timestamp; - audio_info.pData = reinterpret_cast(frame->info.pData); + audio_info.p_data = reinterpret_cast(frame->info.p_data); audio_info.details.audio.sample_rate = frame->info.details.audio.sample_rate; audio_info.details.audio.size = frame->info.details.audio.size; audio_info.details.audio.channel_count = frame->info.details.audio.channel_count; @@ -572,7 +572,7 @@ Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame .buffer = std::move(buffer), .info = { - .pData = p_buffer, + .p_data = p_buffer, .timestamp = timestamp, .details = { @@ -702,7 +702,7 @@ Frame AvPlayerSource::PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame .buffer = std::move(buffer), .info = { - .pData = p_buffer, + .p_data = p_buffer, .timestamp = timestamp, .details = { diff --git a/src/core/libraries/avplayer/avplayer_source.h b/src/core/libraries/avplayer/avplayer_source.h index 7e199c457..6d0590545 100644 --- a/src/core/libraries/avplayer/avplayer_source.h +++ b/src/core/libraries/avplayer/avplayer_source.h @@ -37,7 +37,7 @@ public: class FrameBuffer { public: - FrameBuffer(const SceAvPlayerMemAllocator& memory_replacement, u32 align, u32 size) noexcept + FrameBuffer(const AvPlayerMemAllocator& memory_replacement, u32 align, u32 size) noexcept : m_memory_replacement(memory_replacement), m_data(Allocate(memory_replacement, align, size)) { ASSERT_MSG(m_data, "Could not allocated frame buffer."); @@ -68,22 +68,22 @@ public: } private: - static u8* Allocate(const SceAvPlayerMemAllocator& memory_replacement, u32 align, u32 size) { + static u8* Allocate(const AvPlayerMemAllocator& memory_replacement, u32 align, u32 size) { return reinterpret_cast( memory_replacement.allocate(memory_replacement.object_ptr, align, size)); } - static void Deallocate(const SceAvPlayerMemAllocator& memory_replacement, void* ptr) { + static void Deallocate(const AvPlayerMemAllocator& memory_replacement, void* ptr) { memory_replacement.deallocate(memory_replacement.object_ptr, ptr); } - const SceAvPlayerMemAllocator& m_memory_replacement; + const AvPlayerMemAllocator& m_memory_replacement; u8* m_data = nullptr; }; struct Frame { FrameBuffer buffer; - SceAvPlayerFrameInfoEx info; + AvPlayerFrameInfoEx info; }; class EventCV { @@ -121,18 +121,18 @@ public: AvPlayerSource(AvPlayerStateCallback& state, bool use_vdec2); ~AvPlayerSource(); - bool Init(const SceAvPlayerInitData& init_data, std::string_view path); + bool Init(const AvPlayerInitData& init_data, std::string_view path); bool FindStreamInfo(); s32 GetStreamCount(); - bool GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info); + bool GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info); bool EnableStream(u32 stream_index); void SetLooping(bool is_looping); std::optional HasFrames(u32 num_frames); bool Start(); bool Stop(); - bool GetAudioData(SceAvPlayerFrameInfo& audio_info); - bool GetVideoData(SceAvPlayerFrameInfo& video_info); - bool GetVideoData(SceAvPlayerFrameInfoEx& video_info); + bool GetAudioData(AvPlayerFrameInfo& audio_info); + bool GetVideoData(AvPlayerFrameInfo& video_info); + bool GetVideoData(AvPlayerFrameInfoEx& video_info); u64 CurrentTime(); bool IsActive(); @@ -166,7 +166,7 @@ private: AvPlayerStateCallback& m_state; bool m_use_vdec2 = false; - SceAvPlayerMemAllocator m_memory_replacement{}; + AvPlayerMemAllocator m_memory_replacement{}; u32 m_num_output_video_framebuffers{}; std::atomic_bool m_is_looping = false; diff --git a/src/core/libraries/avplayer/avplayer_state.cpp b/src/core/libraries/avplayer/avplayer_state.cpp index 143df749c..e6885ea2d 100644 --- a/src/core/libraries/avplayer/avplayer_state.cpp +++ b/src/core/libraries/avplayer/avplayer_state.cpp @@ -12,11 +12,11 @@ namespace Libraries::AvPlayer { -void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayerEvents event_id, +void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, AvPlayerEvents event_id, s32 source_id, void* event_data) { auto const self = reinterpret_cast(opaque); - if (event_id == SceAvPlayerEvents::StateReady) { + if (event_id == AvPlayerEvents::StateReady) { s32 video_stream_index = -1; s32 audio_stream_index = -1; s32 timedtext_stream_index = -1; @@ -30,7 +30,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer return; } for (u32 stream_index = 0; stream_index < stream_count; ++stream_index) { - SceAvPlayerStreamInfo info{}; + AvPlayerStreamInfo info{}; if (!self->GetStreamInfo(stream_index, info)) { self->Stop(); return; @@ -38,7 +38,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer const std::string_view default_language{self->m_default_language}; switch (info.type) { - case SceAvPlayerStreamType::Video: + case AvPlayerStreamType::Video: if (video_stream_index == -1) { video_stream_index = stream_index; } @@ -47,7 +47,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer video_stream_index = stream_index; } break; - case SceAvPlayerStreamType::Audio: + case AvPlayerStreamType::Audio: if (audio_stream_index == -1) { audio_stream_index = stream_index; } @@ -56,7 +56,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer audio_stream_index = stream_index; } break; - case SceAvPlayerStreamType::TimedText: + case AvPlayerStreamType::TimedText: if (default_language.empty()) { timedtext_stream_index = stream_index; break; @@ -86,7 +86,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer DefaultEventCallback(opaque, event_id, 0, event_data); } -void AvPlayerState::DefaultEventCallback(void* opaque, SceAvPlayerEvents event_id, s32 source_id, +void AvPlayerState::DefaultEventCallback(void* opaque, AvPlayerEvents event_id, s32 source_id, void* event_data) { auto const self = reinterpret_cast(opaque); const auto callback = self->m_event_replacement.event_callback; @@ -97,7 +97,7 @@ void AvPlayerState::DefaultEventCallback(void* opaque, SceAvPlayerEvents event_i } // Called inside GAME thread -AvPlayerState::AvPlayerState(const SceAvPlayerInitData& init_data) +AvPlayerState::AvPlayerState(const AvPlayerInitData& init_data) : m_init_data(init_data), m_event_replacement(init_data.event_replacement) { if (m_event_replacement.event_callback == nullptr || init_data.auto_start) { m_auto_start = true; @@ -122,12 +122,12 @@ AvPlayerState::~AvPlayerState() { m_event_queue.Clear(); } -void AvPlayerState::PostInit(const SceAvPlayerPostInitData& post_init_data) { +void AvPlayerState::PostInit(const AvPlayerPostInitData& post_init_data) { m_post_init_data = post_init_data; } // Called inside GAME thread -bool AvPlayerState::AddSource(std::string_view path, SceAvPlayerSourceType source_type) { +bool AvPlayerState::AddSource(std::string_view path, AvPlayerSourceType source_type) { if (path.empty()) { LOG_ERROR(Lib_AvPlayer, "File path is empty."); return false; @@ -141,8 +141,8 @@ bool AvPlayerState::AddSource(std::string_view path, SceAvPlayerSourceType sourc } m_up_source = std::make_unique( - *this, m_post_init_data.video_decoder_init.decoderType.video_type == - SceAvPlayerVideoDecoderType::Software2); + *this, m_post_init_data.video_decoder_init.decoder_type.video_type == + AvPlayerVideoDecoderType::Software2); if (!m_up_source->Init(m_init_data, path)) { SetState(AvState::Error); m_up_source.reset(); @@ -164,7 +164,7 @@ s32 AvPlayerState::GetStreamCount() { } // Called inside GAME thread -bool AvPlayerState::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info) { +bool AvPlayerState::GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info) { std::shared_lock lock(m_source_mutex); if (m_up_source == nullptr) { LOG_ERROR(Lib_AvPlayer, "Could not get stream {} info. No source.", stream_index); @@ -247,7 +247,7 @@ bool AvPlayerState::Stop() { return true; } -bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfo& video_info) { +bool AvPlayerState::GetVideoData(AvPlayerFrameInfo& video_info) { std::shared_lock lock(m_source_mutex); if (m_up_source == nullptr) { return false; @@ -255,7 +255,7 @@ bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfo& video_info) { return m_up_source->GetVideoData(video_info); } -bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { +bool AvPlayerState::GetVideoData(AvPlayerFrameInfoEx& video_info) { std::shared_lock lock(m_source_mutex); if (m_up_source == nullptr) { return false; @@ -263,7 +263,7 @@ bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { return m_up_source->GetVideoData(video_info); } -bool AvPlayerState::GetAudioData(SceAvPlayerFrameInfo& audio_info) { +bool AvPlayerState::GetAudioData(AvPlayerFrameInfo& audio_info) { std::shared_lock lock(m_source_mutex); if (m_up_source == nullptr) { return false; @@ -318,23 +318,23 @@ void AvPlayerState::OnEOF() { void AvPlayerState::OnPlaybackStateChanged(AvState state) { switch (state) { case AvState::Ready: { - EmitEvent(SceAvPlayerEvents::StateReady); + EmitEvent(AvPlayerEvents::StateReady); break; } case AvState::Play: { - EmitEvent(SceAvPlayerEvents::StatePlay); + EmitEvent(AvPlayerEvents::StatePlay); break; } case AvState::Stop: { - EmitEvent(SceAvPlayerEvents::StateStop); + EmitEvent(AvPlayerEvents::StateStop); break; } case AvState::Pause: { - EmitEvent(SceAvPlayerEvents::StatePause); + EmitEvent(AvPlayerEvents::StatePause); break; } case AvState::Buffering: { - EmitEvent(SceAvPlayerEvents::StateBuffering); + EmitEvent(AvPlayerEvents::StateBuffering); break; } default: @@ -366,7 +366,7 @@ std::optional AvPlayerState::OnBufferingCheckEvent(u32 num_frames) { } // Called inside CONTROLLER thread -void AvPlayerState::EmitEvent(SceAvPlayerEvents event_id, void* event_data) { +void AvPlayerState::EmitEvent(AvPlayerEvents event_id, void* event_data) { LOG_INFO(Lib_AvPlayer, "Sending event to the game: id = {}", magic_enum::enum_name(event_id)); const auto callback = m_init_data.event_replacement.event_callback; if (callback) { diff --git a/src/core/libraries/avplayer/avplayer_state.h b/src/core/libraries/avplayer/avplayer_state.h index 48cd17bf2..139c5aa8b 100644 --- a/src/core/libraries/avplayer/avplayer_state.h +++ b/src/core/libraries/avplayer/avplayer_state.h @@ -18,29 +18,29 @@ class AvDecoder; class AvPlayerState : public AvPlayerStateCallback { public: - AvPlayerState(const SceAvPlayerInitData& init_data); + AvPlayerState(const AvPlayerInitData& init_data); ~AvPlayerState(); - void PostInit(const SceAvPlayerPostInitData& post_init_data); - bool AddSource(std::string_view filename, SceAvPlayerSourceType source_type); + void PostInit(const AvPlayerPostInitData& post_init_data); + bool AddSource(std::string_view filename, AvPlayerSourceType source_type); s32 GetStreamCount(); - bool GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info); + bool GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info); bool EnableStream(u32 stream_index); bool Start(); bool Stop(); - bool GetAudioData(SceAvPlayerFrameInfo& audio_info); - bool GetVideoData(SceAvPlayerFrameInfo& video_info); - bool GetVideoData(SceAvPlayerFrameInfoEx& video_info); + bool GetAudioData(AvPlayerFrameInfo& audio_info); + bool GetVideoData(AvPlayerFrameInfo& video_info); + bool GetVideoData(AvPlayerFrameInfoEx& video_info); bool IsActive(); u64 CurrentTime(); bool SetLooping(bool is_looping); private: // Event Replacement - static void PS4_SYSV_ABI AutoPlayEventCallback(void* handle, SceAvPlayerEvents event_id, + static void PS4_SYSV_ABI AutoPlayEventCallback(void* handle, AvPlayerEvents event_id, s32 source_id, void* event_data); - static void PS4_SYSV_ABI DefaultEventCallback(void* handle, SceAvPlayerEvents event_id, + static void PS4_SYSV_ABI DefaultEventCallback(void* handle, AvPlayerEvents event_id, s32 source_id, void* event_data); void OnWarning(u32 id) override; @@ -50,7 +50,7 @@ private: void OnPlaybackStateChanged(AvState state); std::optional OnBufferingCheckEvent(u32 num_frames); - void EmitEvent(SceAvPlayerEvents event_id, void* event_data = nullptr); + void EmitEvent(AvPlayerEvents event_id, void* event_data = nullptr); bool SetState(AvState state); void AvControllerThread(std::stop_token stop); @@ -65,9 +65,9 @@ private: std::unique_ptr m_up_source; - SceAvPlayerInitData m_init_data{}; - SceAvPlayerPostInitData m_post_init_data{}; - SceAvPlayerEventReplacement m_event_replacement{}; + AvPlayerInitData m_init_data{}; + AvPlayerPostInitData m_post_init_data{}; + AvPlayerEventReplacement m_event_replacement{}; bool m_auto_start{}; char m_default_language[4]{};