mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-12-08 20:58:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

avplayer: implemented AddSourceEx, SetAvSyncMode, Pause and Resume (#2456)

Browse Source 
* avplayer: code improvements

* avplayer: implemented pause/resume

* avplayer: implemented sync modes

* avplayer: issue warning on loopback

* avplayer: sync on video ts in default mode when audio ts is not available

* avplayer: removed waits for the frame in Get*Data, replaced cv with sleep

* avplayer: removed all waits from GetVideoData

* avplayer: fix warning propagation + small fixes

* Using texture memory for video frames, dropped video frame cache, syncing audio to video

* do not sync to audio when audio is not enabled

* removed logs, fixed sync

* reverted the removal of pre-allocated buffers
This commit is contained in:
Vladislav Mikhalin
2025-09-20 19:27:16 +03:00
committed by GitHub
parent eb18382396
commit 2b1c0b4f82
12 changed files with 452 additions and 373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
src/core/libraries/avplayer/avplayer.cpp
View File

@@ -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) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
if (handle == nullptr) {
s32 PS4_SYSV_ABI sceAvPlayerAddSourceEx(AvPlayerHandle handle, AvPlayerUriType uri_type,
AvPlayerSourceDetails* source_details) {
LOG_TRACE(Lib_AvPlayer, "called");
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;
return false;
}
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;
return false;
}
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;
return false;
}
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,22 +158,20 @@ s32 PS4_SYSV_ABI sceAvPlayerJumpToTime(SceAvPlayerHandle handle, uint64_t time)
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceAvPlayerPause(SceAvPlayerHandle handle) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
s32 PS4_SYSV_ABI sceAvPlayerPause(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
}
return ORBIS_OK;
return handle->Pause();
}
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,29 +179,28 @@ s32 PS4_SYSV_ABI sceAvPlayerPrintf(const char* format, ...) {
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceAvPlayerResume(SceAvPlayerHandle handle) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
s32 PS4_SYSV_ABI sceAvPlayerResume(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
}
return ORBIS_OK;
return handle->Resume();
}
s32 PS4_SYSV_ABI sceAvPlayerSetAvSyncMode(SceAvPlayerHandle handle,
SceAvPlayerAvSyncMode sync_mode) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
s32 PS4_SYSV_ABI sceAvPlayerSetAvSyncMode(AvPlayerHandle handle, AvPlayerAvSyncMode sync_mode) {
LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
}
return ORBIS_OK;
return handle->SetAvSyncMode(sync_mode);
}
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,43 +211,36 @@ s32 PS4_SYSV_ABI sceAvPlayerSetLooping(SceAvPlayerHandle handle, bool loop_flag)
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceAvPlayerSetTrickSpeed(SceAvPlayerHandle handle, s32 trick_speed) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
s32 PS4_SYSV_ABI sceAvPlayerSetTrickSpeed(AvPlayerHandle handle, s32 trick_speed) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called speed = {}", trick_speed);
if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
}
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) {

164
src/core/libraries/avplayer/avplayer.h
View File

@@ -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 RegisterLib(Core::Loader::SymbolsResolver* sym);

14
src/core/libraries/avplayer/avplayer_common.cpp
View File

@@ -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

7
src/core/libraries/avplayer/avplayer_common.h
View File

@@ -16,6 +16,7 @@
namespace Libraries::AvPlayer {
enum class AvState {
Unknown,
Initial,
AddingSource,
Ready,
@@ -64,6 +65,10 @@ public:
m_queue.emplace(std::forward<T>(value));
}
T& Front() {
return m_queue.front();
}
std::optional<T> Pop() {
if (Size() == 0) {
return std::nullopt;
@@ -84,6 +89,6 @@ private:
std::queue<T> m_queue{};
};
SceAvPlayerSourceType GetSourceType(std::string_view path);
AvPlayerSourceType GetSourceType(std::string_view path);
} // namespace Libraries::AvPlayer

4
src/core/libraries/avplayer/avplayer_file_streamer.cpp
View File

@@ -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) {

4
src/core/libraries/avplayer/avplayer_file_streamer.h
View File

@@ -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{};

58
src/core/libraries/avplayer/avplayer_impl.cpp
View File

@@ -58,7 +58,7 @@ int PS4_SYSV_ABI AvPlayer::ReadOffsetFile(void* handle, u8* buffer, u64 position
auto const self = reinterpret_cast<AvPlayer*>(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<AvPlayerState>(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;
}
@@ -140,27 +148,49 @@ s32 AvPlayer::EnableStream(u32 stream_index) {
}
s32 AvPlayer::Start() {
if (!m_state->Start()) {
if (m_state == nullptr || !m_state->Start()) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
}
return ORBIS_OK;
}
bool AvPlayer::GetVideoData(SceAvPlayerFrameInfo& video_info) {
s32 AvPlayer::Pause() {
if (m_state == nullptr || !m_state->Pause()) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
}
return ORBIS_OK;
}
s32 AvPlayer::Resume() {
if (m_state == nullptr || !m_state->Resume()) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
}
return ORBIS_OK;
}
s32 AvPlayer::SetAvSyncMode(AvPlayerAvSyncMode sync_mode) {
if (m_state == nullptr) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
}
m_state->SetAvSyncMode(sync_mode);
return ORBIS_OK;
}
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;
}

23
src/core/libraries/avplayer/avplayer_impl.h
View File

@@ -19,17 +19,21 @@ 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);
s32 Pause();
s32 Resume();
s32 SetAvSyncMode(AvPlayerAvSyncMode sync_mode);
bool GetAudioData(AvPlayerFrameInfo& audio_info);
bool GetVideoData(AvPlayerFrameInfo& video_info);
bool GetVideoData(AvPlayerFrameInfoEx& video_info);
bool IsActive();
u64 CurrentTime();
s32 Stop();
@@ -48,13 +52,12 @@ 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{};
std::unique_ptr<AvPlayerState> m_state{};
};

205
src/core/libraries/avplayer/avplayer_source.cpp
View File

@@ -5,6 +5,7 @@
#include "common/singleton.h"
#include "common/thread.h"
#include "core/file_sys/fs.h"
#include "core/libraries/avplayer/avplayer_error.h"
#include "core/libraries/avplayer/avplayer_file_streamer.h"
#include "core/libraries/avplayer/avplayer_source.h"
@@ -29,9 +30,9 @@ 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 =
m_max_num_video_framebuffers =
std::min(std::max(2, init_data.num_output_video_framebuffers), 16);
AVFormatContext* context = avformat_alloc_context();
@@ -76,25 +77,21 @@ 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;
}
}
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 +112,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 +130,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 +141,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;
@@ -186,16 +183,6 @@ bool AvPlayerSource::EnableStream(u32 stream_index) {
LOG_ERROR(Lib_AvPlayer, "Could not open avcodec for video stream {}.", stream_index);
return false;
}
auto width = u32(m_video_codec_context->width);
auto height = u32(m_video_codec_context->height);
if (!m_use_vdec2) {
width = Common::AlignUp(width, 16);
height = Common::AlignUp(height, 16);
}
const auto size = (width * height * 3) / 2;
for (u64 index = 0; index < m_num_output_video_framebuffers; ++index) {
m_video_buffers.Push(FrameBuffer(m_memory_replacement, 0x100, size));
}
LOG_INFO(Lib_AvPlayer, "Video stream {} enabled", stream_index);
break;
}
@@ -212,12 +199,6 @@ bool AvPlayerSource::EnableStream(u32 stream_index) {
LOG_ERROR(Lib_AvPlayer, "Could not open avcodec for audio stream {}.", stream_index);
return false;
}
const auto num_channels = m_audio_codec_context->ch_layout.nb_channels;
const auto align = num_channels * sizeof(u16);
const auto size = num_channels * sizeof(u16) * 1024;
for (u64 index = 0; index < 4; ++index) {
m_audio_buffers.Push(FrameBuffer(m_memory_replacement, 0x100, size));
}
LOG_INFO(Lib_AvPlayer, "Audio stream {} enabled", stream_index);
break;
}
@@ -244,6 +225,26 @@ bool AvPlayerSource::Start() {
LOG_ERROR(Lib_AvPlayer, "Could not start playback. NULL context.");
return false;
}
if (m_video_codec_context) {
auto width = u32(m_video_codec_context->width);
auto height = u32(m_video_codec_context->height);
if (!m_use_vdec2) {
width = Common::AlignUp(width, 16);
height = Common::AlignUp(height, 16);
}
const auto size = (width * height * 3) / 2;
for (u64 index = 0; index < m_max_num_video_framebuffers; ++index) {
m_video_buffers.Push(GuestBuffer(m_memory_replacement, 0x100, size, true));
}
}
if (m_audio_codec_context) {
const auto num_channels = m_audio_codec_context->ch_layout.nb_channels;
const auto align = num_channels * sizeof(u16);
const auto size = num_channels * sizeof(u16) * 1024;
for (u64 index = 0; index < 8; ++index) {
m_audio_buffers.Push(GuestBuffer(m_memory_replacement, 0x100, size, false));
}
}
m_demuxer_thread.Run([this](std::stop_token stop) { this->DemuxerThread(stop); });
m_video_decoder_thread.Run([this](std::stop_token stop) { this->VideoDecoderThread(stop); });
m_audio_decoder_thread.Run([this](std::stop_token stop) { this->AudioDecoderThread(stop); });
@@ -263,123 +264,122 @@ bool AvPlayerSource::Stop() {
m_audio_decoder_thread.Stop();
m_demuxer_thread.Stop();
if (m_current_audio_frame.has_value()) {
m_audio_buffers.Push(std::move(m_current_audio_frame.value()));
m_current_audio_frame.reset();
}
if (m_current_video_frame.has_value()) {
m_video_buffers.Push(std::move(m_current_video_frame.value()));
m_current_video_frame.reset();
}
m_stop_cv.Notify();
m_current_audio_frame.reset();
m_current_video_frame.reset();
m_video_buffers.Clear();
m_audio_buffers.Clear();
m_audio_packets.Clear();
m_video_packets.Clear();
m_audio_frames.Clear();
m_video_frames.Clear();
return true;
}
bool AvPlayerSource::GetVideoData(SceAvPlayerFrameInfo& video_info) {
if (!IsActive()) {
return false;
}
void AvPlayerSource::Pause() {
m_pause_time = std::chrono::high_resolution_clock::now();
m_is_paused = true;
}
SceAvPlayerFrameInfoEx info{};
void AvPlayerSource::Resume() {
m_pause_duration += std::chrono::high_resolution_clock::now() - m_pause_time;
m_is_paused = false;
}
bool AvPlayerSource::GetVideoData(AvPlayerFrameInfo& video_info) {
AvPlayerFrameInfoEx info{};
if (!GetVideoData(info)) {
return false;
}
video_info = {};
video_info.timestamp = u64(info.timestamp);
video_info.pData = reinterpret_cast<u8*>(info.pData);
video_info.p_data = reinterpret_cast<u8*>(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) {
if (!IsActive()) {
bool AvPlayerSource::GetVideoData(AvPlayerFrameInfoEx& video_info) {
if (m_current_video_frame.has_value()) {
m_video_buffers.Push(std::move(m_current_video_frame->buffer));
m_current_video_frame.reset();
m_video_buffers_cv.Notify();
}
if (!IsActive() || m_is_paused) {
return false;
}
m_video_frames_cv.Wait([this] { return m_video_frames.Size() != 0 || m_is_eof; });
auto frame = m_video_frames.Pop();
if (!frame.has_value()) {
LOG_TRACE(Lib_AvPlayer, "Could get video frame. EOF reached.");
if (m_video_frames.Size() == 0) {
return false;
}
{
using namespace std::chrono;
auto elapsed_time =
duration_cast<milliseconds>(high_resolution_clock::now() - m_start_time).count();
if (elapsed_time < frame->info.timestamp) {
if (m_stop_cv.WaitFor(milliseconds(frame->info.timestamp - elapsed_time),
[&] { return elapsed_time >= frame->info.timestamp; })) {
const auto& new_frame = m_video_frames.Front();
if (m_state.GetSyncMode() == AvPlayerAvSyncMode::Default) {
if (m_audio_codec_context != nullptr) {
// Sync with the audio
auto avdiff = s64(new_frame.info.timestamp) - s64(m_last_audio_ts.value_or(0));
if (avdiff > 69) {
// VIDEO_AHEAD, wait
return false;
}
// These will remain unimplemented for now:
// avdiff < -28 = VIDEO_BEHIND, ??? skip frames ???
// -2 < avdiff < 0 = WAIT_FOR_SYNC, ??? loop until synced ???
} else {
// Sync with the internal timer since audio is not available
const auto current_time = CurrentTime();
if (0 < current_time && current_time < new_frame.info.timestamp) {
return false;
}
}
}
// return the buffer to the queue
if (m_current_video_frame.has_value()) {
m_video_buffers.Push(std::move(m_current_video_frame.value()));
m_video_buffers_cv.Notify();
}
m_current_video_frame = std::move(frame->buffer);
auto frame = m_video_frames.Pop();
video_info = frame->info;
m_current_video_frame = std::move(frame);
return true;
}
bool AvPlayerSource::GetAudioData(SceAvPlayerFrameInfo& audio_info) {
if (!IsActive()) {
return false;
}
m_audio_frames_cv.Wait([this] { return m_audio_frames.Size() != 0 || m_is_eof; });
auto frame = m_audio_frames.Pop();
if (!frame.has_value()) {
LOG_TRACE(Lib_AvPlayer, "Could get audio frame. EOF reached.");
return false;
}
{
using namespace std::chrono;
auto elapsed_time =
duration_cast<milliseconds>(high_resolution_clock::now() - m_start_time).count();
if (elapsed_time < frame->info.timestamp) {
if (m_stop_cv.WaitFor(milliseconds(frame->info.timestamp - elapsed_time),
[&] { return elapsed_time >= frame->info.timestamp; })) {
return false;
}
}
}
// return the buffer to the queue
bool AvPlayerSource::GetAudioData(AvPlayerFrameInfo& audio_info) {
if (m_current_audio_frame.has_value()) {
m_audio_buffers.Push(std::move(m_current_audio_frame.value()));
// return the buffer to the queue
m_audio_buffers.Push(std::move(m_current_audio_frame->buffer));
m_current_audio_frame.reset();
m_audio_buffers_cv.Notify();
}
m_current_audio_frame = std::move(frame->buffer);
if (!IsActive() || m_is_paused) {
return false;
}
if (m_audio_frames.Size() == 0) {
return false;
}
auto frame = m_audio_frames.Pop();
m_last_audio_ts = frame->info.timestamp;
audio_info = {};
audio_info.timestamp = frame->info.timestamp;
audio_info.pData = reinterpret_cast<u8*>(frame->info.pData);
audio_info.p_data = reinterpret_cast<u8*>(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;
m_current_audio_frame = std::move(frame);
return true;
}
u64 AvPlayerSource::CurrentTime() {
if (!IsActive()) {
if (!IsActive() || !m_start_time.has_value()) {
return 0;
}
using namespace std::chrono;
return duration_cast<milliseconds>(high_resolution_clock::now() - m_start_time).count();
return duration_cast<milliseconds>(high_resolution_clock::now() - m_start_time.value() -
m_pause_duration)
.count();
}
bool AvPlayerSource::IsActive() {
@@ -445,6 +445,7 @@ void AvPlayerSource::DemuxerThread(std::stop_token stop) {
if (res == AVERROR_EOF) {
if (m_is_looping) {
LOG_INFO(Lib_AvPlayer, "EOF reached in demuxer. Looping the source...");
m_state.OnWarning(ORBIS_AVPLAYER_ERROR_WAR_LOOPING_BACK);
avio_seek(m_avformat_context->pb, 0, SEEK_SET);
if (m_video_stream_index.has_value()) {
const auto index = m_video_stream_index.value();
@@ -548,7 +549,7 @@ static void CopyNV12Data(u8* dst, const AVFrame& src, bool use_vdec2) {
}
}
Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame) {
Frame AvPlayerSource::PrepareVideoFrame(GuestBuffer buffer, const AVFrame& frame) {
ASSERT(frame.format == AV_PIX_FMT_NV12);
auto p_buffer = buffer.GetBuffer();
@@ -572,7 +573,7 @@ Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame
.buffer = std::move(buffer),
.info =
{
.pData = p_buffer,
.p_data = p_buffer,
.timestamp = timestamp,
.details =
{
@@ -580,7 +581,7 @@ Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame
{
.width = width,
.height = height,
.aspect_ratio = AVRationalToF32(frame.sample_aspect_ratio),
.aspect_ratio = (float)av_q2d(frame.sample_aspect_ratio),
.crop_left_offset = u32(frame.crop_left),
.crop_right_offset = u32(frame.crop_right + (width - frame.width)),
.crop_top_offset = u32(frame.crop_top),
@@ -683,7 +684,7 @@ AvPlayerSource::AVFramePtr AvPlayerSource::ConvertAudioFrame(const AVFrame& fram
return pcm16_frame;
}
Frame AvPlayerSource::PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame) {
Frame AvPlayerSource::PrepareAudioFrame(GuestBuffer buffer, const AVFrame& frame) {
ASSERT(frame.format == AV_SAMPLE_FMT_S16);
ASSERT(frame.nb_samples <= 1024);
@@ -702,7 +703,7 @@ Frame AvPlayerSource::PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame
.buffer = std::move(buffer),
.info =
{
.pData = p_buffer,
.p_data = p_buffer,
.timestamp = timestamp,
.details =
{

87
src/core/libraries/avplayer/avplayer_source.h
View File

@@ -30,35 +30,45 @@ class AvPlayerStateCallback {
public:
virtual ~AvPlayerStateCallback() = default;
virtual AvPlayerAvSyncMode GetSyncMode() = 0;
virtual void OnWarning(u32 id) = 0;
virtual void OnError() = 0;
virtual void OnEOF() = 0;
};
class FrameBuffer {
class GuestBuffer {
public:
FrameBuffer(const SceAvPlayerMemAllocator& memory_replacement, u32 align, u32 size) noexcept
GuestBuffer(const AvPlayerMemAllocator& memory_replacement, u32 align, u32 size,
bool is_texture) noexcept
: m_memory_replacement(memory_replacement),
m_data(Allocate(memory_replacement, align, size)) {
m_data(is_texture ? AllocateTexture(memory_replacement, align, size)
: Allocate(memory_replacement, align, size)),
m_is_texture(is_texture) {
ASSERT_MSG(m_data, "Could not allocate frame buffer.");
}
~FrameBuffer() {
~GuestBuffer() {
if (m_data != nullptr) {
Deallocate(m_memory_replacement, m_data);
if (m_is_texture) {
DeallocateTexture(m_memory_replacement, m_data);
} else {
Deallocate(m_memory_replacement, m_data);
}
m_data = {};
}
}
FrameBuffer(const FrameBuffer&) noexcept = delete;
FrameBuffer& operator=(const FrameBuffer&) noexcept = delete;
GuestBuffer(const GuestBuffer&) noexcept = delete;
GuestBuffer& operator=(const GuestBuffer&) noexcept = delete;
FrameBuffer(FrameBuffer&& r) noexcept
: m_memory_replacement(r.m_memory_replacement), m_data(r.m_data) {
GuestBuffer(GuestBuffer&& r) noexcept
: m_memory_replacement(r.m_memory_replacement), m_data(r.m_data),
m_is_texture(r.m_is_texture) {
r.m_data = nullptr;
};
FrameBuffer& operator=(FrameBuffer&& r) noexcept {
GuestBuffer& operator=(GuestBuffer&& r) noexcept {
std::swap(m_data, r.m_data);
return *this;
}
@@ -68,22 +78,33 @@ 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<u8*>(
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;
static u8* AllocateTexture(const AvPlayerMemAllocator& memory_replacement, u32 align,
u32 size) {
return reinterpret_cast<u8*>(
memory_replacement.allocate_texture(memory_replacement.object_ptr, align, size));
}
static void DeallocateTexture(const AvPlayerMemAllocator& memory_replacement, void* ptr) {
memory_replacement.deallocate_texture(memory_replacement.object_ptr, ptr);
}
const AvPlayerMemAllocator& m_memory_replacement;
u8* m_data = nullptr;
bool m_is_texture = false;
};
struct Frame {
FrameBuffer buffer;
SceAvPlayerFrameInfoEx info;
GuestBuffer buffer;
AvPlayerFrameInfoEx info;
};
class EventCV {
@@ -121,18 +142,20 @@ 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<bool> HasFrames(u32 num_frames);
bool Start();
bool Stop();
bool GetAudioData(SceAvPlayerFrameInfo& audio_info);
bool GetVideoData(SceAvPlayerFrameInfo& video_info);
bool GetVideoData(SceAvPlayerFrameInfoEx& video_info);
void Pause();
void Resume();
bool GetAudioData(AvPlayerFrameInfo& audio_info);
bool GetVideoData(AvPlayerFrameInfo& video_info);
bool GetVideoData(AvPlayerFrameInfoEx& video_info);
u64 CurrentTime();
bool IsActive();
@@ -160,22 +183,23 @@ private:
AVFramePtr ConvertAudioFrame(const AVFrame& frame);
AVFramePtr ConvertVideoFrame(const AVFrame& frame);
Frame PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame);
Frame PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame);
Frame PrepareAudioFrame(GuestBuffer buffer, const AVFrame& frame);
Frame PrepareVideoFrame(GuestBuffer buffer, const AVFrame& frame);
AvPlayerStateCallback& m_state;
bool m_use_vdec2 = false;
SceAvPlayerMemAllocator m_memory_replacement{};
u32 m_num_output_video_framebuffers{};
AvPlayerMemAllocator m_memory_replacement{};
u32 m_max_num_video_framebuffers{};
std::atomic_bool m_is_looping = false;
std::atomic_bool m_is_paused = false;
std::atomic_bool m_is_eof = false;
std::unique_ptr<IDataStreamer> m_up_data_streamer;
AvPlayerQueue<FrameBuffer> m_audio_buffers;
AvPlayerQueue<FrameBuffer> m_video_buffers;
AvPlayerQueue<GuestBuffer> m_audio_buffers;
AvPlayerQueue<GuestBuffer> m_video_buffers;
AvPlayerQueue<AVPacketPtr> m_audio_packets;
AvPlayerQueue<AVPacketPtr> m_video_packets;
@@ -183,8 +207,8 @@ private:
AvPlayerQueue<Frame> m_audio_frames;
AvPlayerQueue<Frame> m_video_frames;
std::optional<FrameBuffer> m_current_video_frame;
std::optional<FrameBuffer> m_current_audio_frame;
std::optional<Frame> m_current_video_frame;
std::optional<Frame> m_current_audio_frame;
std::optional<s32> m_video_stream_index{};
std::optional<s32> m_audio_stream_index{};
@@ -197,8 +221,6 @@ private:
EventCV m_video_frames_cv{};
EventCV m_video_buffers_cv{};
EventCV m_stop_cv{};
std::mutex m_state_mutex{};
Kernel::Thread m_demuxer_thread{};
Kernel::Thread m_video_decoder_thread{};
@@ -210,7 +232,10 @@ private:
SWRContextPtr m_swr_context{nullptr, &ReleaseSWRContext};
SWSContextPtr m_sws_context{nullptr, &ReleaseSWSContext};
std::chrono::high_resolution_clock::time_point m_start_time{};
std::optional<u64> m_last_audio_ts{};
std::optional<std::chrono::high_resolution_clock::time_point> m_start_time{};
std::chrono::high_resolution_clock::time_point m_pause_time{};
std::chrono::high_resolution_clock::duration m_pause_duration{};
};
} // namespace Libraries::AvPlayer

86
src/core/libraries/avplayer/avplayer_state.cpp
View File

@@ -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<AvPlayerState*>(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<AvPlayerState*>(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<AvPlayerSource>(
*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);
@@ -185,6 +185,42 @@ bool AvPlayerState::Start() {
return true;
}
// Called inside GAME thread
bool AvPlayerState::Pause() {
std::shared_lock lock(m_source_mutex);
if (m_current_state == AvState::EndOfFile) {
return true;
}
if (m_up_source == nullptr || m_current_state == AvState::Pause ||
m_current_state == AvState::Ready || m_current_state == AvState::Initial ||
m_current_state == AvState::Unknown || m_current_state == AvState::AddingSource) {
LOG_ERROR(Lib_AvPlayer, "Could not pause playback.");
return false;
}
m_up_source->Pause();
SetState(AvState::Pause);
OnPlaybackStateChanged(AvState::Pause);
return true;
}
// Called inside GAME thread
bool AvPlayerState::Resume() {
std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr || m_current_state != AvState::Pause) {
LOG_ERROR(Lib_AvPlayer, "Could not resume playback.");
return false;
}
m_up_source->Resume();
const auto state = m_previous_state.load();
SetState(state);
OnPlaybackStateChanged(state);
return true;
}
void AvPlayerState::SetAvSyncMode(AvPlayerAvSyncMode sync_mode) {
m_sync_mode = sync_mode;
}
void AvPlayerState::AvControllerThread(std::stop_token stop) {
using std::chrono::milliseconds;
Common::SetCurrentThreadName("shadPS4:AvController");
@@ -247,7 +283,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 +291,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 +299,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;
@@ -305,6 +341,10 @@ void AvPlayerState::OnWarning(u32 id) {
WarningEvent(id);
}
AvPlayerAvSyncMode AvPlayerState::GetSyncMode() {
return m_sync_mode;
}
void AvPlayerState::OnError() {
SetState(AvState::Error);
OnPlaybackStateChanged(AvState::Error);
@@ -318,23 +358,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 +406,7 @@ std::optional<bool> 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) {
@@ -389,7 +429,7 @@ void AvPlayerState::ProcessEvent() {
}
switch (event->event) {
case AvEventType::WarningId: {
OnWarning(event->payload.error);
EmitEvent(AvPlayerEvents::WarningId, &event->payload.error);
break;
}
case AvEventType::RevertState: {

31
src/core/libraries/avplayer/avplayer_state.h
View File

@@ -18,31 +18,35 @@ 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 Pause();
bool Resume();
void SetAvSyncMode(AvPlayerAvSyncMode sync_mode);
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);
AvPlayerAvSyncMode GetSyncMode() override;
void OnWarning(u32 id) override;
void OnError() override;
void OnEOF() override;
@@ -50,7 +54,7 @@ private:
void OnPlaybackStateChanged(AvState state);
std::optional<bool> 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,11 +69,12 @@ private:
std::unique_ptr<AvPlayerSource> 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]{};
AvPlayerAvSyncMode m_sync_mode = AvPlayerAvSyncMode::Default;
std::atomic<AvState> m_current_state;
std::atomic<AvState> m_previous_state;