shifathosn
/
KytyPS5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
KytyPS5/src/libs/avPlayer.cpp

2079 lines
69 KiB
C++
Raw Blame History

#include "common/common.h"
#include "common/file.h"
#include "common/logging/log.h"
#include "kernel/fileSystem.h"
#include "kernel/pthread.h"
#include "libs/audio.h"
#include "libs/libs.h"
#include <algorithm>
#include <atomic>
#include <cctype>
#include <cerrno>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <limits>
#include <magic_enum.hpp>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include <libavutil/avutil.h>
#include <libavutil/channel_layout.h>
#include <libavutil/pixfmt.h>
#include <libswresample/swresample.h>
#include <libswscale/swscale.h>
}
namespace Libs::Audio::AvPlayer {
LIB_NAME("AvPlayer", "AvPlayer");
using AvPlayerAllocate = KYTY_SYSV_ABI void* (*)(void*, uint32_t, uint32_t);
using AvPlayerDeallocate = KYTY_SYSV_ABI void (*)(void*, void*);
using AvPlayerAllocateTexture = KYTY_SYSV_ABI void* (*)(void*, uint32_t, uint32_t);
using AvPlayerDeallocateTexture = KYTY_SYSV_ABI void (*)(void*, void*);
using AvPlayerOpenFile = KYTY_SYSV_ABI int (*)(void*, const char*);
using AvPlayerCloseFile = KYTY_SYSV_ABI int (*)(void*);
using AvPlayerReadOffsetFile = KYTY_SYSV_ABI int (*)(void*, uint8_t*, uint64_t, uint32_t);
using AvPlayerSizeFile = KYTY_SYSV_ABI uint64_t (*)(void*);
using AvPlayerEventCallback = KYTY_SYSV_ABI void (*)(void*, int32_t, int32_t, void*);
using Bool = uint8_t;
constexpr int32_t AVPLAYER_EVENT_STATE_STOP = 0x01;
constexpr int32_t AVPLAYER_EVENT_STATE_READY = 0x02;
constexpr int32_t AVPLAYER_EVENT_STATE_PLAY = 0x03;
constexpr int32_t AVPLAYER_EVENT_STATE_PAUSE = 0x04;
constexpr int32_t AVPLAYER_EVENT_WARNING_ID = 0x20;
constexpr int32_t AVPLAYER_ERROR_INVALID_PARAMS = -2140536831;
constexpr int32_t AVPLAYER_ERROR_OPERATION_FAILED = -2140536830;
constexpr int32_t AVPLAYER_ERROR_NO_MEMORY = -2140536829;
constexpr int32_t AVPLAYER_ERROR_NOT_SUPPORTED = -2140536828;
constexpr int32_t AVPLAYER_WARNING_LOOPING_BACK = -2140536671;
constexpr int32_t AVPLAYER_WARNING_JUMP_COMPLETE = -2140536669;
constexpr int32_t AVPLAYER_TRICK_SPEED_NORMAL = 100;
constexpr int32_t AVPLAYER_TRICK_SPEED_MIN = 400;
constexpr int32_t AVPLAYER_TRICK_SPEED_MAX = 3200;
constexpr uint32_t AVPLAYER_DEMUX_BUFFER_DEFAULT = 4 * 1024 * 1024;
constexpr uint32_t AVPLAYER_DEMUX_BUFFER_MIN = 128 * 1024;
constexpr uint32_t AVPLAYER_DEMUX_BUFFER_MAX = 32 * 1024 * 1024;
constexpr int AVPLAYER_AUDIO_BUFFERS = 8;
enum AvPlayerUriType : uint32_t { AvPlayerUriTypeSource = 0 };
enum AvPlayerSourceType : uint32_t {
AvPlayerSourceUnknown = 0,
AvPlayerSourceFileMp4 = 1,
AvPlayerSourceFileWebm = 2,
AvPlayerSourceHls = 8
};
enum AvPlayerDebuglevels : int {
AvplayerDbgNone,
AvplayerDbgInfo,
AvplayerDbgWarnings,
AvplayerDbgAll
};
enum AvPlayerStreamType : uint32_t {
AvPlayerStreamUnknown = 0,
AvPlayerStreamVideo = 1,
AvPlayerStreamAudio = 2,
AvPlayerStreamTimedText = 3
};
enum AvPlayerVideoDecoderType : uint32_t {
AvPlayerVideoDecoderDefault = 0,
AvPlayerVideoDecoderSoftware2 = 1
};
enum AvPlayerAudioDecoderType : uint32_t { AvPlayerAudioDecoderDefault = 0 };
enum AvPlayerAudioChannelOrder : uint32_t {
AvPlayerAudioChannelOrderDefault = 0,
AvPlayerAudioChannelOrderExt = 1,
AvPlayerAudioChannelOrderLsRs = 2
};
struct AvPlayerMemAllocator {
void* object_pointer = nullptr;
AvPlayerAllocate allocate = nullptr;
AvPlayerDeallocate deallocate = nullptr;
AvPlayerAllocateTexture allocate_texture = nullptr;
AvPlayerDeallocateTexture deallocate_texture = nullptr;
};
struct AvPlayerFileReplacement {
void* object_pointer = nullptr;
AvPlayerOpenFile open = nullptr;
AvPlayerCloseFile close = nullptr;
AvPlayerReadOffsetFile read_offset = nullptr;
AvPlayerSizeFile size = nullptr;
};
struct AvPlayerEventReplacement {
void* object_pointer = nullptr;
AvPlayerEventCallback event_callback = nullptr;
};
static void emit_event(AvPlayerEventReplacement event, int32_t id, void* data = nullptr) {
if (event.event_callback != nullptr) {
LOGF("\t event_id = %d\n", id);
event.event_callback(event.object_pointer, id, 0, data);
}
}
struct AvPlayerUri {
const char* name = nullptr;
uint32_t length = 0;
};
struct AvPlayerSourceDetails {
AvPlayerUri uri;
uint8_t reserved1[64] = {};
AvPlayerSourceType source_type = AvPlayerSourceUnknown;
uint8_t reserved2[44] = {};
};
struct AvPlayerInitData {
AvPlayerMemAllocator memory_replacement;
AvPlayerFileReplacement file_replacement;
AvPlayerEventReplacement event_replacement;
AvPlayerDebuglevels debug_level = AvplayerDbgNone;
uint32_t base_priority = 0;
int32_t num_output_video_framebuffers = 0;
Bool auto_start = 0;
uint8_t reserved[3] = {};
const char* default_language = nullptr;
};
struct AvPlayerThreadInfo {
uint32_t priority = 0;
uint32_t stack_size = 0;
uint64_t affinity = 0;
uint8_t reserved[32] = {};
};
struct AvPlayerInitDataEx {
size_t this_size = 0;
AvPlayerMemAllocator memory_replacement;
AvPlayerFileReplacement file_replacement;
AvPlayerEventReplacement event_replacement;
const char* default_language = nullptr;
AvPlayerDebuglevels debug_level = AvplayerDbgNone;
Bool auto_start = 0;
uint8_t reserved[3] = {};
AvPlayerThreadInfo audio_decoder;
AvPlayerThreadInfo video_decoder;
AvPlayerThreadInfo demuxer;
AvPlayerThreadInfo event;
AvPlayerThreadInfo call_queue;
AvPlayerThreadInfo http_command_processor;
AvPlayerThreadInfo http_segment_manager;
AvPlayerThreadInfo http_streamlist;
AvPlayerThreadInfo file_streaming;
int32_t num_output_video_framebuffers = 0;
uint8_t reserved2[4] = {};
};
struct AvPlayerDecoderInit {
union {
AvPlayerVideoDecoderType video_type;
AvPlayerAudioDecoderType audio_type;
uint8_t reserved[4];
} decoder_type {};
uint8_t reserved[4] = {};
union {
struct {
uint64_t cpu_affinity_mask;
int32_t cpu_thread_priority;
uint8_t decode_input_queue_depth;
uint8_t compute_pipe_id;
uint8_t compute_queue_id;
uint8_t reserved[17];
} video_sw2;
struct {
AvPlayerAudioChannelOrder audio_channel_order;
uint8_t reserved[28];
} audio;
uint8_t reserved[32];
} decoder_params {};
};
struct AvPlayerHttpContext {
uint32_t http_context_id = 0;
uint32_t ssl_context_id = 0;
};
struct AvPlayerPostInitData {
uint32_t demux_video_buffer_size = 0;
uint8_t reserved[4] = {};
AvPlayerDecoderInit video_decoder_init;
AvPlayerDecoderInit audio_decoder_init;
AvPlayerHttpContext http_context;
uint8_t reserved2[56] = {};
};
struct AvPlayerStartInfoEx {
size_t this_size = 0;
uint64_t start_time_milliseconds = 0;
};
struct AvPlayerAudioEx {
uint16_t channel_count = 0;
uint8_t reserved[2] = {};
uint32_t sample_rate = 0;
uint32_t size = 0;
uint8_t language_code[4] = {};
uint8_t reserved1[64] = {};
};
struct AvPlayerAudio {
uint16_t channel_count = 0;
uint8_t reserved[2] = {};
uint32_t sample_rate = 0;
uint32_t size = 0;
uint8_t language_code[4] = {};
};
struct AvPlayerVideoEx {
uint32_t width = 0;
uint32_t height = 0;
float aspect_ratio = 0.0f;
uint8_t language_code[4] = {};
uint8_t reserved[4] = {};
uint32_t crop_left_offset = 0;
uint32_t crop_right_offset = 0;
uint32_t crop_top_offset = 0;
uint32_t crop_bottom_offset = 0;
uint32_t pitch = 0;
uint8_t luma_bit_depth = 0;
uint8_t chroma_bit_depth = 0;
Bool video_full_range_flag = 0;
uint8_t reserved2[5] = {};
double framerate = 0.0;
uint32_t colour_primaries = 0;
uint32_t transfer_characteristics = 0;
uint8_t reserved3[16] = {};
};
struct AvPlayerVideo {
uint32_t width = 0;
uint32_t height = 0;
float aspect_ratio = 0.0f;
uint8_t language_code[4] = {};
};
struct AvPlayerTextPosition {
int16_t top = 0;
int16_t left = 0;
int16_t bottom = 0;
int16_t right = 0;
};
struct AvPlayerTimedTextEx {
uint8_t language_code[4] = {};
uint16_t text_size = 0;
uint16_t font_size = 0;
AvPlayerTextPosition position;
uint8_t reserved1[64] = {};
};
struct AvPlayerTimedText {
uint8_t language_code[4] = {};
uint16_t text_size = 0;
uint16_t font_size = 0;
AvPlayerTextPosition position;
};
union AvPlayerStreamDetailsEx {
AvPlayerAudioEx audio;
AvPlayerVideoEx video;
AvPlayerTimedTextEx subs;
uint8_t reserved1[80];
};
union AvPlayerStreamDetails {
AvPlayerAudio audio;
AvPlayerVideo video;
AvPlayerTimedText subs;
uint8_t reserved[16];
};
struct AvPlayerFrameInfo {
void* data = nullptr;
uint8_t reserved[4] = {};
uint64_t time_stamp = 0;
AvPlayerStreamDetails details {};
};
struct AvPlayerFrameInfoEx {
void* data = nullptr;
uint8_t reserved[4] = {};
uint64_t time_stamp = 0;
AvPlayerStreamDetailsEx details {};
};
struct AvPlayerStreamInfo {
AvPlayerStreamType type = AvPlayerStreamUnknown;
uint8_t reserved[4] = {};
AvPlayerStreamDetails details {};
uint64_t duration = 0;
};
struct AvPlayerStreamInfoEx {
size_t this_size = 0;
AvPlayerStreamType type = AvPlayerStreamUnknown;
uint8_t reserved[4] = {};
AvPlayerStreamDetailsEx details {};
uint64_t duration = 0;
};
static_assert(offsetof(AvPlayerPostInitData, video_decoder_init) == 8);
static_assert(offsetof(AvPlayerVideoEx, framerate) == 48);
static_assert(sizeof(AvPlayerStreamDetailsEx) == 80);
static_assert(offsetof(AvPlayerStreamInfoEx, duration) == 96);
static_assert(offsetof(AvPlayerFrameInfoEx, details) == 24);
static std::string fferr(int e) {
char buf[AV_ERROR_MAX_STRING_SIZE] = {};
av_make_error_string(buf, sizeof(buf), e);
return buf;
}
static uint64_t to_ms(int64_t v, AVRational tb) {
return v == AV_NOPTS_VALUE ? 0
: static_cast<uint64_t>(std::max<int64_t>(
0, av_rescale_q(v, tb, AVRational {1, 1000})));
}
static uint32_t align_up(uint32_t v, uint32_t a) {
return a == 0 ? v : ((v + a - 1) / a) * a;
}
static bool ieq(std::string_view a, std::string_view b) {
return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin(), [](char l, char r) {
return std::tolower(static_cast<unsigned char>(l)) ==
std::tolower(static_cast<unsigned char>(r));
});
}
static void lang(uint8_t out[4], AVDictionary* md) {
std::memset(out, 0, 4);
if (auto* e = av_dict_get(md, "language", nullptr, 0); e != nullptr && e->value != nullptr) {
std::memcpy(out, e->value, std::min<size_t>(3, std::strlen(e->value)));
} else {
out[0] = 'u';
out[1] = 'n';
out[2] = 'd';
}
}
static AvPlayerSourceType source_type_from_path(std::string_view path) {
if (auto q = path.find_first_of("?#"); q != std::string_view::npos) {
path = path.substr(0, q);
}
auto dot = path.rfind('.');
if (dot == std::string_view::npos) {
return AvPlayerSourceUnknown;
}
auto ext = path.substr(dot);
if (auto slash = ext.find('/'); slash != std::string_view::npos) {
ext = ext.substr(0, slash);
}
if (ieq(ext, ".mp4") || ieq(ext, ".m4v") || ieq(ext, ".m4a") || ieq(ext, ".mov") ||
ieq(ext, ".m3d")) {
return AvPlayerSourceFileMp4;
}
if (ieq(ext, ".webm")) {
return AvPlayerSourceFileWebm;
}
if (ieq(ext, ".m3u8")) {
return AvPlayerSourceHls;
}
return AvPlayerSourceUnknown;
}
static bool source_type_is_file(AvPlayerSourceType type) {
return type == AvPlayerSourceUnknown || type == AvPlayerSourceFileMp4 ||
type == AvPlayerSourceFileWebm;
}
static bool codec_is_supported_for_source(AvPlayerSourceType source_type, AVMediaType media_type,
AVCodecID codec_id) {
if (source_type != AvPlayerSourceFileWebm) {
return true;
}
switch (media_type) {
case AVMEDIA_TYPE_VIDEO:
return codec_id == AV_CODEC_ID_VP8 || codec_id == AV_CODEC_ID_VP9 ||
codec_id == AV_CODEC_ID_AV1;
case AVMEDIA_TYPE_AUDIO:
return codec_id == AV_CODEC_ID_OPUS || codec_id == AV_CODEC_ID_VORBIS;
default: return true;
}
}
static const AVCodec* find_decoder(AVCodecID codec_id) {
const auto* decoder = avcodec_find_decoder(codec_id);
if (decoder == nullptr && codec_id == AV_CODEC_ID_VP9) {
Log::WriteToConsoleAndLog(
"WARNING: AvPlayer: The game requested VP9 video, but FFmpeg has no VP9 "
"decoder. Use FFmpeg with VP9 decoding enabled.\n");
}
return decoder;
}
struct PacketDeleter {
void operator()(AVPacket* packet) const { av_packet_free(&packet); }
};
using Packet = std::unique_ptr<AVPacket, PacketDeleter>;
struct DemuxPacket {
Packet packet;
uint64_t timestamp_offset = 0;
};
class PacketQueue {
public:
explicit PacketQueue(size_t byte_capacity): capacity(byte_capacity) {}
bool Push(DemuxPacket value, const std::atomic_bool& stop) {
const auto size =
value.packet == nullptr ? 0u : static_cast<size_t>(std::max(value.packet->size, 0));
std::unique_lock lock(mutex);
available.wait(lock, [&] {
return stop || bytes + size <= capacity || (queue.empty() && bytes == 0);
});
if (stop) {
return false;
}
bytes += size;
queue.push_back(std::move(value));
available.notify_all();
return true;
}
std::optional<DemuxPacket> WaitPop(const std::atomic_bool& stop,
const std::atomic_bool& finished) {
std::unique_lock lock(mutex);
available.wait(lock, [&] { return stop || finished || !queue.empty(); });
if (stop || queue.empty()) {
return std::nullopt;
}
auto value = std::move(queue.front());
queue.pop_front();
if (value.packet != nullptr) {
bytes -= static_cast<size_t>(std::max(value.packet->size, 0));
}
available.notify_all();
return value;
}
void Clear() {
std::lock_guard lock(mutex);
queue.clear();
bytes = 0;
available.notify_all();
}
void Notify() { available.notify_all(); }
private:
std::mutex mutex;
std::condition_variable available;
std::deque<DemuxPacket> queue;
size_t bytes = 0;
size_t capacity = 0;
};
class GuestBuffer {
public:
GuestBuffer() = default;
GuestBuffer(AvPlayerMemAllocator mem, uint32_t align, uint32_t size, bool texture)
: m_mem(mem), m_size(size), m_texture(texture) {
m_data =
static_cast<uint8_t*>(texture ? mem.allocate_texture(mem.object_pointer, align, size)
: mem.allocate(mem.object_pointer, align, size));
}
~GuestBuffer() { Reset(); }
GuestBuffer(const GuestBuffer&) = delete;
GuestBuffer& operator=(const GuestBuffer&) = delete;
GuestBuffer(GuestBuffer&& r) noexcept { Move(r); }
GuestBuffer& operator=(GuestBuffer&& r) noexcept {
if (this != &r) {
Reset();
Move(r);
}
return *this;
}
uint8_t* Get() const { return m_data; }
bool Valid() const { return m_data != nullptr; }
uint32_t Size() const { return m_size; }
private:
void Move(GuestBuffer& r) {
m_mem = r.m_mem;
m_data = r.m_data;
m_size = r.m_size;
m_texture = r.m_texture;
r.m_data = nullptr;
r.m_size = 0;
}
void Reset() {
if (m_data != nullptr) {
if (m_texture) {
m_mem.deallocate_texture(m_mem.object_pointer, m_data);
} else {
m_mem.deallocate(m_mem.object_pointer, m_data);
}
m_data = nullptr;
}
}
AvPlayerMemAllocator m_mem {};
uint8_t* m_data = nullptr;
uint32_t m_size = 0;
bool m_texture = false;
};
template <typename T>
class WorkQueue {
public:
void Push(T value) {
std::lock_guard lock(mutex);
queue.push_back(std::move(value));
available.notify_all();
}
std::optional<T> TryPop() {
std::lock_guard lock(mutex);
if (queue.empty()) {
return std::nullopt;
}
auto value = std::move(queue.front());
queue.pop_front();
available.notify_all();
return value;
}
template <typename Predicate>
std::optional<T> TryPopIf(Predicate&& predicate) {
std::lock_guard lock(mutex);
if (queue.empty() || !std::forward<Predicate>(predicate)(queue.front())) {
return std::nullopt;
}
auto value = std::move(queue.front());
queue.pop_front();
available.notify_all();
return value;
}
std::optional<T> WaitPop(const std::atomic_bool& stop) {
std::unique_lock lock(mutex);
available.wait(lock, [&] { return stop || !queue.empty(); });
if (stop || queue.empty()) {
return std::nullopt;
}
auto value = std::move(queue.front());
queue.pop_front();
available.notify_all();
return value;
}
bool Empty() const {
std::lock_guard lock(mutex);
return queue.empty();
}
void Clear() {
std::lock_guard lock(mutex);
queue.clear();
available.notify_all();
}
void Notify() { available.notify_all(); }
private:
mutable std::mutex mutex;
std::condition_variable available;
std::deque<T> queue;
};
struct ReadyFrame {
std::unique_ptr<GuestBuffer> buffer;
AvPlayerFrameInfoEx info {};
uint64_t timestamp_offset = 0;
};
class FileStreamer {
public:
explicit FileStreamer(AvPlayerFileReplacement f): file(f) {}
~FileStreamer() {
if (ctx != nullptr) {
av_freep(&ctx->buffer);
avio_context_free(&ctx);
}
if (opened) {
file.close(file.object_pointer);
}
}
bool Init(const std::string& path) {
if (file.open != nullptr) {
if (file.close == nullptr || file.read_offset == nullptr || file.size == nullptr ||
file.open(file.object_pointer, path.c_str()) < 0) {
return false;
}
opened = true;
size = file.size(file.object_pointer);
} else {
if (!local_file.Open(LibKernel::FileSystem::GetRealFilename(path),
Common::File::Mode::Read)) {
return false;
}
size = local_file.Size();
}
if (size == 0 || size > static_cast<uint64_t>(std::numeric_limits<int64_t>::max())) {
return false;
}
constexpr int buffer_size = 64 * 1024;
auto* buf = static_cast<uint8_t*>(av_malloc(buffer_size));
if (buf == nullptr) {
return false;
}
ctx = avio_alloc_context(buf, buffer_size, 0, this, Read, nullptr, Seek);
if (ctx == nullptr) {
av_free(buf);
}
return ctx != nullptr;
}
AVIOContext* Context() const { return ctx; }
private:
static int Read(void* opaque, uint8_t* buf, int len) {
auto* s = static_cast<FileStreamer*>(opaque);
if (s->pos >= s->size) {
return AVERROR_EOF;
}
len = static_cast<int>(std::min<uint64_t>(len, s->size - s->pos));
int read = 0;
if (s->opened) {
read = s->file.read_offset(s->file.object_pointer, buf, s->pos,
static_cast<uint32_t>(len));
} else {
uint32_t bytes = 0;
s->local_file.Read(buf, static_cast<uint32_t>(len), &bytes);
read = static_cast<int>(bytes);
}
if (read <= 0 || read > len) {
return read < 0 ? read : AVERROR(EIO);
}
s->pos += static_cast<uint64_t>(read);
return read;
}
static int64_t Seek(void* opaque, int64_t offset, int whence) {
auto* s = static_cast<FileStreamer*>(opaque);
if ((whence & AVSEEK_SIZE) != 0) {
return static_cast<int64_t>(s->size);
}
whence &= ~AVSEEK_FORCE;
uint64_t base = 0;
switch (whence) {
case SEEK_SET: break;
case SEEK_CUR: base = s->pos; break;
case SEEK_END: base = s->size; break;
default: return AVERROR(EINVAL);
}
const auto distance = offset < 0 ? uint64_t {0} - static_cast<uint64_t>(offset)
: static_cast<uint64_t>(offset);
if ((offset < 0 && distance > base) ||
(offset >= 0 && distance > std::numeric_limits<int64_t>::max() - base)) {
return AVERROR(EINVAL);
}
const auto position = offset < 0 ? base - distance : base + distance;
if (!s->opened && !s->local_file.Seek(position)) {
return AVERROR(EIO);
}
s->pos = position;
return static_cast<int64_t>(position);
}
AvPlayerFileReplacement file;
Common::File local_file;
bool opened = false;
uint64_t pos = 0;
uint64_t size = 0;
AVIOContext* ctx = nullptr;
};
class Source {
public:
Source(AvPlayerMemAllocator m, AvPlayerFileReplacement f, AvPlayerEventReplacement e,
int32_t video_buffers, bool vdec2, uint32_t demux_buffer_size)
: mem(m), file(f), event(e),
max_video_buffers(std::clamp(video_buffers <= 0 ? 2 : video_buffers, 2, 16)),
use_vdec2(vdec2),
video_packets(
std::clamp(demux_buffer_size == 0 ? AVPLAYER_DEMUX_BUFFER_DEFAULT : demux_buffer_size,
AVPLAYER_DEMUX_BUFFER_MIN, AVPLAYER_DEMUX_BUFFER_MAX)),
audio_packets(
std::clamp(demux_buffer_size == 0 ? AVPLAYER_DEMUX_BUFFER_DEFAULT : demux_buffer_size,
AVPLAYER_DEMUX_BUFFER_MIN, AVPLAYER_DEMUX_BUFFER_MAX)) {}
~Source() { Close(); }
int Init(const std::string& p, AvPlayerSourceType requested) {
path = p;
source_type = requested == AvPlayerSourceUnknown ? source_type_from_path(path) : requested;
if (source_type == AvPlayerSourceHls) {
return AVPLAYER_ERROR_NOT_SUPPORTED;
}
if (!source_type_is_file(source_type)) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
auto* raw = avformat_alloc_context();
if (raw == nullptr) {
return AVPLAYER_ERROR_NO_MEMORY;
}
raw->interrupt_callback.callback = [](void* opaque) {
return static_cast<Source*>(opaque)->interrupt_io.load() ? 1 : 0;
};
raw->interrupt_callback.opaque = this;
streamer = std::make_unique<FileStreamer>(file);
if (!streamer->Init(path)) {
avformat_free_context(raw);
return AVPLAYER_ERROR_OPERATION_FAILED;
}
raw->pb = streamer->Context();
if (const auto rc = avformat_open_input(&raw, file.open == nullptr ? path.c_str() : nullptr,
nullptr, nullptr);
rc < 0) {
LOGF("\t avformat_open_input failed: %s path=%s\n", fferr(rc).c_str(), path.c_str());
return AVPLAYER_ERROR_OPERATION_FAILED;
}
fmt = raw;
if (auto rc = avformat_find_stream_info(fmt, nullptr); rc < 0) {
LOGF("\t avformat_find_stream_info failed: %s\n", fferr(rc).c_str());
return AVPLAYER_ERROR_OPERATION_FAILED;
}
return 0;
}
int StreamCount() const { return fmt == nullptr ? 0 : static_cast<int>(fmt->nb_streams); }
int Enable(uint32_t id) {
std::scoped_lock lifecycle_lock(lifecycle_mutex);
std::lock_guard state_lock(mutex);
if (state == State::Playing) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
if (fmt == nullptr || id >= fmt->nb_streams) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
if (!StreamSupported(static_cast<int>(id))) {
return AVPLAYER_ERROR_NOT_SUPPORTED;
}
switch (fmt->streams[id]->codecpar->codec_type) {
case AVMEDIA_TYPE_VIDEO: video_id = static_cast<int>(id); return 0;
case AVMEDIA_TYPE_AUDIO: audio_id = static_cast<int>(id); return 0;
default: return AVPLAYER_ERROR_NOT_SUPPORTED;
}
}
int Disable(uint32_t id) {
std::scoped_lock lifecycle_lock(lifecycle_mutex);
std::lock_guard state_lock(mutex);
if (state == State::Playing) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
if (video_id == static_cast<int>(id)) {
video_id.reset();
return 0;
}
if (audio_id == static_cast<int>(id)) {
audio_id.reset();
return 0;
}
return AVPLAYER_ERROR_OPERATION_FAILED;
}
int Change(uint32_t old_id, uint32_t new_id) {
std::scoped_lock lifecycle_lock(lifecycle_mutex);
if (fmt == nullptr || new_id >= fmt->nb_streams) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
if (!StreamSupported(static_cast<int>(new_id))) {
return AVPLAYER_ERROR_NOT_SUPPORTED;
}
uint64_t time = 0;
bool restart = false;
bool was_paused = false;
{
std::lock_guard state_lock(mutex);
if (audio_id != static_cast<int>(old_id) ||
fmt->streams[new_id]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
time = CurrentTimeNoLock();
restart = state == State::Playing;
was_paused = paused;
if (restart) {
state = State::Ready;
}
}
if (restart) {
StopWorkers();
}
{
std::lock_guard state_lock(mutex);
audio_id = static_cast<int>(new_id);
}
if (!restart) {
return 0;
}
return StartImpl(time, was_paused);
}
int Start(uint64_t ms = 0) {
std::scoped_lock lifecycle_lock(lifecycle_mutex);
return StartImpl(ms);
}
int StartImpl(uint64_t ms, bool paused_after_start = false, bool show_seek_frame = false) {
{
std::lock_guard lock(mutex);
state = State::Ready;
}
StopWorkers();
interrupt_io = false;
int result = 0;
{
std::lock_guard lock(mutex);
ResetNoLock(true);
if (!video_id && !audio_id) {
AutoEnable();
}
if (!video_id && !audio_id) {
state = State::Stopped;
return AVPLAYER_ERROR_OPERATION_FAILED;
}
if (!OpenCodecs()) {
ResetNoLock(true);
state = State::Stopped;
return AVPLAYER_ERROR_OPERATION_FAILED;
}
if (!AllocateBuffers()) {
ResetNoLock(true);
state = State::Stopped;
return AVPLAYER_ERROR_NO_MEMORY;
}
SeekNoLock(ms);
start_time_ms = ms;
clock_start = std::chrono::steady_clock::now();
paused_extra = {};
paused = paused_after_start;
pause_time = clock_start;
seek_video_frame_pending =
paused_after_start && show_seek_frame && video_id.has_value();
}
if (!StartWorkers()) {
std::lock_guard lock(mutex);
state = State::Stopped;
ResetNoLock(true);
result = AVPLAYER_ERROR_OPERATION_FAILED;
}
if (result == 0 && video_id) {
::printf("AvPlayer video started playing\n");
}
return result;
}
int Stop() {
bool was_playing_video = false;
AvPlayerEventReplacement stop_event {};
{
std::scoped_lock lifecycle_lock(lifecycle_mutex);
{
std::lock_guard lock(mutex);
if (state == State::Playing) {
was_playing_video = video_id.has_value();
stop_event = event;
}
state = State::Stopped;
}
StopWorkers();
{
std::lock_guard lock(mutex);
ResetNoLock();
}
}
if (was_playing_video) {
::printf("AvPlayer video stopped\n");
}
emit_event(stop_event, AVPLAYER_EVENT_STATE_STOP);
return 0;
}
int Pause() {
std::scoped_lock lifecycle_lock(lifecycle_mutex);
std::lock_guard lock(mutex);
if (state != State::Playing) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
paused = true;
pause_time = std::chrono::steady_clock::now();
return 0;
}
void Resume() {
std::scoped_lock lifecycle_lock(lifecycle_mutex);
std::lock_guard lock(mutex);
if (paused) {
paused_extra += std::chrono::steady_clock::now() - pause_time;
}
paused = false;
seek_video_frame_pending = false;
}
void SetLoop(bool v) { loop = v; }
void SetSync(uint32_t v) {
std::lock_guard lock(mutex);
sync_mode = v;
}
void SetTrick(int32_t v) {
std::lock_guard lock(mutex);
trick_speed = v;
}
bool Active() const {
std::lock_guard lock(mutex);
return state == State::Ready ||
(state == State::Playing && !pipeline_failed && !DrainedNoLock());
}
uint64_t CurrentTime() const {
std::lock_guard lock(mutex);
return CurrentTimeNoLock();
}
int Jump(uint64_t ms) {
std::scoped_lock lifecycle_lock(lifecycle_mutex);
bool was_paused = false;
{
std::lock_guard lock(mutex);
if (state != State::Playing) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
was_paused = paused;
}
return StartImpl(ms, was_paused, true);
}
uint64_t CurrentTimeNoLock() const {
if (state != State::Playing) {
return 0;
}
using namespace std::chrono;
auto now = paused ? pause_time : steady_clock::now();
return start_time_ms +
static_cast<uint64_t>(
duration_cast<milliseconds>(now - clock_start - paused_extra).count());
}
int Info(uint32_t id, AvPlayerStreamInfo* out) const {
if (out == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
std::memset(out, 0, sizeof(*out));
if (fmt == nullptr || id >= fmt->nb_streams) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
FillCommon(id, &out->type, &out->duration, &out->details, nullptr);
return 0;
}
int InfoEx(uint32_t id, AvPlayerStreamInfoEx* out) const {
if (out == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
std::memset(out, 0, sizeof(*out));
out->this_size = sizeof(*out);
if (fmt == nullptr || id >= fmt->nb_streams) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
FillCommon(id, &out->type, &out->duration, nullptr, &out->details);
return 0;
}
bool Video(AvPlayerFrameInfoEx* out) {
if (out == nullptr) {
return false;
}
std::lock_guard lock(mutex);
if (state != State::Playing || !video_id) {
return false;
}
const bool deliver_seek_frame = paused && seek_video_frame_pending;
if (paused && !deliver_seek_frame) {
return false;
}
auto frame = video_frames.TryPopIf([&](const ReadyFrame& candidate) {
if (deliver_seek_frame || sync_mode != 0) {
return true;
}
auto now = CurrentTimeNoLock();
return now == 0 || candidate.info.time_stamp + candidate.timestamp_offset <= now;
});
if (!frame) {
return false;
}
if (current_video) {
video_buffers.Push(std::move(current_video->buffer));
}
current_video = std::move(*frame);
*out = current_video->info;
RecordLoopBoundary(*current_video);
if (deliver_seek_frame) {
seek_video_frame_pending = false;
}
return true;
}
bool Audio(AvPlayerFrameInfo* out) {
if (out == nullptr) {
return false;
}
std::lock_guard lock(mutex);
if (paused || state != State::Playing || !audio_id ||
trick_speed != AVPLAYER_TRICK_SPEED_NORMAL) {
return false;
}
auto frame = audio_frames.TryPop();
if (!frame) {
return false;
}
if (current_audio) {
audio_buffers.Push(std::move(current_audio->buffer));
}
current_audio = std::move(*frame);
std::memset(out, 0, sizeof(*out));
out->data = current_audio->info.data;
out->time_stamp = current_audio->info.time_stamp;
out->details.audio.channel_count = current_audio->info.details.audio.channel_count;
out->details.audio.sample_rate = current_audio->info.details.audio.sample_rate;
out->details.audio.size = current_audio->info.details.audio.size;
std::memcpy(out->details.audio.language_code,
current_audio->info.details.audio.language_code, 4);
start_time_ms = current_audio->info.time_stamp + current_audio->timestamp_offset;
clock_start = std::chrono::steady_clock::now();
paused_extra = {};
RecordLoopBoundary(*current_audio);
return true;
}
std::optional<int32_t> TakeWarning() {
std::lock_guard lock(mutex);
if (pending_loop_warnings == 0) {
return std::nullopt;
}
--pending_loop_warnings;
return AVPLAYER_WARNING_LOOPING_BACK;
}
private:
enum class State { Ready, Playing, Stopped };
bool DrainedNoLock() const {
return demux_eof && video_done && audio_done && video_frames.Empty() &&
audio_frames.Empty();
}
void RecordLoopBoundary(const ReadyFrame& frame) {
if (frame.timestamp_offset > last_output_loop_offset) {
last_output_loop_offset = frame.timestamp_offset;
++pending_loop_warnings;
}
}
void Close() {
Stop();
if (fmt != nullptr) {
avformat_close_input(&fmt);
}
streamer.reset();
}
void ResetNoLock(bool retain_output_buffers = false) {
video_packets.Clear();
audio_packets.Clear();
video_frames.Clear();
audio_frames.Clear();
video_buffers.Clear();
audio_buffers.Clear();
if (!retain_output_buffers) {
current_video.reset();
current_audio.reset();
}
if (sws != nullptr) {
sws_freeContext(sws);
sws = nullptr;
}
sws_src_width = 0;
sws_src_height = 0;
sws_src_format = AV_PIX_FMT_NONE;
if (swr != nullptr) {
swr_free(&swr);
}
if (video_ctx != nullptr) {
avcodec_free_context(&video_ctx);
}
if (audio_ctx != nullptr) {
avcodec_free_context(&audio_ctx);
}
demux_eof = true;
video_done = true;
audio_done = true;
seek_video_frame_pending = false;
last_output_loop_offset = 0;
pending_loop_warnings = 0;
}
void AutoEnable() {
for (uint32_t i = 0; i < fmt->nb_streams; i++) {
if (!StreamSupported(static_cast<int>(i))) {
continue;
}
auto t = fmt->streams[i]->codecpar->codec_type;
if (t == AVMEDIA_TYPE_VIDEO && !video_id) {
video_id = static_cast<int>(i);
}
if (t == AVMEDIA_TYPE_AUDIO && !audio_id) {
audio_id = static_cast<int>(i);
}
}
}
bool StreamSupported(int id) const {
if (fmt == nullptr || id < 0 || id >= static_cast<int>(fmt->nb_streams)) {
return false;
}
auto* s = fmt->streams[id];
auto t = s->codecpar->codec_type;
if (t != AVMEDIA_TYPE_VIDEO && t != AVMEDIA_TYPE_AUDIO) {
return true;
}
if (!codec_is_supported_for_source(source_type, t, s->codecpar->codec_id)) {
LOGF("\t unsupported codec for source type: stream=%d codec=%d source=%u\n", id,
static_cast<int>(s->codecpar->codec_id), static_cast<uint32_t>(source_type));
return false;
}
if (find_decoder(s->codecpar->codec_id) == nullptr) {
LOGF("\t decoder not found: stream=%d codec=%d\n", id,
static_cast<int>(s->codecpar->codec_id));
return false;
}
return true;
}
bool OpenCodec(int id, AVCodecContext** out) {
auto* s = fmt->streams[id];
auto* dec = find_decoder(s->codecpar->codec_id);
if (dec == nullptr) {
LOGF("\t avcodec_find_decoder failed: stream=%d codec=%d\n", id,
static_cast<int>(s->codecpar->codec_id));
return false;
}
auto* c = avcodec_alloc_context3(dec);
if (c == nullptr) {
return false;
}
if (avcodec_parameters_to_context(c, s->codecpar) < 0 ||
avcodec_open2(c, dec, nullptr) < 0) {
avcodec_free_context(&c);
return false;
}
*out = c;
return true;
}
bool OpenCodecs() {
if (video_id && !OpenCodec(video_id.value(), &video_ctx)) {
return false;
}
if (audio_id && !OpenCodec(audio_id.value(), &audio_ctx)) {
return false;
}
return true;
}
bool AllocateBuffers() {
if (video_id) {
auto size = VideoBufferSize(fmt->streams[video_id.value()]);
auto retained = current_video ? 1u : 0u;
for (size_t i = retained; i < static_cast<size_t>(max_video_buffers); i++) {
auto buffer = std::make_unique<GuestBuffer>(mem, 0x100, size, true);
if (!buffer->Valid()) {
return false;
}
video_buffers.Push(std::move(buffer));
}
}
if (audio_id) {
auto channels = std::max(1, audio_ctx->ch_layout.nb_channels);
auto samples = std::max(1024, audio_ctx->frame_size);
auto size = static_cast<uint32_t>(channels * samples * sizeof(int16_t));
auto retained = current_audio ? 1 : 0;
for (int i = retained; i < AVPLAYER_AUDIO_BUFFERS; i++) {
auto buffer = std::make_unique<GuestBuffer>(mem, 0x100, size, false);
if (!buffer->Valid()) {
return false;
}
audio_buffers.Push(std::move(buffer));
}
}
return true;
}
void SeekNoLock(uint64_t ms) {
int sid = video_id.value_or(audio_id.value_or(-1));
int64_t ts = sid >= 0 ? av_rescale_q(static_cast<int64_t>(ms), AVRational {1, 1000},
fmt->streams[sid]->time_base)
: static_cast<int64_t>(ms) * 1000;
avformat_seek_file(fmt, sid, INT64_MIN, ts, INT64_MAX, 0);
if (video_ctx != nullptr) {
avcodec_flush_buffers(video_ctx);
}
if (audio_ctx != nullptr) {
avcodec_flush_buffers(audio_ctx);
}
video_packets.Clear();
audio_packets.Clear();
}
static KYTY_SYSV_ABI void* DemuxEntry(void* arg) {
static_cast<Source*>(arg)->Demux();
return nullptr;
}
static KYTY_SYSV_ABI void* VideoDecoderEntry(void* arg) {
static_cast<Source*>(arg)->VideoDecoder();
return nullptr;
}
static KYTY_SYSV_ABI void* AudioDecoderEntry(void* arg) {
static_cast<Source*>(arg)->AudioDecoder();
return nullptr;
}
bool CreateWorker(LibKernel::Pthread& thread, LibKernel::pthread_entry_func_t entry,
const char* name) {
LibKernel::Pthread created = nullptr;
if (LibKernel::PthreadCreate(&created, nullptr, entry, this, name) != 0) {
return false;
}
thread = created;
return true;
}
bool StartWorkers() {
std::unique_lock lock(mutex);
worker_stop = false;
interrupt_io = false;
pipeline_failed = false;
demux_eof = false;
video_done = !video_id;
audio_done = !audio_id;
if ((video_id && !CreateWorker(video_thread, VideoDecoderEntry, "AvPlayerVideoDecoder")) ||
(audio_id && !CreateWorker(audio_thread, AudioDecoderEntry, "AvPlayerAudioDecoder")) ||
!CreateWorker(demux_thread, DemuxEntry, "AvPlayerDemuxer")) {
lock.unlock();
StopWorkers();
return false;
}
state = State::Playing;
return true;
}
void NotifyWorkers() {
video_packets.Notify();
audio_packets.Notify();
video_buffers.Notify();
audio_buffers.Notify();
}
void StopWorkers() {
{
std::lock_guard lock(mutex);
worker_stop = true;
interrupt_io = true;
}
NotifyWorkers();
if (demux_thread != nullptr) {
LibKernel::PthreadJoin(demux_thread, nullptr);
demux_thread = nullptr;
}
if (video_thread != nullptr) {
LibKernel::PthreadJoin(video_thread, nullptr);
video_thread = nullptr;
}
if (audio_thread != nullptr) {
LibKernel::PthreadJoin(audio_thread, nullptr);
audio_thread = nullptr;
}
}
void FailPipeline() {
{
std::lock_guard lock(mutex);
pipeline_failed = true;
worker_stop = true;
interrupt_io = true;
}
NotifyWorkers();
}
void Demux() {
uint64_t video_offset = 0;
uint64_t audio_offset = 0;
uint64_t loop_period = fmt->duration > 0 ? static_cast<uint64_t>(fmt->duration / 1000) : 0;
if (loop_period == 0) {
if (video_id) {
loop_period = Duration(fmt->streams[video_id.value()]);
}
if (audio_id) {
loop_period = std::max(loop_period, Duration(fmt->streams[audio_id.value()]));
}
}
while (!worker_stop) {
Packet packet(av_packet_alloc());
if (packet == nullptr) {
FailPipeline();
break;
}
auto result = av_read_frame(fmt, packet.get());
if (result < 0) {
if (result == AVERROR_EOF && loop) {
video_offset += loop_period;
audio_offset += loop_period;
if ((video_id && !video_packets.Push({nullptr, video_offset}, worker_stop)) ||
(audio_id && !audio_packets.Push({nullptr, audio_offset}, worker_stop))) {
break;
}
int stream = video_id.value_or(audio_id.value_or(-1));
if (avformat_seek_file(fmt, stream, INT64_MIN, 0, INT64_MAX, 0) < 0) {
break;
}
continue;
}
if (result != AVERROR_EOF && !worker_stop) {
LOGF("\t av_read_frame failed: %s\n", fferr(result).c_str());
FailPipeline();
}
break;
}
if (video_id && packet->stream_index == video_id.value()) {
if (!video_packets.Push({std::move(packet), video_offset}, worker_stop)) {
break;
}
} else if (audio_id && packet->stream_index == audio_id.value()) {
if (!audio_packets.Push({std::move(packet), audio_offset}, worker_stop)) {
break;
}
}
}
demux_eof = true;
video_packets.Notify();
audio_packets.Notify();
}
void VideoDecoder() {
Decoder(video_packets, video_ctx, video_buffers, video_frames, video_done,
&Source::PrepareVideo, "video");
}
void AudioDecoder() {
Decoder(audio_packets, audio_ctx, audio_buffers, audio_frames, audio_done,
&Source::PrepareAudio, "audio");
}
using PrepareFrame = bool (Source::*)(AVFrame*, std::unique_ptr<GuestBuffer>&,
AvPlayerFrameInfoEx*);
void Decoder(PacketQueue& packets, AVCodecContext* codec,
WorkQueue<std::unique_ptr<GuestBuffer>>& buffers, WorkQueue<ReadyFrame>& frames,
std::atomic_bool& done, PrepareFrame prepare, const char* kind) {
uint64_t timestamp_offset = 0;
while (!worker_stop) {
auto item = packets.WaitPop(worker_stop, demux_eof);
if (!item) {
if (demux_eof &&
!DecodePacket(codec, nullptr, timestamp_offset, buffers, frames, prepare,
kind) &&
!worker_stop) {
FailPipeline();
}
break;
}
if (item->packet == nullptr) {
if (!DecodePacket(codec, nullptr, timestamp_offset, buffers, frames, prepare,
kind)) {
if (!worker_stop) {
FailPipeline();
}
break;
}
avcodec_flush_buffers(codec);
timestamp_offset = item->timestamp_offset;
continue;
}
timestamp_offset = item->timestamp_offset;
if (!DecodePacket(codec, item->packet.get(), timestamp_offset, buffers, frames, prepare,
kind)) {
if (!worker_stop) {
FailPipeline();
}
break;
}
}
done = true;
}
bool DecodePacket(AVCodecContext* codec, AVPacket* packet, uint64_t timestamp_offset,
WorkQueue<std::unique_ptr<GuestBuffer>>& buffers,
WorkQueue<ReadyFrame>& frames, PrepareFrame prepare, const char* kind) {
auto result = avcodec_send_packet(codec, packet);
if (result == AVERROR(EAGAIN)) {
if (!ReceiveFrames(codec, timestamp_offset, buffers, frames, prepare, kind)) {
return false;
}
result = avcodec_send_packet(codec, packet);
}
if (result == AVERROR_EOF) {
return true;
}
if (result < 0) {
LOGF("\t avcodec_send_packet %s failed: %s\n", kind, fferr(result).c_str());
return false;
}
return ReceiveFrames(codec, timestamp_offset, buffers, frames, prepare, kind);
}
bool ReceiveFrames(AVCodecContext* codec, uint64_t timestamp_offset,
WorkQueue<std::unique_ptr<GuestBuffer>>& buffers,
WorkQueue<ReadyFrame>& frames, PrepareFrame prepare, const char* kind) {
while (!worker_stop) {
AVFrame* frame = av_frame_alloc();
if (frame == nullptr) {
return false;
}
auto result = avcodec_receive_frame(codec, frame);
if (result == AVERROR(EAGAIN) || result == AVERROR_EOF) {
av_frame_free(&frame);
return true;
}
if (result < 0) {
LOGF("\t avcodec_receive_frame %s failed: %s\n", kind, fferr(result).c_str());
av_frame_free(&frame);
return false;
}
auto buffer = buffers.WaitPop(worker_stop);
if (!buffer) {
av_frame_free(&frame);
return false;
}
ReadyFrame ready {.buffer = std::move(*buffer)};
if (!(this->*prepare)(frame, ready.buffer, &ready.info)) {
buffers.Push(std::move(ready.buffer));
av_frame_free(&frame);
return false;
}
ready.timestamp_offset = timestamp_offset;
frames.Push(std::move(ready));
av_frame_free(&frame);
}
return false;
}
uint32_t Width(AVStream* s) const {
return use_vdec2 ? static_cast<uint32_t>(s->codecpar->width)
: align_up(static_cast<uint32_t>(s->codecpar->width), 16);
}
uint32_t Height(AVStream* s) const {
return use_vdec2 ? static_cast<uint32_t>(s->codecpar->height)
: align_up(static_cast<uint32_t>(s->codecpar->height), 16);
}
float Aspect(AVRational ratio) const {
return ratio.num > 0 && ratio.den > 0 ? static_cast<float>(av_q2d(ratio)) : 0.0f;
}
uint64_t Duration(AVStream* s) const {
return s->duration != AV_NOPTS_VALUE
? to_ms(s->duration, s->time_base)
: (fmt->duration > 0 ? static_cast<uint64_t>(fmt->duration / 1000) : 0);
}
uint32_t VideoPitch(AVStream* s) const { return align_up(Width(s), 256u); }
uint32_t VideoBufferSize(AVStream* s) const { return VideoPitch(s) * Height(s) * 3 / 2; }
void FillVideo(AVStream* s, AvPlayerVideo* v) const {
std::memset(v, 0, sizeof(*v));
v->width = Width(s);
v->height = Height(s);
v->aspect_ratio = Aspect(s->sample_aspect_ratio);
lang(v->language_code, s->metadata);
}
void FillVideoEx(AVStream* s, AvPlayerVideoEx* v, AVRational aspect) const {
std::memset(v, 0, sizeof(*v));
v->width = Width(s);
v->height = Height(s);
v->aspect_ratio = Aspect(aspect);
v->pitch = VideoPitch(s);
v->luma_bit_depth = 8;
v->chroma_bit_depth = 8;
v->video_full_range_flag = s->codecpar->color_range == AVCOL_RANGE_JPEG ? 1 : 0;
auto fr = s->avg_frame_rate.num != 0 ? s->avg_frame_rate : s->r_frame_rate;
v->framerate = av_q2d(fr);
v->colour_primaries = static_cast<uint32_t>(s->codecpar->color_primaries);
v->transfer_characteristics = static_cast<uint32_t>(s->codecpar->color_trc);
lang(v->language_code, s->metadata);
}
void FillAudio(AVStream* s, AvPlayerAudio* a, uint32_t size) const {
std::memset(a, 0, sizeof(*a));
a->channel_count = static_cast<uint16_t>(s->codecpar->ch_layout.nb_channels);
a->sample_rate = static_cast<uint32_t>(s->codecpar->sample_rate);
a->size = size;
lang(a->language_code, s->metadata);
}
void FillAudioEx(AVStream* s, AvPlayerAudioEx* a, uint32_t size) const {
std::memset(a, 0, sizeof(*a));
a->channel_count = static_cast<uint16_t>(s->codecpar->ch_layout.nb_channels);
a->sample_rate = static_cast<uint32_t>(s->codecpar->sample_rate);
a->size = size;
lang(a->language_code, s->metadata);
}
void FillCommon(uint32_t id, AvPlayerStreamType* type, uint64_t* dur, AvPlayerStreamDetails* d,
AvPlayerStreamDetailsEx* ex) const {
auto* s = fmt->streams[id];
*dur = Duration(s);
switch (s->codecpar->codec_type) {
case AVMEDIA_TYPE_VIDEO:
*type = AvPlayerStreamVideo;
if (d) {
FillVideo(s, &d->video);
}
if (ex) {
FillVideoEx(s, &ex->video, s->sample_aspect_ratio);
}
break;
case AVMEDIA_TYPE_AUDIO:
*type = AvPlayerStreamAudio;
if (d) {
FillAudio(s, &d->audio, 0);
}
if (ex) {
FillAudioEx(s, &ex->audio, 0);
}
break;
case AVMEDIA_TYPE_SUBTITLE: *type = AvPlayerStreamTimedText; break;
default: *type = AvPlayerStreamUnknown; break;
}
}
bool PrepareVideo(AVFrame* src, std::unique_ptr<GuestBuffer>& buffer,
AvPlayerFrameInfoEx* info) {
auto* s = fmt->streams[video_id.value()];
uint32_t h = Height(s);
uint32_t pitch = VideoPitch(s);
uint64_t size = static_cast<uint64_t>(pitch) * h * 3 / 2;
if (buffer == nullptr || src->width <= 0 || src->height <= 0 ||
static_cast<uint32_t>(src->width) > pitch || static_cast<uint32_t>(src->height) > h ||
size > buffer->Size()) {
return false;
}
AVFrame* nv12 = src;
AVFrame* tmp = nullptr;
if (src->format != AV_PIX_FMT_NV12) {
tmp = av_frame_alloc();
if (tmp == nullptr) {
return false;
}
tmp->format = AV_PIX_FMT_NV12;
tmp->width = src->width;
tmp->height = src->height;
if (av_frame_get_buffer(tmp, 0) < 0) {
av_frame_free(&tmp);
return false;
}
if (sws == nullptr || sws_src_width != src->width || sws_src_height != src->height ||
sws_src_format != src->format) {
if (sws != nullptr) {
sws_freeContext(sws);
}
sws = sws_getContext(
src->width, src->height, static_cast<AVPixelFormat>(src->format), src->width,
src->height, AV_PIX_FMT_NV12, SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
sws_src_width = src->width;
sws_src_height = src->height;
sws_src_format = src->format;
}
if (sws == nullptr) {
av_frame_free(&tmp);
return false;
}
if (sws_scale(sws, src->data, src->linesize, 0, src->height, tmp->data,
tmp->linesize) != src->height) {
av_frame_free(&tmp);
return false;
}
nv12 = tmp;
}
if (nv12->data[0] == nullptr || nv12->data[1] == nullptr ||
nv12->linesize[0] < src->width || nv12->linesize[1] < src->width) {
if (tmp != nullptr) {
av_frame_free(&tmp);
}
return false;
}
auto* dst = buffer->Get();
auto* c = dst + pitch * h;
// PPSA02433 samples the padded columns; zero chroma would turn them green.
std::memset(dst, s->codecpar->color_range == AVCOL_RANGE_JPEG ? 0 : 16,
static_cast<size_t>(pitch) * h);
std::memset(c, 128, static_cast<size_t>(pitch) * h / 2);
for (int y = 0; y < src->height; y++) {
std::memcpy(dst + y * pitch, nv12->data[0] + y * nv12->linesize[0], src->width);
}
for (int y = 0; y < src->height / 2; y++) {
std::memcpy(c + y * pitch, nv12->data[1] + y * nv12->linesize[1], src->width);
}
std::memset(info, 0, sizeof(*info));
info->data = dst;
info->time_stamp = to_ms(
src->best_effort_timestamp != AV_NOPTS_VALUE ? src->best_effort_timestamp : src->pts,
s->time_base);
FillVideoEx(s, &info->details.video, src->sample_aspect_ratio);
info->details.video.crop_left_offset = static_cast<uint32_t>(src->crop_left);
info->details.video.crop_right_offset =
static_cast<uint32_t>(src->crop_right + (pitch - src->width));
info->details.video.crop_top_offset = static_cast<uint32_t>(src->crop_top);
info->details.video.crop_bottom_offset =
static_cast<uint32_t>(src->crop_bottom + (h - src->height));
info->details.video.pitch = pitch;
if (tmp) {
av_frame_free(&tmp);
}
return true;
}
bool PrepareAudio(AVFrame* src, std::unique_ptr<GuestBuffer>& buffer,
AvPlayerFrameInfoEx* info) {
auto timestamp = to_ms(
src->best_effort_timestamp != AV_NOPTS_VALUE ? src->best_effort_timestamp : src->pts,
fmt->streams[audio_id.value()]->time_base);
AVFrame* pcm = src;
AVFrame* tmp = nullptr;
if (src->format != AV_SAMPLE_FMT_S16) {
tmp = av_frame_alloc();
if (tmp == nullptr) {
return false;
}
tmp->format = AV_SAMPLE_FMT_S16;
tmp->sample_rate = src->sample_rate;
tmp->nb_samples = src->nb_samples;
av_channel_layout_copy(&tmp->ch_layout, &src->ch_layout);
if (av_frame_get_buffer(tmp, 0) < 0) {
av_frame_free(&tmp);
return false;
}
if (swr == nullptr) {
SwrContext* ctx = nullptr;
AVChannelLayout out;
av_channel_layout_copy(&out, &src->ch_layout);
swr_alloc_set_opts2(&ctx, &out, AV_SAMPLE_FMT_S16, src->sample_rate,
&src->ch_layout, static_cast<AVSampleFormat>(src->format),
src->sample_rate, 0, nullptr);
swr = ctx;
swr_init(swr);
av_channel_layout_uninit(&out);
}
if (swr == nullptr || swr_convert_frame(swr, tmp, src) < 0) {
av_frame_free(&tmp);
return false;
}
pcm = tmp;
}
auto channels = std::max(1, pcm->ch_layout.nb_channels);
auto size = static_cast<uint32_t>(channels * pcm->nb_samples * sizeof(int16_t));
if (size > buffer->Size()) {
auto replacement = std::make_unique<GuestBuffer>(mem, 0x100, size, false);
if (!replacement->Valid()) {
if (tmp) {
av_frame_free(&tmp);
}
return false;
}
buffer = std::move(replacement);
}
std::memcpy(buffer->Get(), pcm->data[0], size);
auto* s = fmt->streams[audio_id.value()];
std::memset(info, 0, sizeof(*info));
info->data = buffer->Get();
info->time_stamp = timestamp;
FillAudioEx(s, &info->details.audio, size);
info->details.audio.channel_count = static_cast<uint16_t>(channels);
info->details.audio.sample_rate = static_cast<uint32_t>(pcm->sample_rate);
if (tmp) {
av_frame_free(&tmp);
}
return true;
}
AvPlayerMemAllocator mem;
AvPlayerFileReplacement file;
AvPlayerEventReplacement event;
int max_video_buffers = 2;
bool use_vdec2 = false;
AvPlayerSourceType source_type = AvPlayerSourceUnknown;
std::string path;
std::unique_ptr<FileStreamer> streamer;
AVFormatContext* fmt = nullptr;
AVCodecContext* video_ctx = nullptr;
AVCodecContext* audio_ctx = nullptr;
SwsContext* sws = nullptr;
SwrContext* swr = nullptr;
int sws_src_width = 0;
int sws_src_height = 0;
int sws_src_format = AV_PIX_FMT_NONE;
std::optional<int> video_id;
std::optional<int> audio_id;
PacketQueue video_packets;
PacketQueue audio_packets;
WorkQueue<std::unique_ptr<GuestBuffer>> video_buffers;
WorkQueue<std::unique_ptr<GuestBuffer>> audio_buffers;
WorkQueue<ReadyFrame> video_frames;
WorkQueue<ReadyFrame> audio_frames;
std::optional<ReadyFrame> current_video;
std::optional<ReadyFrame> current_audio;
LibKernel::Pthread demux_thread = nullptr;
LibKernel::Pthread video_thread = nullptr;
LibKernel::Pthread audio_thread = nullptr;
std::atomic_bool worker_stop {true};
std::atomic_bool interrupt_io {false};
std::atomic_bool pipeline_failed {false};
std::atomic_bool demux_eof {true};
std::atomic_bool video_done {true};
std::atomic_bool audio_done {true};
std::mutex lifecycle_mutex;
mutable std::mutex mutex;
State state = State::Ready;
bool paused = false;
bool seek_video_frame_pending = false;
std::atomic_bool loop {false};
int32_t trick_speed = AVPLAYER_TRICK_SPEED_NORMAL;
uint32_t sync_mode = 0;
uint64_t start_time_ms = 0;
uint64_t last_output_loop_offset = 0;
uint32_t pending_loop_warnings = 0;
std::chrono::steady_clock::time_point clock_start {};
std::chrono::steady_clock::time_point pause_time {};
std::chrono::steady_clock::duration paused_extra {};
};
struct AvPlayerInternal {
AvPlayerMemAllocator mem;
AvPlayerFileReplacement file;
AvPlayerEventReplacement event;
AvPlayerPostInitData post_init {};
bool auto_start = false;
int32_t video_buffers = 2;
uint32_t sync_mode = 0;
uint32_t start_bandwidth = 0;
uint32_t minimum_bandwidth = 0;
uint32_t maximum_bandwidth = 0;
std::unique_ptr<Source> source;
};
static bool valid_allocators(const AvPlayerMemAllocator& m) {
return m.allocate && m.deallocate && m.allocate_texture && m.deallocate_texture;
}
static void pump_warnings(AvPlayerInternal* h) {
if (h == nullptr || h->source == nullptr) {
return;
}
while (auto w = h->source->TakeWarning()) {
int32_t warning = *w;
emit_event(h->event, AVPLAYER_EVENT_WARNING_ID, &warning);
}
}
static AvPlayerInternal* create_player(const AvPlayerMemAllocator& mem,
const AvPlayerFileReplacement& file,
const AvPlayerEventReplacement& event, bool auto_start,
int32_t video_buffers) {
if (!valid_allocators(mem)) {
return nullptr;
}
auto* h = new AvPlayerInternal;
h->mem = mem;
h->file = file;
h->event = event;
h->auto_start = auto_start || event.event_callback == nullptr;
h->video_buffers = std::clamp(video_buffers <= 0 ? 2 : video_buffers, 2, 16);
h->post_init.demux_video_buffer_size = 4 * 1024 * 1024;
return h;
}
static int add_source(AvPlayerInternal* h, const std::string& filename, AvPlayerSourceType type) {
if (h == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
if (h->source != nullptr) {
return AVPLAYER_ERROR_OPERATION_FAILED;
}
bool vdec2 =
h->post_init.video_decoder_init.decoder_type.video_type == AvPlayerVideoDecoderSoftware2;
auto s = std::make_unique<Source>(h->mem, h->file, h->event, h->video_buffers, vdec2,
h->post_init.demux_video_buffer_size);
if (auto rc = s->Init(filename, type); rc < 0) {
return rc;
}
s->SetSync(h->sync_mode);
h->source = std::move(s);
emit_event(h->event, AVPLAYER_EVENT_STATE_READY);
if (h->auto_start) {
auto rc = h->source->Start();
if (rc == 0) {
emit_event(h->event, AVPLAYER_EVENT_STATE_PLAY);
}
return rc;
}
return 0;
}
static void log_init_common(const AvPlayerMemAllocator& mem, const AvPlayerFileReplacement& file,
const AvPlayerEventReplacement& event, AvPlayerDebuglevels debug_level,
int32_t buffers, uint32_t priority, Bool auto_start,
const char* language) {
LOGF("\t memory_replacement.object_pointer = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(mem.object_pointer));
LOGF("\t memory_replacement.allocate = %016" PRIx64
"\n\t memory_replacement.deallocate = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(mem.allocate), reinterpret_cast<uint64_t>(mem.deallocate));
LOGF("\t memory_replacement.allocate_texture = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(mem.allocate_texture));
LOGF("\t memory_replacement.deallocate_texture = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(mem.deallocate_texture));
LOGF("\t file_replacement.object_pointer = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(file.object_pointer));
LOGF("\t file_replacement.open = %016" PRIx64
"\n\t file_replacement.close = %016" PRIx64
"\n\t file_replacement.read_offset = %016" PRIx64
"\n\t file_replacement.size = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(file.open), reinterpret_cast<uint64_t>(file.close),
reinterpret_cast<uint64_t>(file.read_offset), reinterpret_cast<uint64_t>(file.size));
LOGF("\t event_replacement.object_pointer = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(event.object_pointer));
LOGF("\t event_replacement.event_callback = %016" PRIx64 "\n",
reinterpret_cast<uint64_t>(event.event_callback));
LOGF("\t debug_level = %s\n\t num_output_video_framebuffers "
"= %d\n\t base_priority "
" = %u\n\t auto_start = %u\n\t default_language "
" = %s\n",
magic_enum::enum_name(debug_level), buffers, priority, auto_start,
language == nullptr ? "(null)" : language);
}
AvPlayerInternal* KYTY_SYSV_ABI AvPlayerInit(AvPlayerInitData* init) {
PRINT_NAME();
if (init == nullptr) {
return nullptr;
}
log_init_common(init->memory_replacement, init->file_replacement, init->event_replacement,
init->debug_level, init->num_output_video_framebuffers, init->base_priority,
init->auto_start, init->default_language);
return create_player(init->memory_replacement, init->file_replacement, init->event_replacement,
init->auto_start != 0, init->num_output_video_framebuffers);
}
int KYTY_SYSV_ABI AvPlayerInitEx(const void* init_ex, AvPlayerInternal** handle) {
PRINT_NAME();
if (init_ex == nullptr || handle == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
const auto* init = static_cast<const AvPlayerInitDataEx*>(init_ex);
LOGF("\t this_size = %zu\n", init->this_size);
log_init_common(init->memory_replacement, init->file_replacement, init->event_replacement,
init->debug_level, init->num_output_video_framebuffers, 0, init->auto_start,
init->default_language);
*handle =
create_player(init->memory_replacement, init->file_replacement, init->event_replacement,
init->auto_start != 0, init->num_output_video_framebuffers);
return *handle == nullptr ? AVPLAYER_ERROR_INVALID_PARAMS : 0;
}
int KYTY_SYSV_ABI AvPlayerPostInit(AvPlayerInternal* h, const void* post_init) {
PRINT_NAME();
if (h == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
if (post_init != nullptr) {
h->post_init = *static_cast<const AvPlayerPostInitData*>(post_init);
LOGF("\t demux_video_buffer_size = %u\n", h->post_init.demux_video_buffer_size);
}
return 0;
}
int KYTY_SYSV_ABI AvPlayerAddSource(AvPlayerInternal* h, const char* filename) {
PRINT_NAME();
if (h == nullptr || filename == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
LOGF("\t filename = %s\n", filename);
return add_source(h, filename, AvPlayerSourceUnknown);
}
int KYTY_SYSV_ABI AvPlayerAddSourceEx(AvPlayerInternal* h, uint32_t uri_type,
const void* source_details) {
PRINT_NAME();
if (h == nullptr || uri_type != AvPlayerUriTypeSource || source_details == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
const auto* d = static_cast<const AvPlayerSourceDetails*>(source_details);
if (d->uri.name == nullptr || d->uri.length == 0) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
if (d->source_type != AvPlayerSourceUnknown && d->source_type != AvPlayerSourceFileMp4 &&
d->source_type != AvPlayerSourceFileWebm && d->source_type != AvPlayerSourceHls) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
std::string filename(d->uri.name, d->uri.length);
LOGF("\t uri_type = %u\n\t source_type = %u\n\t filename = %s\n", uri_type,
static_cast<uint32_t>(d->source_type), filename.c_str());
return add_source(h, filename, d->source_type);
}
int KYTY_SYSV_ABI AvPlayerStreamCount(AvPlayerInternal* h) {
PRINT_NAME();
return h == nullptr ? AVPLAYER_ERROR_INVALID_PARAMS
: (h->source == nullptr ? 0 : h->source->StreamCount());
}
int KYTY_SYSV_ABI AvPlayerGetStreamInfo(AvPlayerInternal* h, uint32_t stream_id, void* info) {
PRINT_NAME();
if (h == nullptr || info == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
return h->source == nullptr
? AVPLAYER_ERROR_OPERATION_FAILED
: h->source->Info(stream_id, static_cast<AvPlayerStreamInfo*>(info));
}
int KYTY_SYSV_ABI AvPlayerGetStreamInfoEx(AvPlayerInternal* h, uint32_t stream_id, void* info) {
PRINT_NAME();
if (h == nullptr || info == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
return h->source == nullptr
? AVPLAYER_ERROR_OPERATION_FAILED
: h->source->InfoEx(stream_id, static_cast<AvPlayerStreamInfoEx*>(info));
}
int KYTY_SYSV_ABI AvPlayerEnableStream(AvPlayerInternal* h, uint32_t stream_id) {
PRINT_NAME();
return h == nullptr || h->source == nullptr ? AVPLAYER_ERROR_INVALID_PARAMS
: h->source->Enable(stream_id);
}
int KYTY_SYSV_ABI AvPlayerDisableStream(AvPlayerInternal* h, uint32_t stream_id) {
PRINT_NAME();
return h == nullptr || h->source == nullptr ? AVPLAYER_ERROR_INVALID_PARAMS
: h->source->Disable(stream_id);
}
int KYTY_SYSV_ABI AvPlayerChangeStream(AvPlayerInternal* h, uint32_t old_stream_id,
uint32_t new_stream_id) {
PRINT_NAME();
return h == nullptr || h->source == nullptr ? AVPLAYER_ERROR_INVALID_PARAMS
: h->source->Change(old_stream_id, new_stream_id);
}
int KYTY_SYSV_ABI AvPlayerStart(AvPlayerInternal* h) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
auto rc = h->source->Start();
if (rc == 0) {
emit_event(h->event, AVPLAYER_EVENT_STATE_PLAY);
}
return rc;
}
int KYTY_SYSV_ABI AvPlayerStartEx(AvPlayerInternal* h, const void* start_info_ex) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
uint64_t ms =
start_info_ex == nullptr
? 0
: static_cast<const AvPlayerStartInfoEx*>(start_info_ex)->start_time_milliseconds;
auto rc = h->source->Start(ms);
if (rc == 0) {
emit_event(h->event, AVPLAYER_EVENT_STATE_PLAY);
}
return rc;
}
int KYTY_SYSV_ABI AvPlayerStop(AvPlayerInternal* h) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
return h->source->Stop();
}
int KYTY_SYSV_ABI AvPlayerPause(AvPlayerInternal* h) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
auto rc = h->source->Pause();
if (rc == 0) {
emit_event(h->event, AVPLAYER_EVENT_STATE_PAUSE);
}
return rc;
}
int KYTY_SYSV_ABI AvPlayerResume(AvPlayerInternal* h) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
h->source->Resume();
emit_event(h->event, AVPLAYER_EVENT_STATE_PLAY);
return 0;
}
int KYTY_SYSV_ABI AvPlayerSetLooping(AvPlayerInternal* h, Bool loop) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
h->source->SetLoop(loop != 0);
return 0;
}
int KYTY_SYSV_ABI AvPlayerSetTrickSpeed(AvPlayerInternal* h, int32_t trick_speed) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
trick_speed = std::clamp(trick_speed, -AVPLAYER_TRICK_SPEED_MAX, AVPLAYER_TRICK_SPEED_MAX);
if (trick_speed != AVPLAYER_TRICK_SPEED_NORMAL && trick_speed > -AVPLAYER_TRICK_SPEED_MIN &&
trick_speed < AVPLAYER_TRICK_SPEED_MIN) {
return AVPLAYER_ERROR_NOT_SUPPORTED;
}
h->source->SetTrick(trick_speed);
return trick_speed == AVPLAYER_TRICK_SPEED_NORMAL ? 0 : AVPLAYER_ERROR_NOT_SUPPORTED;
}
int KYTY_SYSV_ABI AvPlayerSetAvSyncMode(AvPlayerInternal* h, uint32_t sync_mode) {
PRINT_NAME();
if (h == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
if (sync_mode > 1) {
return AVPLAYER_ERROR_NOT_SUPPORTED;
}
h->sync_mode = sync_mode;
if (h->source != nullptr) {
h->source->SetSync(sync_mode);
}
return 0;
}
int KYTY_SYSV_ABI AvPlayerSetAvailableBandwidth(AvPlayerInternal* h, uint32_t start_bandwidth,
uint32_t minimum_bandwidth,
uint32_t maximum_bandwidth) {
PRINT_NAME();
if (h == nullptr || (minimum_bandwidth != 0 && maximum_bandwidth != 0 &&
minimum_bandwidth > maximum_bandwidth)) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
h->start_bandwidth = start_bandwidth;
h->minimum_bandwidth = minimum_bandwidth;
h->maximum_bandwidth = maximum_bandwidth;
return h->source == nullptr ? 0 : AVPLAYER_ERROR_OPERATION_FAILED;
}
Bool KYTY_SYSV_ABI AvPlayerGetVideoData(AvPlayerInternal* h, AvPlayerFrameInfo* video_info) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr || video_info == nullptr) {
return 0;
}
AvPlayerFrameInfoEx ex {};
if (!h->source->Video(&ex)) {
pump_warnings(h);
return 0;
}
std::memset(video_info, 0, sizeof(*video_info));
video_info->data = ex.data;
video_info->time_stamp = ex.time_stamp;
video_info->details.video.width = ex.details.video.width;
video_info->details.video.height = ex.details.video.height;
video_info->details.video.aspect_ratio = ex.details.video.aspect_ratio;
std::memcpy(video_info->details.video.language_code, ex.details.video.language_code, 4);
pump_warnings(h);
return 1;
}
Bool KYTY_SYSV_ABI AvPlayerGetVideoDataEx(AvPlayerInternal* h, AvPlayerFrameInfoEx* video_info) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr || video_info == nullptr) {
return 0;
}
auto ok = h->source->Video(video_info) ? 1 : 0;
pump_warnings(h);
return ok;
}
Bool KYTY_SYSV_ABI AvPlayerGetAudioData(AvPlayerInternal* h, AvPlayerFrameInfo* audio_info) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr || audio_info == nullptr) {
return 0;
}
auto ok = h->source->Audio(audio_info) ? 1 : 0;
pump_warnings(h);
return ok;
}
Bool KYTY_SYSV_ABI AvPlayerIsActive(AvPlayerInternal* h) {
PRINT_NAME();
return h != nullptr && (h->source == nullptr || h->source->Active());
}
uint64_t KYTY_SYSV_ABI AvPlayerCurrentTime(AvPlayerInternal* h) {
PRINT_NAME();
return h == nullptr || h->source == nullptr ? 0 : h->source->CurrentTime();
}
int KYTY_SYSV_ABI AvPlayerJumpToTime(AvPlayerInternal* h, uint64_t time_ms) {
PRINT_NAME();
if (h == nullptr || h->source == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
auto rc = h->source->Jump(time_ms);
if (rc == 0) {
int32_t w = AVPLAYER_WARNING_JUMP_COMPLETE;
emit_event(h->event, AVPLAYER_EVENT_WARNING_ID, &w);
}
return rc;
}
int KYTY_SYSV_ABI AvPlayerClose(AvPlayerInternal* h) {
PRINT_NAME();
if (h == nullptr) {
return AVPLAYER_ERROR_INVALID_PARAMS;
}
h->source.reset();
delete h;
return 0;
}
int KYTY_SYSV_ABI AvPlayerSetLogCallback(void* callback, void* user_data) {
PRINT_NAME();
LOGF("\t callback = 0x%016" PRIx64 "\n\t user_data = 0x%016" PRIx64 "\n",
reinterpret_cast<uint64_t>(callback), reinterpret_cast<uint64_t>(user_data));
return 0;
}
} // namespace Libs::Audio::AvPlayer
Reference in New Issue View Git Blame Copy Permalink