Mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-07-12 04:35:56 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge a16ecdc6b4 into 27cbd6647f

Browse source
This commit is contained in:
Vladislav Mikhalin 2025-07-10 16:09:34 +05:30 • committed by GitHub
commit c0a177c97f
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 704 additions and 426 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/common/logging/log.h
View file

@ -39,14 +39,10 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig
Common::Log::FmtLogMessage(log_class, log_level, Common::Log::TrimSourcePath(__FILE__), \ Common::Log::FmtLogMessage(log_class, log_level, Common::Log::TrimSourcePath(__FILE__), \
__LINE__, __func__, __VA_ARGS__) __LINE__, __func__, __VA_ARGS__)
#ifdef _DEBUG
#define LOG_TRACE(log_class, ...) \ #define LOG_TRACE(log_class, ...) \
Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Trace, \ Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Trace, \
Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__, \ Common::Log::TrimSourcePath(__FILE__), __LINE__, __func__, \
__VA_ARGS__) __VA_ARGS__)
#else
#define LOG_TRACE(log_class, fmt, ...) (void(0))
#endif
#define LOG_DEBUG(log_class, ...) \ #define LOG_DEBUG(log_class, ...) \
Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Debug, \ Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Debug, \

49
src/common/native_clock.cpp
View file

@ -5,28 +5,51 @@
#include "common/rdtsc.h" #include "common/rdtsc.h"
#include "common/uint128.h" #include "common/uint128.h"
#include <chrono>
#ifdef _WIN64
#include <Windows.h>
#define MM_SHARED_USER_DATA_VA 0x7ffe0000
#define QpcBias ((ULONGLONG volatile*)(MM_SHARED_USER_DATA_VA + 0x3b0))
#endif
namespace Common { namespace Common {
NativeClock::NativeClock() NativeClock::NativeClock()
: rdtsc_frequency{EstimateRDTSCFrequency()}, : rdtsc_frequency{EstimateRDTSCFrequency()},
ns_rdtsc_factor{GetFixedPoint64Factor(std::nano::den, rdtsc_frequency)}, us_rdtsc_factor{GetFixedPoint64Factor(std::micro::den, rdtsc_frequency)} {}
us_rdtsc_factor{GetFixedPoint64Factor(std::micro::den, rdtsc_frequency)},
ms_rdtsc_factor{GetFixedPoint64Factor(std::milli::den, rdtsc_frequency)} {}
u64 NativeClock::GetTimeNS(u64 base_ptc /*= 0*/) const { u64 NativeClock::GetTimeUS(u64 time) const {
return MultiplyHigh(GetUptime() - base_ptc, ns_rdtsc_factor); return MultiplyHigh(time, us_rdtsc_factor);
}
u64 NativeClock::GetTimeUS(u64 base_ptc /*= 0*/) const {
return MultiplyHigh(GetUptime() - base_ptc, us_rdtsc_factor);
}
u64 NativeClock::GetTimeMS(u64 base_ptc /*= 0*/) const {
return MultiplyHigh(GetUptime() - base_ptc, ms_rdtsc_factor);
} }
u64 NativeClock::GetUptime() const { u64 NativeClock::GetUptime() const {
#ifdef _WIN64
LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
return counter.QuadPart;
#else
return FencedRDTSC(); return FencedRDTSC();
#endif
}
u64 NativeClock::GetUnbiasedUptime() const {
#ifdef _WIN64
ULONGLONG bias = 0;
u64 qpc = 0;
do {
bias = *QpcBias;
qpc = GetUptime();
} while (bias != *QpcBias);
return qpc - bias;
#else
return GetUptime();
#endif
}
u64 NativeClock::GetTscFrequency() const {
return rdtsc_frequency;
} }
} // namespace Common } // namespace Common

12
src/common/native_clock.h
View file

@ -3,7 +3,6 @@
#pragma once #pragma once
#include <chrono>
#include "common/types.h" #include "common/types.h"
namespace Common { namespace Common {
@ -12,20 +11,15 @@ class NativeClock final {
public: public:
explicit NativeClock(); explicit NativeClock();
u64 GetTscFrequency() const { u64 GetTimeUS(u64 time) const;
return rdtsc_frequency;
}
u64 GetTimeNS(u64 base_ptc = 0) const;
u64 GetTimeUS(u64 base_ptc = 0) const;
u64 GetTimeMS(u64 base_ptc = 0) const;
u64 GetUptime() const; u64 GetUptime() const;
u64 GetUnbiasedUptime() const;
u64 GetTscFrequency() const;
private: private:
u64 rdtsc_frequency; u64 rdtsc_frequency;
u64 ns_rdtsc_factor;
u64 us_rdtsc_factor; u64 us_rdtsc_factor;
u64 ms_rdtsc_factor;
}; };
} // namespace Common } // namespace Common

21
src/common/rdtsc.cpp
View file

@ -6,11 +6,12 @@
#include "common/uint128.h" #include "common/uint128.h"
#ifdef _WIN64 #ifdef _WIN64
#include <windows.h> #include <Windows.h>
#endif #endif
namespace Common { namespace Common {
#ifndef _WIN64
static constexpr size_t SecondToNanoseconds = 1000000000ULL; static constexpr size_t SecondToNanoseconds = 1000000000ULL;
template <u64 Nearest> template <u64 Nearest>
@ -20,16 +21,7 @@ static u64 RoundToNearest(u64 value) {
} }
static u64 GetTimeNs() { static u64 GetTimeNs() {
#ifdef _WIN64 #if defined(__APPLE__)
// GetSystemTimePreciseAsFileTime returns the file time in 100ns units.
static constexpr u64 Multiplier = 100;
// Convert Windows epoch to Unix epoch.
static constexpr u64 WindowsEpochToUnixEpoch = 0x19DB1DED53E8000LL;
FILETIME filetime;
GetSystemTimePreciseAsFileTime(&filetime);
return Multiplier * ((static_cast<u64>(filetime.dwHighDateTime) << 32) +
static_cast<u64>(filetime.dwLowDateTime) - WindowsEpochToUnixEpoch);
#elif defined(__APPLE__)
return clock_gettime_nsec_np(CLOCK_REALTIME); return clock_gettime_nsec_np(CLOCK_REALTIME);
#else #else
timespec ts; timespec ts;
@ -37,8 +29,14 @@ static u64 GetTimeNs() {
return ts.tv_sec * SecondToNanoseconds + ts.tv_nsec; return ts.tv_sec * SecondToNanoseconds + ts.tv_nsec;
#endif #endif
} }
#endif
u64 EstimateRDTSCFrequency() { u64 EstimateRDTSCFrequency() {
#ifdef _WIN64
LARGE_INTEGER frequency;
QueryPerformanceFrequency(&frequency);
return frequency.QuadPart;
#else
// Discard the first result measuring the rdtsc. // Discard the first result measuring the rdtsc.
FencedRDTSC(); FencedRDTSC();
std::this_thread::sleep_for(std::chrono::milliseconds{1}); std::this_thread::sleep_for(std::chrono::milliseconds{1});
@ -55,6 +53,7 @@ u64 EstimateRDTSCFrequency() {
const u64 tsc_diff = tsc_end - tsc_start; const u64 tsc_diff = tsc_end - tsc_start;
const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, end_time - start_time); const u64 tsc_freq = MultiplyAndDivide64(tsc_diff, 1000000000ULL, end_time - start_time);
return RoundToNearest<100'000>(tsc_freq); return RoundToNearest<100'000>(tsc_freq);
#endif
} }
} // namespace Common } // namespace Common

152
src/core/libraries/avplayer/avplayer.cpp
View file

@ -9,23 +9,22 @@
namespace Libraries::AvPlayer { 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); LOG_TRACE(Lib_AvPlayer, "filename = {}", filename);
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->AddSource(filename); return handle->AddSource(filename);
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
s32 PS4_SYSV_ABI sceAvPlayerAddSourceEx(SceAvPlayerHandle handle, SceAvPlayerUriType uriType, s32 PS4_SYSV_ABI sceAvPlayerAddSourceEx(AvPlayerHandle handle, AvPlayerUriType uri_type,
SceAvPlayerSourceDetails* sourceDetails) { AvPlayerSourceDetails* source_details) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr || uri_type != AvPlayerUriType::Source) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; 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() { int PS4_SYSV_ABI sceAvPlayerChangeStream() {
@ -33,20 +32,19 @@ int PS4_SYSV_ABI sceAvPlayerChangeStream() {
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceAvPlayerClose(SceAvPlayerHandle handle) { s32 PS4_SYSV_ABI sceAvPlayerClose(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
LOG_TRACE(Lib_AvPlayer, "returning ORBIS_AVPLAYER_ERROR_INVALID_PARAMS");
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
delete handle; delete handle;
LOG_TRACE(Lib_AvPlayer, "returning ORBIS_OK");
return ORBIS_OK; return ORBIS_OK;
} }
u64 PS4_SYSV_ABI sceAvPlayerCurrentTime(SceAvPlayerHandle handle) { u64 PS4_SYSV_ABI sceAvPlayerCurrentTime(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called"); // LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
LOG_TRACE(Lib_AvPlayer, "returning ORBIS_AVPLAYER_ERROR_INVALID_PARAMS");
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->CurrentTime(); const auto res = handle->CurrentTime();
@ -54,7 +52,7 @@ u64 PS4_SYSV_ABI sceAvPlayerCurrentTime(SceAvPlayerHandle handle) {
return res; return res;
} }
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"); LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
@ -62,60 +60,67 @@ s32 PS4_SYSV_ABI sceAvPlayerDisableStream(SceAvPlayerHandle handle, u32 stream_i
return ORBIS_OK; 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); LOG_TRACE(Lib_AvPlayer, "stream_id = {}", stream_id);
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->EnableStream(stream_id); return handle->EnableStream(stream_id);
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
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"); // LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr || p_info == nullptr) { if (handle == nullptr || p_info == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; LOG_TRACE(Lib_AvPlayer, "returning false");
return false;
} }
const auto res = handle->GetAudioData(*p_info); const auto res = handle->GetAudioData(*p_info);
LOG_TRACE(Lib_AvPlayer, "returning {}", res); if (res) {
LOG_TRACE(Lib_AvPlayer, "returning {}, ts = {}", res, p_info->timestamp);
} else {
LOG_TRACE(Lib_AvPlayer, "returning false");
}
return res; return res;
} }
s32 PS4_SYSV_ABI sceAvPlayerGetStreamInfo(SceAvPlayerHandle handle, u32 stream_id, s32 PS4_SYSV_ABI sceAvPlayerGetStreamInfo(AvPlayerHandle handle, u32 stream_id,
SceAvPlayerStreamInfo* p_info) { AvPlayerStreamInfo* p_info) {
LOG_TRACE(Lib_AvPlayer, "stream_id = {}", stream_id); LOG_TRACE(Lib_AvPlayer, "stream_id = {}", stream_id);
if (handle == nullptr || p_info == nullptr) { if (handle == nullptr || p_info == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->GetStreamInfo(stream_id, *p_info); return handle->GetStreamInfo(stream_id, *p_info);
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
bool PS4_SYSV_ABI sceAvPlayerGetVideoData(SceAvPlayerHandle handle, bool PS4_SYSV_ABI sceAvPlayerGetVideoData(AvPlayerHandle handle, AvPlayerFrameInfo* video_info) {
SceAvPlayerFrameInfo* video_info) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr || video_info == nullptr) { if (handle == nullptr || video_info == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return false;
} }
const auto res = handle->GetVideoData(*video_info); return handle->GetVideoData(*video_info);
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
bool PS4_SYSV_ABI sceAvPlayerGetVideoDataEx(SceAvPlayerHandle handle, bool PS4_SYSV_ABI sceAvPlayerGetVideoDataEx(AvPlayerHandle handle,
SceAvPlayerFrameInfoEx* video_info) { AvPlayerFrameInfoEx* video_info) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr || video_info == nullptr) { if (handle == nullptr || video_info == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; LOG_TRACE(Lib_AvPlayer, "returning {}", false);
return false;
} }
const auto res = handle->GetVideoData(*video_info);
LOG_TRACE(Lib_AvPlayer, "returning {}", res); // This is what the original library does, idk why
return res; for (int i = 0; i < 20; ++i) {
if (handle->GetVideoData(*video_info)) {
LOG_TRACE(Lib_AvPlayer, "returning {}, ts = {}", true, video_info->timestamp);
return true;
}
}
LOG_TRACE(Lib_AvPlayer, "returning {}", false);
return false;
} }
SceAvPlayerHandle PS4_SYSV_ABI sceAvPlayerInit(SceAvPlayerInitData* data) { AvPlayerHandle PS4_SYSV_ABI sceAvPlayerInit(AvPlayerInitData* data) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (data == nullptr) { if (data == nullptr) {
return nullptr; return nullptr;
@ -125,15 +130,14 @@ SceAvPlayerHandle PS4_SYSV_ABI sceAvPlayerInit(SceAvPlayerInitData* data) {
data->memory_replacement.allocate_texture == nullptr || data->memory_replacement.allocate_texture == nullptr ||
data->memory_replacement.deallocate == nullptr || data->memory_replacement.deallocate == nullptr ||
data->memory_replacement.deallocate_texture == 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 nullptr;
} }
return new AvPlayer(*data); return new AvPlayer(*data);
} }
s32 PS4_SYSV_ABI sceAvPlayerInitEx(const SceAvPlayerInitDataEx* p_data, s32 PS4_SYSV_ABI sceAvPlayerInitEx(const AvPlayerInitDataEx* p_data, AvPlayerHandle* p_player) {
SceAvPlayerHandle* p_player) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (p_data == nullptr || p_player == nullptr) { if (p_data == nullptr || p_player == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
@ -143,11 +147,11 @@ s32 PS4_SYSV_ABI sceAvPlayerInitEx(const SceAvPlayerInitDataEx* p_data,
p_data->memory_replacement.allocate_texture == nullptr || p_data->memory_replacement.allocate_texture == nullptr ||
p_data->memory_replacement.deallocate == nullptr || p_data->memory_replacement.deallocate == nullptr ||
p_data->memory_replacement.deallocate_texture == 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; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
SceAvPlayerInitData data = {}; AvPlayerInitData data = {};
data.memory_replacement = p_data->memory_replacement; data.memory_replacement = p_data->memory_replacement;
data.file_replacement = p_data->file_replacement; data.file_replacement = p_data->file_replacement;
data.event_replacement = p_data->event_replacement; data.event_replacement = p_data->event_replacement;
@ -159,8 +163,8 @@ s32 PS4_SYSV_ABI sceAvPlayerInitEx(const SceAvPlayerInitDataEx* p_data,
return ORBIS_OK; return ORBIS_OK;
} }
bool PS4_SYSV_ABI sceAvPlayerIsActive(SceAvPlayerHandle handle) { bool PS4_SYSV_ABI sceAvPlayerIsActive(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called"); // LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
LOG_TRACE(Lib_AvPlayer, "returning false"); LOG_TRACE(Lib_AvPlayer, "returning false");
return false; return false;
@ -170,7 +174,7 @@ bool PS4_SYSV_ABI sceAvPlayerIsActive(SceAvPlayerHandle handle) {
return res; return res;
} }
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); LOG_ERROR(Lib_AvPlayer, "(STUBBED) called, time (msec) = {}", time);
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
@ -178,22 +182,20 @@ s32 PS4_SYSV_ABI sceAvPlayerJumpToTime(SceAvPlayerHandle handle, uint64_t time)
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceAvPlayerPause(SceAvPlayerHandle handle) { s32 PS4_SYSV_ABI sceAvPlayerPause(AvPlayerHandle handle) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; 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"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr || data == nullptr) { if (handle == nullptr || data == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->PostInit(*data); return handle->PostInit(*data);
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
s32 PS4_SYSV_ABI sceAvPlayerPrintf(const char* format, ...) { s32 PS4_SYSV_ABI sceAvPlayerPrintf(const char* format, ...) {
@ -201,29 +203,28 @@ s32 PS4_SYSV_ABI sceAvPlayerPrintf(const char* format, ...) {
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceAvPlayerResume(SceAvPlayerHandle handle) { s32 PS4_SYSV_ABI sceAvPlayerResume(AvPlayerHandle handle) {
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
return ORBIS_OK; return handle->Resume();
} }
s32 PS4_SYSV_ABI sceAvPlayerSetAvSyncMode(SceAvPlayerHandle handle, s32 PS4_SYSV_ABI sceAvPlayerSetAvSyncMode(AvPlayerHandle handle, AvPlayerAvSyncMode sync_mode) {
SceAvPlayerAvSyncMode sync_mode) { LOG_TRACE(Lib_AvPlayer, "called");
LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; 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"); LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
return ORBIS_OK; 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); LOG_TRACE(Lib_AvPlayer, "called, looping = {}", loop_flag);
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
@ -234,7 +235,7 @@ s32 PS4_SYSV_ABI sceAvPlayerSetLooping(SceAvPlayerHandle handle, bool loop_flag)
return ORBIS_OK; 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"); LOG_ERROR(Lib_AvPlayer, "(STUBBED) called");
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
@ -242,35 +243,28 @@ s32 PS4_SYSV_ABI sceAvPlayerSetTrickSpeed(SceAvPlayerHandle handle, s32 trick_sp
return ORBIS_OK; return ORBIS_OK;
} }
s32 PS4_SYSV_ABI sceAvPlayerStart(SceAvPlayerHandle handle) { s32 PS4_SYSV_ABI sceAvPlayerStart(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->Start(); return handle->Start();
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
s32 PS4_SYSV_ABI sceAvPlayerStop(SceAvPlayerHandle handle) { s32 PS4_SYSV_ABI sceAvPlayerStop(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
LOG_TRACE(Lib_AvPlayer, "returning ORBIS_AVPLAYER_ERROR_INVALID_PARAMS");
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->Stop(); return handle->Stop();
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
s32 PS4_SYSV_ABI sceAvPlayerStreamCount(SceAvPlayerHandle handle) { s32 PS4_SYSV_ABI sceAvPlayerStreamCount(AvPlayerHandle handle) {
LOG_TRACE(Lib_AvPlayer, "called"); LOG_TRACE(Lib_AvPlayer, "called");
if (handle == nullptr) { if (handle == nullptr) {
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS;
} }
const auto res = handle->GetStreamCount(); return static_cast<s32>(handle->GetStreamCount());
LOG_TRACE(Lib_AvPlayer, "returning {}", res);
return res;
} }
s32 PS4_SYSV_ABI sceAvPlayerVprintf(const char* format, va_list args) { s32 PS4_SYSV_ABI sceAvPlayerVprintf(const char* format, va_list args) {

165
src/core/libraries/avplayer/avplayer.h
View file

@ -16,38 +16,38 @@ namespace Libraries::AvPlayer {
class AvPlayer; class AvPlayer;
using SceAvPlayerHandle = AvPlayer*; using AvPlayerHandle = AvPlayer*;
enum class SceAvPlayerUriType : u32 { enum class AvPlayerUriType : u32 {
Source = 0, Source = 0,
}; };
struct SceAvPlayerUri { struct AvPlayerUri {
const char* name; const char* name;
u32 length; u32 length;
}; };
enum class SceAvPlayerSourceType { enum class AvPlayerSourceType {
Unknown = 0, Unknown = 0,
FileMp4 = 1, FileMp4 = 1,
Hls = 8, Hls = 8,
}; };
enum class SceAvPlayerStreamType : u32 { enum class AvPlayerStreamType : u32 {
Video, Video,
Audio, Audio,
TimedText, TimedText,
Unknown, Unknown,
}; };
struct SceAvPlayerSourceDetails { struct AvPlayerSourceDetails {
SceAvPlayerUri uri; AvPlayerUri uri;
u8 reserved1[64]; u8 reserved1[64];
SceAvPlayerSourceType source_type; AvPlayerSourceType source_type;
u8 reserved2[44]; u8 reserved2[44];
}; };
struct SceAvPlayerAudio { struct AvPlayerAudio {
u16 channel_count; u16 channel_count;
u8 reserved1[2]; u8 reserved1[2];
u32 sample_rate; u32 sample_rate;
@ -55,50 +55,50 @@ struct SceAvPlayerAudio {
u8 language_code[4]; u8 language_code[4];
}; };
struct SceAvPlayerVideo { struct AvPlayerVideo {
u32 width; u32 width;
u32 height; u32 height;
f32 aspect_ratio; f32 aspect_ratio;
char language_code[4]; char language_code[4];
}; };
struct SceAvPlayerTextPosition { struct AvPlayerTextPosition {
u16 top; u16 top;
u16 left; u16 left;
u16 bottom; u16 bottom;
u16 right; u16 right;
}; };
struct SceAvPlayerTimedText { struct AvPlayerTimedText {
u8 language_code[4]; u8 language_code[4];
u16 text_size; u16 text_size;
u16 font_size; u16 font_size;
SceAvPlayerTextPosition position; AvPlayerTextPosition position;
}; };
union SceAvPlayerStreamDetails { union AvPlayerStreamDetails {
u8 reserved[16]; u8 reserved[16];
SceAvPlayerAudio audio; AvPlayerAudio audio;
SceAvPlayerVideo video; AvPlayerVideo video;
SceAvPlayerTimedText subs; AvPlayerTimedText subs;
}; };
struct SceAvPlayerFrameInfo { struct AvPlayerFrameInfo {
u8* pData; u8* p_data;
u8 reserved[4]; u8 reserved[4];
u64 timestamp; u64 timestamp;
SceAvPlayerStreamDetails details; AvPlayerStreamDetails details;
}; };
struct SceAvPlayerStreamInfo { struct AvPlayerStreamInfo {
SceAvPlayerStreamType type; AvPlayerStreamType type;
u8 reserved[4]; u8 reserved[4];
SceAvPlayerStreamDetails details; AvPlayerStreamDetails details;
u64 duration; u64 duration;
u64 start_time; u64 start_time;
}; };
struct SceAvPlayerAudioEx { struct AvPlayerAudioEx {
u16 channel_count; u16 channel_count;
u8 reserved[2]; u8 reserved[2];
u32 sample_rate; u32 sample_rate;
@ -107,7 +107,7 @@ struct SceAvPlayerAudioEx {
u8 reserved1[64]; u8 reserved1[64];
}; };
struct SceAvPlayerVideoEx { struct AvPlayerVideoEx {
u32 width; u32 width;
u32 height; u32 height;
f32 aspect_ratio; f32 aspect_ratio;
@ -124,53 +124,54 @@ struct SceAvPlayerVideoEx {
u8 reserved1[37]; u8 reserved1[37];
}; };
struct SceAvPlayerTimedTextEx { struct AvPlayerTimedTextEx {
u8 language_code[4]; u8 language_code[4];
u8 reserved[12]; u8 reserved[12];
u8 reserved1[64]; u8 reserved1[64];
}; };
union SceAvPlayerStreamDetailsEx { union AvPlayerStreamDetailsEx {
SceAvPlayerAudioEx audio; AvPlayerAudioEx audio;
SceAvPlayerVideoEx video; AvPlayerVideoEx video;
SceAvPlayerTimedTextEx subs; AvPlayerTimedTextEx subs;
u8 reserved1[80]; u8 reserved1[80];
}; };
struct SceAvPlayerFrameInfoEx { struct AvPlayerFrameInfoEx {
void* pData; void* p_data;
u8 reserved[4]; u8 reserved[4];
u64 timestamp; u64 timestamp;
SceAvPlayerStreamDetailsEx details; AvPlayerStreamDetailsEx details;
}; };
using SceAvPlayerAllocate = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size); using AvPlayerAllocate = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size);
using SceAvPlayerDeallocate = void PS4_SYSV_ABI (*)(void* p, void* mem); using AvPlayerDeallocate = void PS4_SYSV_ABI (*)(void* p, void* mem);
using SceAvPlayerAllocateTexture = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size); using AvPlayerAllocateTexture = void* PS4_SYSV_ABI (*)(void* p, u32 align, u32 size);
using SceAvPlayerDeallocateTexture = void PS4_SYSV_ABI (*)(void* p, void* mem); using AvPlayerDeallocateTexture = void PS4_SYSV_ABI (*)(void* p, void* mem);
struct SceAvPlayerMemAllocator { struct AvPlayerMemAllocator {
void* object_ptr; void* object_ptr;
SceAvPlayerAllocate allocate; AvPlayerAllocate allocate;
SceAvPlayerDeallocate deallocate; AvPlayerDeallocate deallocate;
SceAvPlayerAllocateTexture allocate_texture; AvPlayerAllocateTexture allocate_texture;
SceAvPlayerDeallocateTexture deallocate_texture; AvPlayerDeallocateTexture deallocate_texture;
}; };
using SceAvPlayerOpenFile = s32 PS4_SYSV_ABI (*)(void* p, const char* name); using AvPlayerOpenFile = s32 PS4_SYSV_ABI (*)(void* p, const char* name);
using SceAvPlayerCloseFile = s32 PS4_SYSV_ABI (*)(void* p); using AvPlayerCloseFile = s32 PS4_SYSV_ABI (*)(void* p);
using SceAvPlayerReadOffsetFile = s32 PS4_SYSV_ABI (*)(void* p, u8* buf, u64 pos, u32 len); using AvPlayerReadOffsetFile = s32 PS4_SYSV_ABI (*)(void* p, u8* buf, u64 pos, u32 len);
using SceAvPlayerSizeFile = u64 PS4_SYSV_ABI (*)(void* p); using AvPlayerSizeFile = u64 PS4_SYSV_ABI (*)(void* p);
struct SceAvPlayerFileReplacement { struct AvPlayerFileReplacement {
void* object_ptr; void* object_ptr;
SceAvPlayerOpenFile open; AvPlayerOpenFile open;
SceAvPlayerCloseFile close; AvPlayerCloseFile close;
SceAvPlayerReadOffsetFile readOffset; AvPlayerReadOffsetFile read_offset;
SceAvPlayerSizeFile size; AvPlayerSizeFile size;
}; };
enum class SceAvPlayerEvents { enum class AvPlayerEvents {
Initial = 0x00,
StateStop = 0x01, StateStop = 0x01,
StateReady = 0x02, StateReady = 0x02,
StatePlay = 0x03, StatePlay = 0x03,
@ -182,26 +183,26 @@ enum class SceAvPlayerEvents {
DrmError = 0x40, DrmError = 0x40,
}; };
using SceAvPlayerEventCallback = void PS4_SYSV_ABI (*)(void* p, SceAvPlayerEvents event, s32 src_id, using AvPlayerEventCallback = void PS4_SYSV_ABI (*)(void* p, AvPlayerEvents event, s32 src_id,
void* data); void* data);
struct SceAvPlayerEventReplacement { struct AvPlayerEventReplacement {
void* object_ptr; void* object_ptr;
SceAvPlayerEventCallback event_callback; AvPlayerEventCallback event_callback;
}; };
enum class SceAvPlayerDebuglevels { enum class AvPlayerDebuglevels {
None, None,
Info, Info,
Warnings, Warnings,
All, All,
}; };
struct SceAvPlayerInitData { struct AvPlayerInitData {
SceAvPlayerMemAllocator memory_replacement; AvPlayerMemAllocator memory_replacement;
SceAvPlayerFileReplacement file_replacement; AvPlayerFileReplacement file_replacement;
SceAvPlayerEventReplacement event_replacement; AvPlayerEventReplacement event_replacement;
SceAvPlayerDebuglevels debug_level; AvPlayerDebuglevels debug_level;
u32 base_priority; u32 base_priority;
s32 num_output_video_framebuffers; s32 num_output_video_framebuffers;
bool auto_start; bool auto_start;
@ -209,13 +210,13 @@ struct SceAvPlayerInitData {
const char* default_language; const char* default_language;
}; };
struct SceAvPlayerInitDataEx { struct AvPlayerInitDataEx {
size_t this_size; size_t this_size;
SceAvPlayerMemAllocator memory_replacement; AvPlayerMemAllocator memory_replacement;
SceAvPlayerFileReplacement file_replacement; AvPlayerFileReplacement file_replacement;
SceAvPlayerEventReplacement event_replacement; AvPlayerEventReplacement event_replacement;
const char* default_language; const char* default_language;
SceAvPlayerDebuglevels debug_level; AvPlayerDebuglevels debug_level;
u32 audio_decoder_priority; u32 audio_decoder_priority;
u32 audio_decoder_affinity; u32 audio_decoder_affinity;
u32 video_decoder_priority; u32 video_decoder_priority;
@ -233,25 +234,25 @@ struct SceAvPlayerInitDataEx {
u8 reserved[3]; u8 reserved[3];
}; };
enum class SceAvPlayerVideoDecoderType { enum class AvPlayerVideoDecoderType {
Default = 0, Default = 0,
Reserved1, Reserved1,
Software, Software,
Software2, Software2,
}; };
enum class SceAvPlayerAudioDecoderType { enum class AvPlayerAudioDecoderType {
Default = 0, Default = 0,
Reserved1, Reserved1,
Reserved2, Reserved2,
}; };
struct SceAvPlayerDecoderInit { struct AvPlayerDecoderInit {
union { union {
SceAvPlayerVideoDecoderType video_type; AvPlayerVideoDecoderType video_type;
SceAvPlayerAudioDecoderType audio_type; AvPlayerAudioDecoderType audio_type;
u8 reserved[4]; u8 reserved[4];
} decoderType; } decoder_type;
union { union {
struct { struct {
s32 cpu_affinity_mask; s32 cpu_affinity_mask;
@ -261,34 +262,34 @@ struct SceAvPlayerDecoderInit {
u8 compute_queue_id; u8 compute_queue_id;
u8 enable_interlaced; u8 enable_interlaced;
u8 reserved[16]; u8 reserved[16];
} avcSw2; } avc_sw2;
struct { struct {
u8 audio_channel_order; u8 audio_channel_order;
u8 reserved[27]; u8 reserved[27];
} aac; } aac;
u8 reserved[28]; u8 reserved[28];
} decoderParams; } decoder_params;
}; };
struct SceAvPlayerHTTPCtx { struct AvPlayerHTTPCtx {
u32 http_context_id; u32 http_context_id;
u32 ssl_context_id; u32 ssl_context_id;
}; };
struct SceAvPlayerPostInitData { struct AvPlayerPostInitData {
u32 demux_video_buffer_size; u32 demux_video_buffer_size;
SceAvPlayerDecoderInit video_decoder_init; AvPlayerDecoderInit video_decoder_init;
SceAvPlayerDecoderInit audio_decoder_init; AvPlayerDecoderInit audio_decoder_init;
SceAvPlayerHTTPCtx http_context; AvPlayerHTTPCtx http_context;
u8 reserved[56]; u8 reserved[56];
}; };
enum class SceAvPlayerAvSyncMode { enum class AvPlayerAvSyncMode {
Default = 0, Default = 0,
None, 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); void RegisterlibSceAvPlayer(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); }); 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()) { if (path.empty()) {
return SceAvPlayerSourceType::Unknown; return AvPlayerSourceType::Unknown;
} }
std::string_view name = path; std::string_view name = path;
@ -25,14 +25,14 @@ SceAvPlayerSourceType GetSourceType(std::string_view path) {
// -> schema://server.domain/path/to/file.ext/and/beyond // -> schema://server.domain/path/to/file.ext/and/beyond
name = path.substr(0, path.find_first_of("?#")); name = path.substr(0, path.find_first_of("?#"));
if (name.empty()) { if (name.empty()) {
return SceAvPlayerSourceType::Unknown; return AvPlayerSourceType::Unknown;
} }
} }
// schema://server.domain/path/to/file.ext/and/beyond -> .ext/and/beyond // schema://server.domain/path/to/file.ext/and/beyond -> .ext/and/beyond
auto ext = name.substr(name.rfind('.')); auto ext = name.substr(name.rfind('.'));
if (ext.empty()) { if (ext.empty()) {
return SceAvPlayerSourceType::Unknown; return AvPlayerSourceType::Unknown;
} }
// .ext/and/beyond -> .ext // .ext/and/beyond -> .ext
@ -40,14 +40,14 @@ SceAvPlayerSourceType GetSourceType(std::string_view path) {
if (iequals(ext, ".mp4") || iequals(ext, ".m4v") || iequals(ext, ".m3d") || if (iequals(ext, ".mp4") || iequals(ext, ".m4v") || iequals(ext, ".m3d") ||
iequals(ext, ".m4a") || iequals(ext, ".mov")) { iequals(ext, ".m4a") || iequals(ext, ".mov")) {
return SceAvPlayerSourceType::FileMp4; return AvPlayerSourceType::FileMp4;
} }
if (iequals(ext, ".m3u8")) { if (iequals(ext, ".m3u8")) {
return SceAvPlayerSourceType::Hls; return AvPlayerSourceType::Hls;
} }
return SceAvPlayerSourceType::Unknown; return AvPlayerSourceType::Unknown;
} }
} // namespace Libraries::AvPlayer } // namespace Libraries::AvPlayer

10
src/core/libraries/avplayer/avplayer_common.h
View file

@ -16,6 +16,7 @@
namespace Libraries::AvPlayer { namespace Libraries::AvPlayer {
enum class AvState { enum class AvState {
Unknown,
Initial, Initial,
AddingSource, AddingSource,
Ready, Ready,
@ -23,12 +24,13 @@ enum class AvState {
Stop, Stop,
EndOfFile, EndOfFile,
Pause, Pause,
C0x08, PauseOnEOF,
Jump, Jump,
TrickMode, TrickMode,
C0x0B, C0x0B,
Buffering, Buffering,
Starting, Starting,
C0x10,
Error, Error,
}; };
@ -64,6 +66,10 @@ public:
m_queue.emplace(std::forward<T>(value)); m_queue.emplace(std::forward<T>(value));
} }
T& Front() {
return m_queue.front();
}
std::optional<T> Pop() { std::optional<T> Pop() {
if (Size() == 0) { if (Size() == 0) {
return std::nullopt; return std::nullopt;
@ -84,6 +90,6 @@ private:
std::queue<T> m_queue{}; std::queue<T> m_queue{};
}; };
SceAvPlayerSourceType GetSourceType(std::string_view path); AvPlayerSourceType GetSourceType(std::string_view path);
} // namespace Libraries::AvPlayer } // 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 { namespace Libraries::AvPlayer {
AvPlayerFileStreamer::AvPlayerFileStreamer(const SceAvPlayerFileReplacement& file_replacement) AvPlayerFileStreamer::AvPlayerFileStreamer(const AvPlayerFileReplacement& file_replacement)
: m_file_replacement(file_replacement) {} : m_file_replacement(file_replacement) {}
AvPlayerFileStreamer::~AvPlayerFileStreamer() { AvPlayerFileStreamer::~AvPlayerFileStreamer() {
@ -51,7 +51,7 @@ s32 AvPlayerFileStreamer::ReadPacket(void* opaque, u8* buffer, s32 size) {
if (self->m_position + size > self->m_file_size) { if (self->m_position + size > self->m_file_size) {
size = self->m_file_size - self->m_position; 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 ptr = self->m_file_replacement.object_ptr;
const auto bytes_read = read_offset(ptr, buffer, self->m_position, size); const auto bytes_read = read_offset(ptr, buffer, self->m_position, size);
if (bytes_read == 0 && size != 0) { 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 { class AvPlayerFileStreamer : public IDataStreamer {
public: public:
AvPlayerFileStreamer(const SceAvPlayerFileReplacement& file_replacement); AvPlayerFileStreamer(const AvPlayerFileReplacement& file_replacement);
~AvPlayerFileStreamer(); ~AvPlayerFileStreamer();
bool Init(std::string_view path) override; bool Init(std::string_view path) override;
@ -26,7 +26,7 @@ private:
static s32 ReadPacket(void* opaque, u8* buffer, s32 size); static s32 ReadPacket(void* opaque, u8* buffer, s32 size);
static s64 Seek(void* opaque, s64 buffer, int whence); static s64 Seek(void* opaque, s64 buffer, int whence);
SceAvPlayerFileReplacement m_file_replacement; AvPlayerFileReplacement m_file_replacement;
int m_fd = -1; int m_fd = -1;
u64 m_position{}; u64 m_position{};

69
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); auto const self = reinterpret_cast<AvPlayer*>(handle);
std::lock_guard guard(self->m_file_io_mutex); 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; const auto ptr = self->m_init_data_original.file_replacement.object_ptr;
return Core::ExecuteGuest(read_offset, ptr, buffer, position, length); 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); return Core::ExecuteGuest(size, ptr);
} }
SceAvPlayerInitData AvPlayer::StubInitData(const SceAvPlayerInitData& data) { AvPlayerInitData AvPlayer::StubInitData(const AvPlayerInitData& data) {
SceAvPlayerInitData result = data; AvPlayerInitData result = data;
result.memory_replacement.object_ptr = this; result.memory_replacement.object_ptr = this;
result.memory_replacement.allocate = &AvPlayer::Allocate; result.memory_replacement.allocate = &AvPlayer::Allocate;
result.memory_replacement.deallocate = &AvPlayer::Deallocate; result.memory_replacement.deallocate = &AvPlayer::Deallocate;
result.memory_replacement.allocate_texture = &AvPlayer::AllocateTexture; result.memory_replacement.allocate_texture = &AvPlayer::AllocateTexture;
result.memory_replacement.deallocate_texture = &AvPlayer::DeallocateTexture; result.memory_replacement.deallocate_texture = &AvPlayer::DeallocateTexture;
if (data.file_replacement.open == nullptr || data.file_replacement.close == nullptr || 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 = {}; result.file_replacement = {};
} else { } else {
result.file_replacement.object_ptr = this; result.file_replacement.object_ptr = this;
result.file_replacement.open = &AvPlayer::OpenFile; result.file_replacement.open = &AvPlayer::OpenFile;
result.file_replacement.close = &AvPlayer::CloseFile; 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; result.file_replacement.size = &AvPlayer::SizeFile;
} }
return result; return result;
} }
AvPlayer::AvPlayer(const SceAvPlayerInitData& data) AvPlayer::AvPlayer(const AvPlayerInitData& data)
: m_init_data(StubInitData(data)), m_init_data_original(data), : m_init_data(StubInitData(data)), m_init_data_original(data),
m_state(std::make_unique<AvPlayerState>(m_init_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); m_state->PostInit(data);
return ORBIS_OK; return ORBIS_OK;
} }
s32 AvPlayer::AddSource(std::string_view path) { s32 AvPlayer::AddSource(std::string_view path) {
if (path.empty()) { return AddSourceEx(path, AvPlayerSourceType::Unknown);
return ORBIS_AVPLAYER_ERROR_INVALID_PARAMS; }
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))) { if (!m_state->AddSource(path, GetSourceType(path))) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED; return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
@ -111,18 +119,11 @@ s32 AvPlayer::AddSource(std::string_view path) {
return ORBIS_OK; return ORBIS_OK;
} }
s32 AvPlayer::GetStreamCount() { u32 AvPlayer::GetStreamCount() {
if (m_state == nullptr) { return m_state->GetStreamCount();
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
}
const auto res = m_state->GetStreamCount();
if (AVPLAYER_IS_ERROR(res)) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
}
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)) { if (!m_state->GetStreamInfo(stream_index, info)) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED; return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
} }
@ -140,27 +141,49 @@ s32 AvPlayer::EnableStream(u32 stream_index) {
} }
s32 AvPlayer::Start() { s32 AvPlayer::Start() {
if (!m_state->Start()) { if (m_state == nullptr || !m_state->Start()) {
return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED; return ORBIS_AVPLAYER_ERROR_OPERATION_FAILED;
} }
return ORBIS_OK; 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) { if (m_state == nullptr) {
return false; return false;
} }
return m_state->GetVideoData(video_info); return m_state->GetVideoData(video_info);
} }
bool AvPlayer::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { bool AvPlayer::GetVideoData(AvPlayerFrameInfoEx& video_info) {
if (m_state == nullptr) { if (m_state == nullptr) {
return false; return false;
} }
return m_state->GetVideoData(video_info); return m_state->GetVideoData(video_info);
} }
bool AvPlayer::GetAudioData(SceAvPlayerFrameInfo& audio_info) { bool AvPlayer::GetAudioData(AvPlayerFrameInfo& audio_info) {
if (m_state == nullptr) { if (m_state == nullptr) {
return false; return false;
} }

24
src/core/libraries/avplayer/avplayer_impl.h
View file

@ -19,17 +19,21 @@ namespace Libraries::AvPlayer {
class AvPlayer { class AvPlayer {
public: 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 AddSource(std::string_view filename);
s32 GetStreamCount(); s32 AddSourceEx(std::string_view path, AvPlayerSourceType source_type);
s32 GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info); u32 GetStreamCount();
s32 GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info);
s32 EnableStream(u32 stream_index); s32 EnableStream(u32 stream_index);
s32 Start(); s32 Start();
bool GetAudioData(SceAvPlayerFrameInfo& audio_info); s32 Pause();
bool GetVideoData(SceAvPlayerFrameInfo& video_info); s32 Resume();
bool GetVideoData(SceAvPlayerFrameInfoEx& video_info); s32 SetAvSyncMode(AvPlayerAvSyncMode sync_mode);
bool GetAudioData(AvPlayerFrameInfo& audio_info);
bool GetVideoData(AvPlayerFrameInfo& video_info);
bool GetVideoData(AvPlayerFrameInfoEx& video_info);
bool IsActive(); bool IsActive();
u64 CurrentTime(); u64 CurrentTime();
s32 Stop(); s32 Stop();
@ -48,10 +52,10 @@ private:
static int PS4_SYSV_ABI ReadOffsetFile(void* handle, u8* buffer, u64 position, u32 length); static int PS4_SYSV_ABI ReadOffsetFile(void* handle, u8* buffer, u64 position, u32 length);
static u64 PS4_SYSV_ABI SizeFile(void* handle); static u64 PS4_SYSV_ABI SizeFile(void* handle);
SceAvPlayerInitData StubInitData(const SceAvPlayerInitData& data); AvPlayerInitData StubInitData(const AvPlayerInitData& data);
SceAvPlayerInitData m_init_data{}; AvPlayerInitData m_init_data{};
SceAvPlayerInitData m_init_data_original{}; AvPlayerInitData m_init_data_original{};
std::mutex m_file_io_mutex{}; std::mutex m_file_io_mutex{};
std::atomic_bool m_has_source{}; std::atomic_bool m_has_source{};

234
src/core/libraries/avplayer/avplayer_source.cpp
View file

@ -5,6 +5,7 @@
#include "common/singleton.h" #include "common/singleton.h"
#include "common/thread.h" #include "common/thread.h"
#include "core/file_sys/fs.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_file_streamer.h"
#include "core/libraries/avplayer/avplayer_source.h" #include "core/libraries/avplayer/avplayer_source.h"
@ -29,7 +30,7 @@ AvPlayerSource::~AvPlayerSource() {
Stop(); 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_memory_replacement = init_data.memory_replacement,
m_num_output_video_framebuffers = m_num_output_video_framebuffers =
std::min(std::max(2, init_data.num_output_video_framebuffers), 16); std::min(std::max(2, init_data.num_output_video_framebuffers), 16);
@ -76,25 +77,21 @@ s32 AvPlayerSource::GetStreamCount() {
return m_avformat_context->nb_streams; return m_avformat_context->nb_streams;
} }
static SceAvPlayerStreamType CodecTypeToStreamType(AVMediaType codec_type) { static AvPlayerStreamType CodecTypeToStreamType(AVMediaType codec_type) {
switch (codec_type) { switch (codec_type) {
case AVMediaType::AVMEDIA_TYPE_VIDEO: case AVMediaType::AVMEDIA_TYPE_VIDEO:
return SceAvPlayerStreamType::Video; return AvPlayerStreamType::Video;
case AVMediaType::AVMEDIA_TYPE_AUDIO: case AVMediaType::AVMEDIA_TYPE_AUDIO:
return SceAvPlayerStreamType::Audio; return AvPlayerStreamType::Audio;
case AVMediaType::AVMEDIA_TYPE_SUBTITLE: case AVMediaType::AVMEDIA_TYPE_SUBTITLE:
return SceAvPlayerStreamType::TimedText; return AvPlayerStreamType::TimedText;
default: default:
LOG_ERROR(Lib_AvPlayer, "Unexpected AVMediaType {}", magic_enum::enum_name(codec_type)); LOG_ERROR(Lib_AvPlayer, "Unexpected AVMediaType {}", magic_enum::enum_name(codec_type));
return SceAvPlayerStreamType::Unknown; return AvPlayerStreamType::Unknown;
} }
} }
static f32 AVRationalToF32(const AVRational rational) { bool AvPlayerSource::GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info) {
return f32(rational.num) / rational.den;
}
bool AvPlayerSource::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info) {
info = {}; info = {};
if (m_avformat_context == nullptr || stream_index >= m_avformat_context->nb_streams) { if (m_avformat_context == nullptr || stream_index >= m_avformat_context->nb_streams) {
LOG_ERROR(Lib_AvPlayer, "Could not get stream {} info.", stream_index); 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); LOG_WARNING(Lib_AvPlayer, "Stream {} language is unknown", stream_index);
} }
switch (info.type) { switch (info.type) {
case SceAvPlayerStreamType::Video: { case AvPlayerStreamType::Video: {
LOG_INFO(Lib_AvPlayer, "Stream {} is a video stream.", stream_index); LOG_INFO(Lib_AvPlayer, "Stream {} is a video stream.", stream_index);
info.details.video.aspect_ratio = info.details.video.aspect_ratio =
f32(p_stream->codecpar->width) / p_stream->codecpar->height; f32(p_stream->codecpar->width) / p_stream->codecpar->height;
@ -133,7 +130,7 @@ bool AvPlayerSource::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info
} }
break; break;
} }
case SceAvPlayerStreamType::Audio: { case AvPlayerStreamType::Audio: {
LOG_INFO(Lib_AvPlayer, "Stream {} is an audio stream.", stream_index); 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.channel_count = p_stream->codecpar->ch_layout.nb_channels;
info.details.audio.sample_rate = p_stream->codecpar->sample_rate; info.details.audio.sample_rate = p_stream->codecpar->sample_rate;
@ -144,7 +141,7 @@ bool AvPlayerSource::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info
} }
break; break;
} }
case SceAvPlayerStreamType::TimedText: { case AvPlayerStreamType::TimedText: {
LOG_WARNING(Lib_AvPlayer, "Stream {} is a timedtext stream.", stream_index); LOG_WARNING(Lib_AvPlayer, "Stream {} is a timedtext stream.", stream_index);
info.details.subs.font_size = 12; info.details.subs.font_size = 12;
info.details.subs.text_size = 12; info.details.subs.text_size = 12;
@ -264,14 +261,13 @@ bool AvPlayerSource::Stop() {
m_demuxer_thread.Stop(); m_demuxer_thread.Stop();
if (m_current_audio_frame.has_value()) { if (m_current_audio_frame.has_value()) {
m_audio_buffers.Push(std::move(m_current_audio_frame.value())); m_audio_buffers.Push(std::move(m_current_audio_frame->buffer));
m_current_audio_frame.reset(); m_current_audio_frame.reset();
} }
if (m_current_video_frame.has_value()) { if (m_current_video_frame.has_value()) {
m_video_buffers.Push(std::move(m_current_video_frame.value())); m_video_buffers.Push(std::move(m_current_video_frame->buffer));
m_current_video_frame.reset(); m_current_video_frame.reset();
} }
m_stop_cv.Notify();
m_audio_packets.Clear(); m_audio_packets.Clear();
m_video_packets.Clear(); m_video_packets.Clear();
@ -280,97 +276,91 @@ bool AvPlayerSource::Stop() {
return true; return true;
} }
bool AvPlayerSource::GetVideoData(SceAvPlayerFrameInfo& video_info) { void AvPlayerSource::Pause() {
if (!IsActive()) { m_pause_time = std::chrono::high_resolution_clock::now();
return false; 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)) { if (!GetVideoData(info)) {
return false; return false;
} }
video_info = {}; video_info = {};
video_info.timestamp = u64(info.timestamp); 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.aspect_ratio = info.details.video.aspect_ratio;
video_info.details.video.width = info.details.video.width; video_info.details.video.width = info.details.video.width;
video_info.details.video.height = info.details.video.height; video_info.details.video.height = info.details.video.height;
return true; return true;
} }
bool AvPlayerSource::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { bool AvPlayerSource::GetVideoData(AvPlayerFrameInfoEx& video_info) {
if (!IsActive()) { if (!IsActive() || m_is_paused) {
return false; return false;
} }
m_video_frames_cv.Wait([this] { return m_video_frames.Size() != 0 || m_is_eof; }); if (m_video_frames.Size() == 0) {
auto frame = m_video_frames.Pop();
if (!frame.has_value()) {
LOG_TRACE(Lib_AvPlayer, "Could get video frame. EOF reached.");
return false; return false;
} }
{ const auto& new_frame = m_video_frames.Front();
using namespace std::chrono; if (m_state.GetSyncMode() == AvPlayerAvSyncMode::Default) {
auto elapsed_time = const auto current_time = CurrentTime();
duration_cast<milliseconds>(high_resolution_clock::now() - m_start_time).count(); if (0 < current_time && current_time < new_frame.info.timestamp) {
if (elapsed_time < frame->info.timestamp) { LOG_TRACE(Lib_AvPlayer, "{} < {}", current_time, new_frame.info.timestamp);
if (m_stop_cv.WaitFor(milliseconds(frame->info.timestamp - elapsed_time), return false;
[&] { return elapsed_time >= frame->info.timestamp; })) {
return false;
}
} }
} }
// return the buffer to the queue auto frame = m_video_frames.Pop();
if (m_current_video_frame.has_value()) { if (m_current_video_frame.has_value()) {
m_video_buffers.Push(std::move(m_current_video_frame.value())); // return the buffer to the queue
m_video_buffers.Push(std::move(m_current_video_frame->buffer));
m_video_buffers_cv.Notify(); m_video_buffers_cv.Notify();
} }
m_current_video_frame = std::move(frame->buffer);
if (frame->is_loop && m_is_looping) {
m_state.OnLoop();
}
video_info = frame->info; video_info = frame->info;
m_current_video_frame = std::move(frame);
return true; return true;
} }
bool AvPlayerSource::GetAudioData(SceAvPlayerFrameInfo& audio_info) { bool AvPlayerSource::GetAudioData(AvPlayerFrameInfo& audio_info) {
if (!IsActive()) { if (!IsActive() || m_is_paused) {
return false; return false;
} }
m_audio_frames_cv.Wait([this] { return m_audio_frames.Size() != 0 || m_is_eof; }); if (m_audio_frames.Size() == 0) {
return false;
}
auto frame = m_audio_frames.Pop(); 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
if (m_current_audio_frame.has_value()) { 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_audio_buffers_cv.Notify(); m_audio_buffers_cv.Notify();
} }
m_current_audio_frame = std::move(frame->buffer);
if (frame->is_loop && m_is_looping) {
m_state.OnLoop();
}
audio_info = {}; audio_info = {};
audio_info.timestamp = frame->info.timestamp; 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.sample_rate = frame->info.details.audio.sample_rate;
audio_info.details.audio.size = frame->info.details.audio.size; audio_info.details.audio.size = frame->info.details.audio.size;
audio_info.details.audio.channel_count = frame->info.details.audio.channel_count; audio_info.details.audio.channel_count = frame->info.details.audio.channel_count;
m_current_audio_frame = std::move(frame);
return true; return true;
} }
@ -379,7 +369,9 @@ u64 AvPlayerSource::CurrentTime() {
return 0; return 0;
} }
using namespace std::chrono; 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 -
m_pause_duration)
.count();
} }
bool AvPlayerSource::IsActive() { bool AvPlayerSource::IsActive() {
@ -423,8 +415,11 @@ void AvPlayerSource::ReleaseAVFormatContext(AVFormatContext* context) {
} }
} }
// Custom flag that is not passed to ffmpeg
// It's here to get rid of the need for a separate structure
#define AV_PKT_FLAG_LOOP 0x100000
void AvPlayerSource::DemuxerThread(std::stop_token stop) { void AvPlayerSource::DemuxerThread(std::stop_token stop) {
using namespace std::chrono;
Common::SetCurrentThreadName("shadPS4:AvDemuxer"); Common::SetCurrentThreadName("shadPS4:AvDemuxer");
if (!m_audio_stream_index.has_value() && !m_video_stream_index.has_value()) { if (!m_audio_stream_index.has_value() && !m_video_stream_index.has_value()) {
@ -433,49 +428,46 @@ void AvPlayerSource::DemuxerThread(std::stop_token stop) {
} }
LOG_INFO(Lib_AvPlayer, "Demuxer Thread started"); LOG_INFO(Lib_AvPlayer, "Demuxer Thread started");
bool is_loop = false;
while (!stop.stop_requested()) { while (!stop.stop_requested()) {
if (m_video_packets.Size() > 30 && if (m_video_packets.Size() > 30 &&
(!m_audio_stream_index.has_value() || m_audio_packets.Size() > 8)) { (!m_audio_stream_index.has_value() || m_audio_packets.Size() > 8)) {
std::this_thread::sleep_for(milliseconds(5)); std::this_thread::sleep_for(std::chrono::milliseconds(5));
continue; continue;
} }
AVPacketPtr up_packet(av_packet_alloc(), &ReleaseAVPacket); AVPacketPtr up_packet(av_packet_alloc(), &ReleaseAVPacket);
const auto res = av_read_frame(m_avformat_context.get(), up_packet.get()); const auto res = av_read_frame(m_avformat_context.get(), up_packet.get());
if (res < 0) { if (res >= 0) [[likely]] {
if (res == AVERROR_EOF) { if (is_loop) {
if (m_is_looping) { up_packet->flags |= AV_PKT_FLAG_LOOP;
LOG_INFO(Lib_AvPlayer, "EOF reached in demuxer. Looping the source..."); is_loop = false;
avio_seek(m_avformat_context->pb, 0, SEEK_SET);
if (m_video_stream_index.has_value()) {
const auto index = m_video_stream_index.value();
const auto stream = m_avformat_context->streams[index];
avformat_seek_file(m_avformat_context.get(), index, 0, 0, stream->duration,
0);
}
if (m_audio_stream_index.has_value()) {
const auto index = m_audio_stream_index.value();
const auto stream = m_avformat_context->streams[index];
avformat_seek_file(m_avformat_context.get(), index, 0, 0, stream->duration,
0);
}
continue;
} else {
LOG_INFO(Lib_AvPlayer, "EOF reached in demuxer. Exiting.");
break;
}
} else {
LOG_ERROR(Lib_AvPlayer, "Could not read AV frame: error = {}", res);
m_state.OnError();
return;
} }
AddPacket(std::move(up_packet));
continue;
}
if (res != AVERROR_EOF) [[unlikely]] {
LOG_ERROR(Lib_AvPlayer, "Could not read AV frame: error = {}", res);
m_state.OnError();
break; break;
} }
if (up_packet->stream_index == m_video_stream_index) {
m_video_packets.Push(std::move(up_packet)); if (!m_is_looping) {
m_video_packets_cv.Notify(); LOG_INFO(Lib_AvPlayer, "EOF reached in demuxer. Exiting.");
} else if (up_packet->stream_index == m_audio_stream_index) { break;
m_audio_packets.Push(std::move(up_packet)); }
m_audio_packets_cv.Notify();
is_loop = true;
LOG_INFO(Lib_AvPlayer, "Looping the source...");
avio_seek(m_avformat_context->pb, 0, SEEK_SET);
if (m_audio_stream_index.has_value()) {
const auto index = m_audio_stream_index.value();
av_seek_frame(m_avformat_context.get(), index, 0, 0);
} else if (m_video_stream_index.has_value()) {
const auto index = m_video_stream_index.value();
av_seek_frame(m_avformat_context.get(), index, 0, 0);
} }
} }
@ -493,6 +485,16 @@ void AvPlayerSource::DemuxerThread(std::stop_token stop) {
LOG_INFO(Lib_AvPlayer, "Demuxer Thread exited normally"); LOG_INFO(Lib_AvPlayer, "Demuxer Thread exited normally");
} }
void AvPlayerSource::AddPacket(AVPacketPtr up_packet) {
if (up_packet->stream_index == m_video_stream_index) {
m_video_packets.Push(std::move(up_packet));
m_video_packets_cv.Notify();
} else if (up_packet->stream_index == m_audio_stream_index) {
m_audio_packets.Push(std::move(up_packet));
m_audio_packets_cv.Notify();
}
}
AvPlayerSource::AVFramePtr AvPlayerSource::ConvertVideoFrame(const AVFrame& frame) { AvPlayerSource::AVFramePtr AvPlayerSource::ConvertVideoFrame(const AVFrame& frame) {
auto nv12_frame = AVFramePtr{av_frame_alloc(), &ReleaseAVFrame}; auto nv12_frame = AVFramePtr{av_frame_alloc(), &ReleaseAVFrame};
nv12_frame->pts = frame.pts; nv12_frame->pts = frame.pts;
@ -548,7 +550,7 @@ static void CopyNV12Data(u8* dst, const AVFrame& src, bool use_vdec2) {
} }
} }
Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame) { Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame, bool is_loop) {
ASSERT(frame.format == AV_PIX_FMT_NV12); ASSERT(frame.format == AV_PIX_FMT_NV12);
auto p_buffer = buffer.GetBuffer(); auto p_buffer = buffer.GetBuffer();
@ -572,7 +574,7 @@ Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame
.buffer = std::move(buffer), .buffer = std::move(buffer),
.info = .info =
{ {
.pData = p_buffer, .p_data = p_buffer,
.timestamp = timestamp, .timestamp = timestamp,
.details = .details =
{ {
@ -580,7 +582,7 @@ Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame
{ {
.width = width, .width = width,
.height = height, .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_left_offset = u32(frame.crop_left),
.crop_right_offset = u32(frame.crop_right + (width - frame.width)), .crop_right_offset = u32(frame.crop_right + (width - frame.width)),
.crop_top_offset = u32(frame.crop_top), .crop_top_offset = u32(frame.crop_top),
@ -592,6 +594,7 @@ Frame AvPlayerSource::PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame
}, },
}, },
}, },
.is_loop = is_loop,
}; };
} }
@ -610,6 +613,8 @@ void AvPlayerSource::VideoDecoderThread(std::stop_token stop) {
continue; continue;
} }
bool is_loop = (packet->get()->flags & AV_PKT_FLAG_LOOP) == AV_PKT_FLAG_LOOP;
packet->get()->flags &= ~AV_PKT_FLAG_LOOP; // Remove the fake flag
auto res = avcodec_send_packet(m_video_codec_context.get(), packet->get()); auto res = avcodec_send_packet(m_video_codec_context.get(), packet->get());
if (res < 0 && res != AVERROR(EAGAIN)) { if (res < 0 && res != AVERROR(EAGAIN)) {
m_state.OnError(); m_state.OnError();
@ -645,10 +650,13 @@ void AvPlayerSource::VideoDecoderThread(std::stop_token stop) {
} }
if (up_frame->format != AV_PIX_FMT_NV12) { if (up_frame->format != AV_PIX_FMT_NV12) {
const auto nv12_frame = ConvertVideoFrame(*up_frame); const auto nv12_frame = ConvertVideoFrame(*up_frame);
m_video_frames.Push(PrepareVideoFrame(std::move(buffer.value()), *nv12_frame)); m_video_frames.Push(
PrepareVideoFrame(std::move(buffer.value()), *nv12_frame, is_loop));
} else { } else {
m_video_frames.Push(PrepareVideoFrame(std::move(buffer.value()), *up_frame)); m_video_frames.Push(
PrepareVideoFrame(std::move(buffer.value()), *up_frame, is_loop));
} }
is_loop = false;
m_video_frames_cv.Notify(); m_video_frames_cv.Notify();
} }
} }
@ -683,7 +691,7 @@ AvPlayerSource::AVFramePtr AvPlayerSource::ConvertAudioFrame(const AVFrame& fram
return pcm16_frame; return pcm16_frame;
} }
Frame AvPlayerSource::PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame) { Frame AvPlayerSource::PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame, bool is_loop) {
ASSERT(frame.format == AV_SAMPLE_FMT_S16); ASSERT(frame.format == AV_SAMPLE_FMT_S16);
ASSERT(frame.nb_samples <= 1024); ASSERT(frame.nb_samples <= 1024);
@ -702,7 +710,7 @@ Frame AvPlayerSource::PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame
.buffer = std::move(buffer), .buffer = std::move(buffer),
.info = .info =
{ {
.pData = p_buffer, .p_data = p_buffer,
.timestamp = timestamp, .timestamp = timestamp,
.details = .details =
{ {
@ -714,6 +722,7 @@ Frame AvPlayerSource::PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame
}, },
}, },
}, },
.is_loop = is_loop,
}; };
} }
@ -731,6 +740,8 @@ void AvPlayerSource::AudioDecoderThread(std::stop_token stop) {
if (!packet.has_value()) { if (!packet.has_value()) {
continue; continue;
} }
bool is_loop = (packet->get()->flags & AV_PKT_FLAG_LOOP) == AV_PKT_FLAG_LOOP;
packet->get()->flags &= ~AV_PKT_FLAG_LOOP; // Remove the fake flag
auto res = avcodec_send_packet(m_audio_codec_context.get(), packet->get()); auto res = avcodec_send_packet(m_audio_codec_context.get(), packet->get());
if (res < 0 && res != AVERROR(EAGAIN)) { if (res < 0 && res != AVERROR(EAGAIN)) {
m_state.OnError(); m_state.OnError();
@ -767,10 +778,13 @@ void AvPlayerSource::AudioDecoderThread(std::stop_token stop) {
} }
if (up_frame->format != AV_SAMPLE_FMT_S16) { if (up_frame->format != AV_SAMPLE_FMT_S16) {
const auto pcm16_frame = ConvertAudioFrame(*up_frame); const auto pcm16_frame = ConvertAudioFrame(*up_frame);
m_audio_frames.Push(PrepareAudioFrame(std::move(buffer.value()), *pcm16_frame)); m_audio_frames.Push(
PrepareAudioFrame(std::move(buffer.value()), *pcm16_frame, is_loop));
} else { } else {
m_audio_frames.Push(PrepareAudioFrame(std::move(buffer.value()), *up_frame)); m_audio_frames.Push(
PrepareAudioFrame(std::move(buffer.value()), *up_frame, is_loop));
} }
is_loop = false;
m_audio_frames_cv.Notify(); m_audio_frames_cv.Notify();
} }
} }

42
src/core/libraries/avplayer/avplayer_source.h
View file

@ -30,14 +30,17 @@ class AvPlayerStateCallback {
public: public:
virtual ~AvPlayerStateCallback() = default; virtual ~AvPlayerStateCallback() = default;
virtual AvPlayerAvSyncMode GetSyncMode() = 0;
virtual void OnWarning(u32 id) = 0; virtual void OnWarning(u32 id) = 0;
virtual void OnError() = 0; virtual void OnError() = 0;
virtual void OnLoop() = 0;
virtual void OnEOF() = 0; virtual void OnEOF() = 0;
}; };
class FrameBuffer { class FrameBuffer {
public: 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_memory_replacement(memory_replacement),
m_data(Allocate(memory_replacement, align, size)) { m_data(Allocate(memory_replacement, align, size)) {
ASSERT_MSG(m_data, "Could not allocated frame buffer."); ASSERT_MSG(m_data, "Could not allocated frame buffer.");
@ -68,22 +71,23 @@ public:
} }
private: 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*>( return reinterpret_cast<u8*>(
memory_replacement.allocate(memory_replacement.object_ptr, align, size)); 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); memory_replacement.deallocate(memory_replacement.object_ptr, ptr);
} }
const SceAvPlayerMemAllocator& m_memory_replacement; const AvPlayerMemAllocator& m_memory_replacement;
u8* m_data = nullptr; u8* m_data = nullptr;
}; };
struct Frame { struct Frame {
FrameBuffer buffer; FrameBuffer buffer;
SceAvPlayerFrameInfoEx info; AvPlayerFrameInfoEx info;
bool is_loop = false;
}; };
class EventCV { class EventCV {
@ -121,18 +125,20 @@ public:
AvPlayerSource(AvPlayerStateCallback& state, bool use_vdec2); AvPlayerSource(AvPlayerStateCallback& state, bool use_vdec2);
~AvPlayerSource(); ~AvPlayerSource();
bool Init(const SceAvPlayerInitData& init_data, std::string_view path); bool Init(const AvPlayerInitData& init_data, std::string_view path);
bool FindStreamInfo(); bool FindStreamInfo();
s32 GetStreamCount(); s32 GetStreamCount();
bool GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info); bool GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info);
bool EnableStream(u32 stream_index); bool EnableStream(u32 stream_index);
void SetLooping(bool is_looping); void SetLooping(bool is_looping);
std::optional<bool> HasFrames(u32 num_frames); std::optional<bool> HasFrames(u32 num_frames);
bool Start(); bool Start();
bool Stop(); bool Stop();
bool GetAudioData(SceAvPlayerFrameInfo& audio_info); void Pause();
bool GetVideoData(SceAvPlayerFrameInfo& video_info); void Resume();
bool GetVideoData(SceAvPlayerFrameInfoEx& video_info); bool GetAudioData(AvPlayerFrameInfo& audio_info);
bool GetVideoData(AvPlayerFrameInfo& video_info);
bool GetVideoData(AvPlayerFrameInfoEx& video_info);
u64 CurrentTime(); u64 CurrentTime();
bool IsActive(); bool IsActive();
@ -156,20 +162,22 @@ private:
void AudioDecoderThread(std::stop_token stop); void AudioDecoderThread(std::stop_token stop);
bool HasRunningThreads() const; bool HasRunningThreads() const;
void AddPacket(AVPacketPtr up_packet);
AVFramePtr ConvertAudioFrame(const AVFrame& frame); AVFramePtr ConvertAudioFrame(const AVFrame& frame);
AVFramePtr ConvertVideoFrame(const AVFrame& frame); AVFramePtr ConvertVideoFrame(const AVFrame& frame);
Frame PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame); Frame PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame, bool is_loop);
Frame PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame); Frame PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame, bool is_loop);
AvPlayerStateCallback& m_state; AvPlayerStateCallback& m_state;
bool m_use_vdec2 = false; bool m_use_vdec2 = false;
SceAvPlayerMemAllocator m_memory_replacement{}; AvPlayerMemAllocator m_memory_replacement{};
u32 m_num_output_video_framebuffers{}; u32 m_num_output_video_framebuffers{};
std::atomic_bool m_is_looping = false; std::atomic_bool m_is_looping = false;
std::atomic_bool m_is_paused = false;
std::atomic_bool m_is_eof = false; std::atomic_bool m_is_eof = false;
std::unique_ptr<IDataStreamer> m_up_data_streamer; std::unique_ptr<IDataStreamer> m_up_data_streamer;
@ -183,8 +191,8 @@ private:
AvPlayerQueue<Frame> m_audio_frames; AvPlayerQueue<Frame> m_audio_frames;
AvPlayerQueue<Frame> m_video_frames; AvPlayerQueue<Frame> m_video_frames;
std::optional<FrameBuffer> m_current_video_frame; std::optional<Frame> m_current_video_frame;
std::optional<FrameBuffer> m_current_audio_frame; std::optional<Frame> m_current_audio_frame;
std::optional<s32> m_video_stream_index{}; std::optional<s32> m_video_stream_index{};
std::optional<s32> m_audio_stream_index{}; std::optional<s32> m_audio_stream_index{};
@ -197,8 +205,6 @@ private:
EventCV m_video_frames_cv{}; EventCV m_video_frames_cv{};
EventCV m_video_buffers_cv{}; EventCV m_video_buffers_cv{};
EventCV m_stop_cv{};
std::mutex m_state_mutex{}; std::mutex m_state_mutex{};
Kernel::Thread m_demuxer_thread{}; Kernel::Thread m_demuxer_thread{};
Kernel::Thread m_video_decoder_thread{}; Kernel::Thread m_video_decoder_thread{};
@ -211,6 +217,8 @@ private:
SWSContextPtr m_sws_context{nullptr, &ReleaseSWSContext}; SWSContextPtr m_sws_context{nullptr, &ReleaseSWSContext};
std::chrono::high_resolution_clock::time_point m_start_time{}; 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 } // namespace Libraries::AvPlayer

253
src/core/libraries/avplayer/avplayer_state.cpp
View file

@ -6,17 +6,18 @@
#include "core/libraries/avplayer/avplayer_error.h" #include "core/libraries/avplayer/avplayer_error.h"
#include "core/libraries/avplayer/avplayer_source.h" #include "core/libraries/avplayer/avplayer_source.h"
#include "core/libraries/avplayer/avplayer_state.h" #include "core/libraries/avplayer/avplayer_state.h"
#include "core/libraries/kernel/time.h"
#include "core/tls.h" #include "core/tls.h"
#include <magic_enum/magic_enum.hpp> #include <magic_enum/magic_enum.hpp>
namespace Libraries::AvPlayer { 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) { s32 source_id, void* event_data) {
auto const self = reinterpret_cast<AvPlayerState*>(opaque); auto const self = reinterpret_cast<AvPlayerState*>(opaque);
if (event_id == SceAvPlayerEvents::StateReady) { if (event_id == AvPlayerEvents::StateReady) {
s32 video_stream_index = -1; s32 video_stream_index = -1;
s32 audio_stream_index = -1; s32 audio_stream_index = -1;
s32 timedtext_stream_index = -1; s32 timedtext_stream_index = -1;
@ -30,7 +31,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer
return; return;
} }
for (u32 stream_index = 0; stream_index < stream_count; ++stream_index) { for (u32 stream_index = 0; stream_index < stream_count; ++stream_index) {
SceAvPlayerStreamInfo info{}; AvPlayerStreamInfo info{};
if (!self->GetStreamInfo(stream_index, info)) { if (!self->GetStreamInfo(stream_index, info)) {
self->Stop(); self->Stop();
return; return;
@ -38,7 +39,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer
const std::string_view default_language{self->m_default_language}; const std::string_view default_language{self->m_default_language};
switch (info.type) { switch (info.type) {
case SceAvPlayerStreamType::Video: case AvPlayerStreamType::Video:
if (video_stream_index == -1) { if (video_stream_index == -1) {
video_stream_index = stream_index; video_stream_index = stream_index;
} }
@ -47,7 +48,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer
video_stream_index = stream_index; video_stream_index = stream_index;
} }
break; break;
case SceAvPlayerStreamType::Audio: case AvPlayerStreamType::Audio:
if (audio_stream_index == -1) { if (audio_stream_index == -1) {
audio_stream_index = stream_index; audio_stream_index = stream_index;
} }
@ -56,7 +57,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer
audio_stream_index = stream_index; audio_stream_index = stream_index;
} }
break; break;
case SceAvPlayerStreamType::TimedText: case AvPlayerStreamType::TimedText:
if (default_language.empty()) { if (default_language.empty()) {
timedtext_stream_index = stream_index; timedtext_stream_index = stream_index;
break; break;
@ -86,7 +87,7 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer
DefaultEventCallback(opaque, event_id, 0, event_data); 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) { void* event_data) {
auto const self = reinterpret_cast<AvPlayerState*>(opaque); auto const self = reinterpret_cast<AvPlayerState*>(opaque);
const auto callback = self->m_event_replacement.event_callback; const auto callback = self->m_event_replacement.event_callback;
@ -97,7 +98,7 @@ void AvPlayerState::DefaultEventCallback(void* opaque, SceAvPlayerEvents event_i
} }
// Called inside GAME thread // 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) { : m_init_data(init_data), m_event_replacement(init_data.event_replacement) {
if (m_event_replacement.event_callback == nullptr || init_data.auto_start) { if (m_event_replacement.event_callback == nullptr || init_data.auto_start) {
m_auto_start = true; m_auto_start = true;
@ -122,12 +123,12 @@ AvPlayerState::~AvPlayerState() {
m_event_queue.Clear(); 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; m_post_init_data = post_init_data;
} }
// Called inside GAME thread // 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()) { if (path.empty()) {
LOG_ERROR(Lib_AvPlayer, "File path is empty."); LOG_ERROR(Lib_AvPlayer, "File path is empty.");
return false; return false;
@ -141,8 +142,8 @@ bool AvPlayerState::AddSource(std::string_view path, SceAvPlayerSourceType sourc
} }
m_up_source = std::make_unique<AvPlayerSource>( m_up_source = std::make_unique<AvPlayerSource>(
*this, m_post_init_data.video_decoder_init.decoderType.video_type == *this, m_post_init_data.video_decoder_init.decoder_type.video_type ==
SceAvPlayerVideoDecoderType::Software2); AvPlayerVideoDecoderType::Software2);
if (!m_up_source->Init(m_init_data, path)) { if (!m_up_source->Init(m_init_data, path)) {
SetState(AvState::Error); SetState(AvState::Error);
m_up_source.reset(); m_up_source.reset();
@ -154,17 +155,35 @@ bool AvPlayerState::AddSource(std::string_view path, SceAvPlayerSourceType sourc
} }
// Called inside GAME thread // Called inside GAME thread
s32 AvPlayerState::GetStreamCount() { u32 AvPlayerState::GetStreamCount() {
std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr) { if (m_up_source == nullptr) {
LOG_ERROR(Lib_AvPlayer, "Could not get stream count. No source."); return 0;
return -1;
} }
return m_up_source->GetStreamCount(); auto count = m_up_source->GetStreamCount();
if (!m_stream_infos.empty()) {
return count;
}
if (count > 0) {
m_stream_infos.reserve(count);
for (u32 i = 0; i < count; ++i) {
AvPlayerStreamInfo info;
if (!m_up_source->GetStreamInfo(i, info)) {
std::lock_guard guard(m_stream_infos_mutex);
m_stream_infos.clear();
return 0;
}
std::lock_guard guard(m_stream_infos_mutex);
m_stream_infos.emplace_back(info);
}
}
InitFilters();
return count;
} }
void AvPlayerState::InitFilters() {}
// Called inside GAME thread // 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); std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr) { if (m_up_source == nullptr) {
LOG_ERROR(Lib_AvPlayer, "Could not get stream {} info. No source.", stream_index); LOG_ERROR(Lib_AvPlayer, "Could not get stream {} info. No source.", stream_index);
@ -175,6 +194,12 @@ bool AvPlayerState::GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info)
// Called inside GAME thread // Called inside GAME thread
bool AvPlayerState::Start() { bool AvPlayerState::Start() {
if (m_current_state != AvState::Ready && m_current_state != AvState::Stop) {
if (!Stop()) {
return false;
}
}
SetState(AvState::Starting);
std::shared_lock lock(m_source_mutex); std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr || !m_up_source->Start()) { if (m_up_source == nullptr || !m_up_source->Start()) {
LOG_ERROR(Lib_AvPlayer, "Could not start playback."); LOG_ERROR(Lib_AvPlayer, "Could not start playback.");
@ -185,6 +210,64 @@ bool AvPlayerState::Start() {
return true; return true;
} }
// Called inside GAME thread
bool AvPlayerState::Pause() {
if (m_current_state == AvState::EndOfFile) {
return true;
}
if (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;
}
std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr) {
return false;
}
m_up_source->Pause();
SetState(AvState::Pause);
m_timer.Update();
OnPlaybackStateChanged(AvState::Pause);
return true;
}
// Called inside GAME thread
bool AvPlayerState::Resume() {
if (m_current_state == AvState::Initial || m_current_state == AvState::Stop ||
m_current_state == AvState::Ready || m_current_state == AvState::AddingSource ||
m_current_state == AvState::Error) {
return false;
}
while (m_current_state == AvState::Starting || m_current_state == AvState::Jump ||
m_current_state == AvState::TrickMode) {
std::this_thread::sleep_for(std::chrono::microseconds(90));
}
if (m_current_state == AvState::Buffering || m_current_state == AvState::Pause ||
m_current_state == AvState::C0x10) {
m_timer.UpdateVPts();
std::shared_lock lock(m_source_mutex);
m_up_source->Resume();
SetState(AvState::Play);
OnPlaybackStateChanged(AvState::Play);
return true;
}
if (m_current_state == AvState::PauseOnEOF) {
m_timer.UpdateVPts();
SetState(AvState::EndOfFile);
OnPlaybackStateChanged(AvState::EndOfFile);
return true;
}
if (m_current_state == AvState::Play || m_current_state == AvState::EndOfFile) {
return true;
}
return false;
}
void AvPlayerState::SetAvSyncMode(AvPlayerAvSyncMode sync_mode) {
m_sync_mode = sync_mode;
}
void AvPlayerState::AvControllerThread(std::stop_token stop) { void AvPlayerState::AvControllerThread(std::stop_token stop) {
using std::chrono::milliseconds; using std::chrono::milliseconds;
Common::SetCurrentThreadName("shadPS4:AvController"); Common::SetCurrentThreadName("shadPS4:AvController");
@ -233,21 +316,31 @@ bool AvPlayerState::EnableStream(u32 stream_index) {
// Called inside GAME thread // Called inside GAME thread
bool AvPlayerState::Stop() { bool AvPlayerState::Stop() {
std::shared_lock lock(m_source_mutex); if (m_current_state == AvState::Unknown || m_current_state == AvState::Stop) {
if (m_up_source == nullptr || m_current_state == AvState::Stop) {
return false; return false;
} }
if (!m_up_source->Stop()) { while (m_current_state == AvState::Jump || m_current_state == AvState::TrickMode) {
return false; std::this_thread::sleep_for(std::chrono::microseconds(90));
} }
if (!SetState(AvState::Stop)) { if (!SetState(AvState::Stop)) {
return false; return false;
} }
OnPlaybackStateChanged(AvState::Stop); EmitEvent(AvPlayerEvents::StateStop);
{
std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr || !m_up_source->Stop()) {
return false;
}
}
m_timer.Reset();
return true; return true;
} }
bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfo& video_info) { bool AvPlayerState::GetVideoData(AvPlayerFrameInfo& video_info) {
if (m_current_state == AvState::Play || m_current_state == AvState::EndOfFile ||
m_current_state == AvState::C0x10) {
return false;
}
std::shared_lock lock(m_source_mutex); std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr) { if (m_up_source == nullptr) {
return false; return false;
@ -255,7 +348,11 @@ bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfo& video_info) {
return m_up_source->GetVideoData(video_info); return m_up_source->GetVideoData(video_info);
} }
bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfoEx& video_info) { bool AvPlayerState::GetVideoData(AvPlayerFrameInfoEx& video_info) {
if (m_current_state == AvState::Play || m_current_state == AvState::EndOfFile ||
m_current_state == AvState::C0x10) {
return false;
}
std::shared_lock lock(m_source_mutex); std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr) { if (m_up_source == nullptr) {
return false; return false;
@ -263,7 +360,7 @@ bool AvPlayerState::GetVideoData(SceAvPlayerFrameInfoEx& video_info) {
return m_up_source->GetVideoData(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); std::shared_lock lock(m_source_mutex);
if (m_up_source == nullptr) { if (m_up_source == nullptr) {
return false; return false;
@ -305,11 +402,20 @@ void AvPlayerState::OnWarning(u32 id) {
WarningEvent(id); WarningEvent(id);
} }
AvPlayerAvSyncMode AvPlayerState::GetSyncMode() {
return m_sync_mode;
}
void AvPlayerState::OnError() { void AvPlayerState::OnError() {
SetState(AvState::Error); SetState(AvState::Error);
OnPlaybackStateChanged(AvState::Error); OnPlaybackStateChanged(AvState::Error);
} }
void AvPlayerState::OnLoop() {
auto id = ORBIS_AVPLAYER_ERROR_WAR_LOOPING_BACK;
EmitEvent(AvPlayerEvents::WarningId, &id);
}
void AvPlayerState::OnEOF() { void AvPlayerState::OnEOF() {
SetState(AvState::EndOfFile); SetState(AvState::EndOfFile);
} }
@ -318,23 +424,27 @@ void AvPlayerState::OnEOF() {
void AvPlayerState::OnPlaybackStateChanged(AvState state) { void AvPlayerState::OnPlaybackStateChanged(AvState state) {
switch (state) { switch (state) {
case AvState::Ready: { case AvState::Ready: {
EmitEvent(SceAvPlayerEvents::StateReady); EmitEvent(AvPlayerEvents::StateReady);
break; break;
} }
case AvState::Play: { case AvState::Play: {
EmitEvent(SceAvPlayerEvents::StatePlay); EmitEvent(AvPlayerEvents::StatePlay);
break; break;
} }
case AvState::Stop: { case AvState::Stop: {
EmitEvent(SceAvPlayerEvents::StateStop); EmitEvent(AvPlayerEvents::StateStop);
break; break;
} }
case AvState::Pause: { case AvState::Pause: {
EmitEvent(SceAvPlayerEvents::StatePause); EmitEvent(AvPlayerEvents::StatePause);
break; break;
} }
case AvState::Buffering: { case AvState::Buffering: {
EmitEvent(SceAvPlayerEvents::StateBuffering); EmitEvent(AvPlayerEvents::StateBuffering);
break;
}
case AvState::EndOfFile: {
EmitEvent(AvPlayerEvents::Initial);
break; break;
} }
default: default:
@ -366,7 +476,7 @@ std::optional<bool> AvPlayerState::OnBufferingCheckEvent(u32 num_frames) {
} }
// Called inside CONTROLLER thread // 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)); 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; const auto callback = m_init_data.event_replacement.event_callback;
if (callback) { if (callback) {
@ -389,7 +499,7 @@ void AvPlayerState::ProcessEvent() {
} }
switch (event->event) { switch (event->event) {
case AvEventType::WarningId: { case AvEventType::WarningId: {
OnWarning(event->payload.error); EmitEvent(AvPlayerEvents::WarningId, &event->payload.error);
break; break;
} }
case AvEventType::RevertState: { case AvEventType::RevertState: {
@ -427,6 +537,7 @@ void AvPlayerState::UpdateBufferingState() {
if (has_frames.value()) { if (has_frames.value()) {
const auto state = const auto state =
m_previous_state >= AvState::C0x0B ? m_previous_state.load() : AvState::Play; m_previous_state >= AvState::C0x0B ? m_previous_state.load() : AvState::Play;
m_timer.UpdateVPts();
SetState(state); SetState(state);
OnPlaybackStateChanged(state); OnPlaybackStateChanged(state);
} }
@ -448,7 +559,7 @@ bool AvPlayerState::IsStateTransitionValid(AvState state) {
switch (m_current_state.load()) { switch (m_current_state.load()) {
case AvState::Stop: case AvState::Stop:
case AvState::EndOfFile: case AvState::EndOfFile:
// case AvState::C0x08: case AvState::PauseOnEOF:
case AvState::Error: case AvState::Error:
return false; return false;
default: default:
@ -459,7 +570,7 @@ bool AvPlayerState::IsStateTransitionValid(AvState state) {
switch (m_current_state.load()) { switch (m_current_state.load()) {
case AvState::Stop: case AvState::Stop:
case AvState::EndOfFile: case AvState::EndOfFile:
// case AvState::C0x08: case AvState::PauseOnEOF:
case AvState::Starting: case AvState::Starting:
case AvState::Error: case AvState::Error:
return false; return false;
@ -471,7 +582,7 @@ bool AvPlayerState::IsStateTransitionValid(AvState state) {
switch (m_current_state.load()) { switch (m_current_state.load()) {
case AvState::Stop: case AvState::Stop:
case AvState::EndOfFile: case AvState::EndOfFile:
// case AvState::C0x08: case AvState::PauseOnEOF:
case AvState::TrickMode: case AvState::TrickMode:
case AvState::Starting: case AvState::Starting:
case AvState::Error: case AvState::Error:
@ -484,7 +595,7 @@ bool AvPlayerState::IsStateTransitionValid(AvState state) {
switch (m_current_state.load()) { switch (m_current_state.load()) {
case AvState::Stop: case AvState::Stop:
case AvState::EndOfFile: case AvState::EndOfFile:
// case AvState::C0x08: case AvState::PauseOnEOF:
case AvState::Jump: case AvState::Jump:
case AvState::Starting: case AvState::Starting:
case AvState::Error: case AvState::Error:
@ -498,7 +609,7 @@ bool AvPlayerState::IsStateTransitionValid(AvState state) {
case AvState::Stop: case AvState::Stop:
case AvState::EndOfFile: case AvState::EndOfFile:
case AvState::Pause: case AvState::Pause:
// case AvState::C0x08: case AvState::PauseOnEOF:
case AvState::Starting: case AvState::Starting:
case AvState::Error: case AvState::Error:
return false; return false;
@ -511,4 +622,70 @@ bool AvPlayerState::IsStateTransitionValid(AvState state) {
} }
} }
u64 AvPlayerTimer::Now() {
auto now = Kernel::sceKernelGetProcessTimeCounter();
const auto frequency = Kernel::sceKernelGetProcessTimeCounterFrequency();
if (frequency != 0) {
now = ((now % frequency) * 1'000'000) / frequency + (now / frequency) * 1'000'000;
}
return now / 100;
}
void AvPlayerTimer::Update() {
UpdateAPts(m_v_hint_pts);
}
void AvPlayerTimer::UpdateAPts(u64 timestamp) {
const auto now = Now();
m_last_update_pts = now;
m_a_pts = timestamp;
m_ts_diff = now - m_a_pts;
}
void AvPlayerTimer::UpdateVPts() {
const auto now = Now();
m_last_update_pts = now;
m_v_pts = now;
m_ts_diff = now - m_a_pts;
}
void AvPlayerTimer::UpdateVHintPts(u64 hint) {
const auto now = Now();
m_v_pts = now;
m_v_hint_pts = hint;
}
void AvPlayerTimer::Reset() {
m_ts_diff = -1;
m_v_pts = -1;
m_v_hint_pts = -1;
m_last_update_pts = 0;
m_a_pts = 0;
}
AvPlayerTimer::State AvPlayerTimer::GetState(AvPlayerAvSyncMode sync_mode) {
if (m_ts_diff == -1 || m_v_hint_pts == -1) {
return State::Error;
}
if (sync_mode == AvPlayerAvSyncMode::None) {
return State::Ok;
}
const s64 diff = (Now() - m_last_update_pts) + (m_a_pts - m_v_hint_pts);
if (diff > 2800) {
return State::VideoBehind;
}
if (diff < -6900) {
return State::VideoAhead;
}
if (diff < 200) {
return State::WaitForSync;
}
return State::Ok;
}
} // namespace Libraries::AvPlayer } // namespace Libraries::AvPlayer

66
src/core/libraries/avplayer/avplayer_state.h
View file

@ -16,45 +16,78 @@ namespace Libraries::AvPlayer {
class Stream; class Stream;
class AvDecoder; class AvDecoder;
class AvPlayerTimer {
public:
enum class State {
Ok,
WaitForSync,
VideoAhead,
VideoBehind,
Error,
};
void Update();
void UpdateAPts(u64 timestamp);
void UpdateVHintPts(u64 hint);
void UpdateVPts();
void Reset();
State GetState(AvPlayerAvSyncMode sync_mode);
private:
static u64 Now();
std::atomic<s64> m_ts_diff = -1;
std::atomic<s64> m_v_pts = -1;
std::atomic<s64> m_v_hint_pts = -1;
std::atomic<u64> m_last_update_pts = 0;
std::atomic<u64> m_a_pts = 0;
};
class AvPlayerState : public AvPlayerStateCallback { class AvPlayerState : public AvPlayerStateCallback {
public: public:
AvPlayerState(const SceAvPlayerInitData& init_data); AvPlayerState(const AvPlayerInitData& init_data);
~AvPlayerState(); ~AvPlayerState();
void PostInit(const SceAvPlayerPostInitData& post_init_data); void PostInit(const AvPlayerPostInitData& post_init_data);
bool AddSource(std::string_view filename, SceAvPlayerSourceType source_type); bool AddSource(std::string_view filename, AvPlayerSourceType source_type);
s32 GetStreamCount(); u32 GetStreamCount();
bool GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info); bool GetStreamInfo(u32 stream_index, AvPlayerStreamInfo& info);
bool EnableStream(u32 stream_index); bool EnableStream(u32 stream_index);
bool Start(); bool Start();
bool Stop(); bool Stop();
bool GetAudioData(SceAvPlayerFrameInfo& audio_info); bool Pause();
bool GetVideoData(SceAvPlayerFrameInfo& video_info); bool Resume();
bool GetVideoData(SceAvPlayerFrameInfoEx& video_info); void SetAvSyncMode(AvPlayerAvSyncMode sync_mode);
bool GetAudioData(AvPlayerFrameInfo& audio_info);
bool GetVideoData(AvPlayerFrameInfo& video_info);
bool GetVideoData(AvPlayerFrameInfoEx& video_info);
bool IsActive(); bool IsActive();
u64 CurrentTime(); u64 CurrentTime();
bool SetLooping(bool is_looping); bool SetLooping(bool is_looping);
private: private:
// Event Replacement // 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); 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); s32 source_id, void* event_data);
AvPlayerAvSyncMode GetSyncMode() override;
void OnWarning(u32 id) override; void OnWarning(u32 id) override;
void OnError() override; void OnError() override;
void OnLoop() override;
void OnEOF() override; void OnEOF() override;
void OnPlaybackStateChanged(AvState state); void OnPlaybackStateChanged(AvState state);
std::optional<bool> OnBufferingCheckEvent(u32 num_frames); 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); bool SetState(AvState state);
void AvControllerThread(std::stop_token stop); void AvControllerThread(std::stop_token stop);
void InitFilters();
void AddSourceEvent(); void AddSourceEvent();
void WarningEvent(s32 id); void WarningEvent(s32 id);
@ -65,14 +98,16 @@ private:
std::unique_ptr<AvPlayerSource> m_up_source; std::unique_ptr<AvPlayerSource> m_up_source;
SceAvPlayerInitData m_init_data{}; AvPlayerInitData m_init_data{};
SceAvPlayerPostInitData m_post_init_data{}; AvPlayerPostInitData m_post_init_data{};
SceAvPlayerEventReplacement m_event_replacement{}; AvPlayerEventReplacement m_event_replacement{};
bool m_auto_start{}; bool m_auto_start{};
char m_default_language[4]{}; char m_default_language[4]{};
AvPlayerAvSyncMode m_sync_mode = AvPlayerAvSyncMode::Default;
std::atomic<AvState> m_current_state; std::atomic<AvState> m_current_state;
std::atomic<AvState> m_previous_state; std::atomic<AvState> m_previous_state;
AvPlayerTimer m_timer;
u32 m_thread_priority; u32 m_thread_priority;
u32 m_thread_affinity; u32 m_thread_affinity;
std::atomic_uint32_t m_some_event_result{}; std::atomic_uint32_t m_some_event_result{};
@ -82,6 +117,9 @@ private:
std::mutex m_event_handler_mutex{}; std::mutex m_event_handler_mutex{};
Kernel::Thread m_controller_thread{}; Kernel::Thread m_controller_thread{};
AvPlayerQueue<AvPlayerEvent> m_event_queue{}; AvPlayerQueue<AvPlayerEvent> m_event_queue{};
std::mutex m_stream_infos_mutex;
std::vector<AvPlayerStreamInfo> m_stream_infos;
}; };
} // namespace Libraries::AvPlayer } // namespace Libraries::AvPlayer

7
src/core/libraries/kernel/time.cpp
View file

@ -28,6 +28,7 @@
namespace Libraries::Kernel { namespace Libraries::Kernel {
static u64 initial_ptc; static u64 initial_ptc;
static u64 initial_unbiased_ptc;
static std::unique_ptr<Common::NativeClock> clock; static std::unique_ptr<Common::NativeClock> clock;
u64 PS4_SYSV_ABI sceKernelGetTscFrequency() { u64 PS4_SYSV_ABI sceKernelGetTscFrequency() {
@ -35,12 +36,11 @@ u64 PS4_SYSV_ABI sceKernelGetTscFrequency() {
} }
u64 PS4_SYSV_ABI sceKernelGetProcessTime() { u64 PS4_SYSV_ABI sceKernelGetProcessTime() {
// TODO: this timer should support suspends, so initial ptc needs to be updated on wake up return clock->GetTimeUS(clock->GetUnbiasedUptime() - initial_unbiased_ptc);
return clock->GetTimeUS(initial_ptc);
} }
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter() { u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter() {
return clock->GetUptime() - initial_ptc; return clock->GetUnbiasedUptime() - initial_unbiased_ptc;
} }
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency() { u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency() {
@ -511,6 +511,7 @@ s32 PS4_SYSV_ABI sceKernelConvertUtcToLocaltime(time_t time, time_t* local_time,
void RegisterTime(Core::Loader::SymbolsResolver* sym) { void RegisterTime(Core::Loader::SymbolsResolver* sym) {
clock = std::make_unique<Common::NativeClock>(); clock = std::make_unique<Common::NativeClock>();
initial_ptc = clock->GetUptime(); initial_ptc = clock->GetUptime();
initial_unbiased_ptc = clock->GetUnbiasedUptime();
// POSIX // POSIX
LIB_FUNCTION("yS8U2TGCe1A", "libkernel", 1, "libkernel", 1, 1, posix_nanosleep); LIB_FUNCTION("yS8U2TGCe1A", "libkernel", 1, "libkernel", 1, 1, posix_nanosleep);