xaymar/obs-ffmpeg-encoder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 14 Wiki Activity

Initial code (pre-GitHub)

Browse Source 
Contains:
- ffmpeg object wrappers
- base encoder class
- Apply ProRes encoder (prores_aw)
- OBS plugin structure
This commit is contained in:
Michael Fabian 'Xaymar' Dirks
2018-11-13 19:04:13 +01:00
parent e1d41695a2
commit ec75fe23fe
24 changed files with 2515 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/encoder.cpp
+20
View File
@@ -0,0 +1,20 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#include "encoder.hpp"
obsffmpeg::encoder::base::~base() {}
source/encoder.hpp
+145
View File
@@ -0,0 +1,145 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef OBS_FFMPEG_ENCODER_HPP
#define OBS_FFMPEG_ENCODER_HPP
#pragma once
#include <map>
#include <string>
#include "ffmpeg/swscale.hpp"
#include <obs.h>
extern "C" {
#pragma warning(push)
#pragma warning(disable : 4244)
#include "libavcodec/avcodec.h"
#include "libswscale/swscale.h"
#pragma warning(pop)
}
namespace obsffmpeg {
namespace encoder {
class base {
protected:
obs_encoder_t* self = nullptr;
AVCodec* avcodec = nullptr;
AVCodecContext* avcontext = nullptr;
AVDictionary* avdictionary = nullptr;
ffmpeg::swscale swscale;
std::pair<uint32_t, uint32_t> resolution;
std::pair<uint32_t, uint32_t> framerate;
AVPixelFormat source_format;
AVColorSpace source_colorspace;
AVColorRange source_range;
AVPixelFormat target_format;
AVColorSpace target_colorspace;
AVColorRange target_range;
public:
virtual ~base();
virtual void get_properties(obs_properties_t* props) = 0;
virtual bool update(obs_data_t* settings) = 0;
virtual bool get_extra_data(uint8_t** extra_data, size_t* size) = 0;
virtual bool get_sei_data(uint8_t** sei_data, size_t* size) = 0;
virtual void get_video_info(struct video_scale_info* info) = 0;
virtual bool encode(struct encoder_frame* frame, struct encoder_packet* packet,
bool* received_packet) = 0;
};
#define make_encoder_base(_source, _target, _name, _codec) \
static void* _source##_create(obs_data_t* settings, obs_encoder_t* encoder) \
{ \
_target* ptr = nullptr; \
try { \
ptr = new _target(settings, encoder); \
} catch (...) { \
} \
return ptr; \
} \
static void _source##_destroy(void* ptr) \
{ \
delete static_cast<_target*>(ptr); \
} \
static const char* _source##_get_name(void*) \
{ \
return _name; \
} \
static obs_properties_t* _source##_get_properties(void* ptr) \
{ \
obs_properties_t* pr = _target::get_properties(); \
if (ptr) { \
static_cast<_target*>(ptr)->get_properties(pr); \
} \
return pr; \
} \
static void _source##_get_defaults(obs_data_t* settings) \
{ \
_target::get_defaults(settings); \
} \
static bool _source##_get_extra_data(void* ptr, uint8_t** extra_data, size_t* size) \
{ \
return static_cast<_target*>(ptr)->get_extra_data(extra_data, size); \
} \
static bool _source##_get_sei_data(void* ptr, uint8_t** sei_data, size_t* size) \
{ \
return static_cast<_target*>(ptr)->get_sei_data(sei_data, size); \
} \
static void _source##_get_video_info(void* ptr, struct video_scale_info* info) \
{ \
static_cast<_target*>(ptr)->get_video_info(info); \
} \
static bool _source##_encode(void* ptr, struct encoder_frame* frame, struct encoder_packet* packet, \
bool* received_packet) \
{ \
return static_cast<_target*>(ptr)->encode(frame, packet, received_packet); \
} \
static obs_encoder_info _source##_info; \
static void _source##_initialize() \
{ \
_source##_info.id = "obs-ffmpeg-encoder-" #_source; \
_source##_info.type = OBS_ENCODER_VIDEO; \
_source##_info.caps = 0; \
_source##_info.codec = _codec; \
_source##_info.create = _source##_create; \
_source##_info.destroy = _source##_destroy; \
_source##_info.get_name = _source##_get_name; \
_source##_info.get_properties = _source##_get_properties; \
_source##_info.get_defaults = _source##_get_defaults; \
_source##_info.get_extra_data = _source##_get_extra_data; \
_source##_info.get_sei_data = _source##_get_sei_data; \
_source##_info.get_video_info = _source##_get_video_info; \
_source##_info.encode = _source##_encode; \
obs_register_encoder(&(_source##_info)); \
}
//*/
} // namespace encoder
} // namespace obsffmpeg
#endif OBS_FFMPEG_ENCODER_HPP
source/encoders/prores_aw.cpp
+343
View File
@@ -0,0 +1,343 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#include "prores_aw.hpp"
#include <obs-module.h>
#include <thread>
#include "ffmpeg/tools.hpp"
#include "utility.hpp"
extern "C" {
#pragma warning(push)
#pragma warning(disable : 4244)
#include "libavutil/dict.h"
#include "libavutil/frame.h"
#include "libavutil/opt.h"
#pragma warning(pop)
}
#include <util/profiler.hpp>
#define T_PROFILE "ProRes.Profile"
#define T_PROFILE_(x) "ProRes.Profile." vstr(x)
#define T_CUSTOM "Custom"
#define LOG_PREFIX "[prores_aw] "
make_encoder_base(prores_aw, obsffmpeg::encoder::prores_aw, "ProRes (Anatoliy Wasserman) (FFMPEG)", "prores");
void obsffmpeg::encoder::prores_aw::initialize()
{
auto avd = avcodec_find_encoder_by_name("prores_aw");
if (!avd) {
PLOG_INFO("ProRes (Anatoliy Wasserman) not supported.");
return;
}
prores_aw_initialize();
PLOG_INFO("ProRes (Anatoliy Wasserman) supported.");
}
void obsffmpeg::encoder::prores_aw::finalize()
{
//prores_aw_finalize();
}
void obsffmpeg::encoder::prores_aw::get_defaults(obs_data_t* settings)
{
obs_data_set_default_int(settings, T_PROFILE, static_cast<long long>(profile::HighQuality));
}
obs_properties_t* obsffmpeg::encoder::prores_aw::get_properties()
{
obs_properties_t* prs = obs_properties_create();
obs_property_t* p = nullptr;
p = obs_properties_add_list(prs, T_PROFILE, TRANSLATE(T_PROFILE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_set_long_description(p, TRANSLATE(DESC(T_PROFILE)));
obs_property_list_add_int(p, TRANSLATE(T_PROFILE_(Proxy)), static_cast<long long>(profile::Proxy));
obs_property_list_add_int(p, TRANSLATE(T_PROFILE_(Light)), static_cast<long long>(profile::Light));
obs_property_list_add_int(p, TRANSLATE(T_PROFILE_(Standard)), static_cast<long long>(profile::Standard));
obs_property_list_add_int(p, TRANSLATE(T_PROFILE_(HighQuality)), static_cast<long long>(profile::HighQuality));
p = obs_properties_add_text(prs, T_CUSTOM, TRANSLATE(T_CUSTOM), OBS_TEXT_DEFAULT);
obs_property_set_long_description(p, TRANSLATE(DESC(T_CUSTOM)));
return prs;
}
obsffmpeg::encoder::prores_aw::prores_aw(obs_data_t* settings, obs_encoder_t* encoder)
{
this->self = encoder;
auto encvideo = obs_encoder_video(this->self);
auto voi = video_output_get_info(encvideo);
// Options, Parameters, etc.
/// Resolution, Frame Rate
this->resolution.first = voi->width;
this->resolution.second = voi->height;
this->framerate.first = voi->fps_num;
this->framerate.second = voi->fps_den;
/// Source/Input
this->source_colorspace = ffmpeg::tools::obs_videocolorspace_to_avcolorspace(voi->colorspace);
this->source_range = ffmpeg::tools::obs_videorangetype_to_avcolorrange(voi->range);
this->source_format = ffmpeg::tools::obs_videoformat_to_avpixelformat(voi->format);
/// Target/Output
this->target_colorspace = this->source_colorspace;
this->target_range = this->source_range;
switch (voi->format) {
case VIDEO_FORMAT_RGBA:
case VIDEO_FORMAT_BGRA:
case VIDEO_FORMAT_BGRX:
this->target_format = AV_PIX_FMT_YUV444P10;
this->video_profile = profile::FourFourFourFour;
break;
case VIDEO_FORMAT_I444:
case VIDEO_FORMAT_YVYU:
case VIDEO_FORMAT_YUY2:
case VIDEO_FORMAT_UYVY:
case VIDEO_FORMAT_I420:
case VIDEO_FORMAT_NV12:
this->video_profile = static_cast<profile>(obs_data_get_int(settings, T_PROFILE));
if (this->video_profile == profile::FourFourFourFour) {
this->target_format = AV_PIX_FMT_YUV444P10;
} else {
this->target_format = AV_PIX_FMT_YUV422P10;
}
break;
}
// Log Settings
PLOG_INFO(LOG_PREFIX
"Initializing encoder...\n\tResolution: %lux%lu\n\tFramerate: %lu/%lu (%.2lf fps)\n\tInput: %s %s "
"%s\n\tOutput: %s %s %s\n\tProfile: %ld",
this->resolution.first, this->resolution.second, this->framerate.first, this->framerate.second,
(double_t(this->framerate.first) / double_t(this->framerate.second)),
ffmpeg::tools::get_pixel_format_name(this->source_format),
ffmpeg::tools::get_color_space_name(this->source_colorspace),
swscale.is_source_full_range() ? "Full" : "Partial",
ffmpeg::tools::get_pixel_format_name(this->target_format),
ffmpeg::tools::get_color_space_name(this->target_colorspace),
swscale.is_target_full_range() ? "Full" : "Partial", static_cast<int>(this->video_profile));
// prores_aw restriction
if (this->resolution.first % 2 == 1) {
PLOG_ERROR(LOG_PREFIX "Width must be a multiple of 2.");
throw std::exception();
}
// Quit if we for some reason can't find prores_aw anymore.
this->avcodec = avcodec_find_encoder_by_name("prores_aw");
if (!this->avcodec) {
PLOG_ERROR(LOG_PREFIX "Failed to find encoder.");
throw std::exception();
}
this->avcontext = avcodec_alloc_context3(this->avcodec);
if (!this->avcontext) {
PLOG_ERROR(LOG_PREFIX "Failed to create context.");
throw std::exception();
}
// Apply Settings
/// Resolution
this->avcontext->width = this->resolution.first;
this->avcontext->height = this->resolution.second;
/// Framerate
this->avcontext->time_base.num = this->framerate.first;
this->avcontext->time_base.den = this->framerate.second;
this->avcontext->ticks_per_frame = 1;
/// GOP/Keyframe (ProRes is Intra only)
this->avcontext->gop_size = 0;
/// Color, Profile
this->avcontext->colorspace = this->target_colorspace;
this->avcontext->color_range = this->target_range;
this->avcontext->pix_fmt = this->target_format;
this->avcontext->profile = static_cast<int>(this->video_profile);
/// Other
this->avcontext->field_order = AV_FIELD_PROGRESSIVE;
this->avcontext->strict_std_compliance = FF_COMPLIANCE_NORMAL;
this->avcontext->debug = 0;
/// Threading
this->avcontext->thread_type = FF_THREAD_FRAME;
#if defined(__cplusplus)
this->avcontext->thread_count = std::thread::hardware_concurrency();
#elif defined(_WIN32)
{
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
this->avcontext->thread_count = sysinfo.dwNumberOfProcessors;
}
#elif defined(_GNU)
this->avcontext->thread_count = 16;
#else
this->avcontext->thread_count = 16;
#endif
/// Dynamic Stuff
this->update(settings);
// Open Encoder
int res = avcodec_open2(this->avcontext, this->avcodec, NULL);
if (res < 0) {
avcodec_free_context(&this->avcontext);
PLOG_ERROR(LOG_PREFIX "Failed to open codec: %s (%ld).", ffmpeg::tools::get_error_description(res),
res);
throw std::exception();
}
// Configure and initialize SWScale
swscale.set_source_size(voi->width, voi->height);
swscale.set_source_format(this->source_format);
swscale.set_source_color(this->source_range == AVCOL_RANGE_JPEG, this->source_colorspace);
swscale.set_target_size(voi->width, voi->height);
swscale.set_target_format(this->target_format);
swscale.set_target_color(this->target_range == AVCOL_RANGE_JPEG, this->target_colorspace);
if (!swscale.initialize(SWS_FAST_BILINEAR)) {
PLOG_ERROR(LOG_PREFIX "Incompatible conversion parameters:\n\tInput: %s %s %s\n\tOutput: %s %s %s",
ffmpeg::tools::get_pixel_format_name(this->source_format),
ffmpeg::tools::get_color_space_name(this->source_colorspace),
swscale.is_source_full_range() ? "Full" : "Partial",
ffmpeg::tools::get_pixel_format_name(this->target_format),
ffmpeg::tools::get_color_space_name(this->target_colorspace),
swscale.is_target_full_range() ? "Full" : "Partial");
throw std::exception();
}
frame_queue.set_pixel_format(this->avcontext->pix_fmt);
frame_queue.set_resolution(this->resolution.first, this->resolution.second);
frame_queue.precache(this->avcontext->thread_count / 2);
this->current_packet = av_packet_alloc();
if (!this->current_packet) {
PLOG_ERROR(LOG_PREFIX "Failed to allocated packet.");
throw std::exception();
}
PLOG_INFO(LOG_PREFIX "Encoder initialized.");
}
obsffmpeg::encoder::prores_aw::~prores_aw()
{
frame_queue.clear();
swscale.finalize();
if (this->avcontext) {
avcodec_close(this->avcontext);
avcodec_free_context(&this->avcontext);
}
}
void obsffmpeg::encoder::prores_aw::get_properties(obs_properties_t* props) {}
bool obsffmpeg::encoder::prores_aw::update(obs_data_t* settings)
{
return false;
}
bool obsffmpeg::encoder::prores_aw::get_extra_data(uint8_t** extra_data, size_t* size)
{
if (!this->avcontext->extradata) {
return false;
}
*extra_data = this->avcontext->extradata;
*size = this->avcontext->extradata_size;
return true;
}
bool obsffmpeg::encoder::prores_aw::get_sei_data(uint8_t** sei_data, size_t* size)
{
return false;
}
void obsffmpeg::encoder::prores_aw::get_video_info(video_scale_info* info)
{
return;
}
bool obsffmpeg::encoder::prores_aw::encode(encoder_frame* frame, encoder_packet* packet, bool* received_packet)
{
int res = 0;
{
ScopeProfiler sp_frame("frame");
AVFrame* vframe = frame_queue.pop();
vframe->pts = frame->pts;
vframe->color_range = this->avcontext->color_range;
vframe->colorspace = this->avcontext->colorspace;
{
ScopeProfiler profile("convert");
res = swscale.convert(reinterpret_cast<uint8_t**>(frame->data),
reinterpret_cast<int*>(frame->linesize), 0, this->resolution.second,
vframe->data, vframe->linesize);
if (res <= 0) {
PLOG_ERROR(LOG_PREFIX "Failed to convert frame: %s (%ld).",
ffmpeg::tools::get_error_description(res), res);
return false;
}
}
{
ScopeProfiler profile("send");
res = avcodec_send_frame(this->avcontext, vframe);
if (res < 0) {
PLOG_ERROR(LOG_PREFIX "Failed to encode frame: %s (%ld).",
ffmpeg::tools::get_error_description(res), res);
return false;
}
}
frame_queue_used.push(vframe);
}
{
ScopeProfiler profile("receive");
res = avcodec_receive_packet(this->avcontext, this->current_packet);
if (res < 0) {
if (res == AVERROR(EAGAIN)) {
*received_packet = false;
return true;
} else if (res == AVERROR(EOF)) {
return true;
} else {
PLOG_ERROR(LOG_PREFIX "Failed to receive packet: %s (%ld).",
ffmpeg::tools::get_error_description(res), res);
return false;
}
} else {
AVFrame* uframe = frame_queue_used.pop_only();
if (uframe) {
if (frame_queue.empty()) {
frame_queue.push(uframe);
} else {
av_frame_free(&uframe);
}
}
packet->type = OBS_ENCODER_VIDEO;
packet->pts = this->current_packet->pts;
packet->dts = this->current_packet->pts;
packet->data = this->current_packet->data;
packet->size = this->current_packet->size;
packet->keyframe = true; // There are only keyframes in ProRes (Intra Only)
packet->drop_priority = 0;
*received_packet = true;
}
}
return true;
}
source/encoders/prores_aw.hpp
+80
View File
@@ -0,0 +1,80 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef OBS_FFMPEG_ENCODER_PRORES_AW
#define OBS_FFMPEG_ENCODER_PRORES_AW
#pragma once
#include <encoder.hpp>
#include "ffmpeg/avframe-queue.hpp"
#include <vector>
extern "C" {
#include <libavcodec/avcodec.h>
}
namespace obsffmpeg {
namespace encoder {
class prores_aw : base {
enum class profile {
Auto = FF_PROFILE_UNKNOWN,
Proxy = 0 /*FF_PROFILE_PRORES_PROXY*/,
Light = 1 /*FF_PROFILE_PRORES_LT*/,
Standard = 2 /*FF_PROFILE_PRORES_STANDARD*/,
HighQuality = 3 /*FF_PROFILE_PRORES_HQ*/,
FourFourFourFour = 4 /*FF_PROFILE_PRORES_4444*/ // Automatically set if I444 or RGB input.
};
private:
profile video_profile = profile::Auto;
ffmpeg::avframe_queue frame_queue;
ffmpeg::avframe_queue frame_queue_used;
AVPacket* current_packet = nullptr;
public:
prores_aw(obs_data_t* settings, obs_encoder_t* encoder);
~prores_aw();
virtual void get_properties(obs_properties_t* props) override;
virtual bool update(obs_data_t* settings) override;
virtual bool get_extra_data(uint8_t** extra_data, size_t* size) override;
virtual bool get_sei_data(uint8_t** sei_data, size_t* size) override;
virtual void get_video_info(video_scale_info* info) override;
virtual bool encode(encoder_frame* frame, encoder_packet* packet,
bool* received_packet) override;
public:
static void initialize();
static void finalize();
static void get_defaults(obs_data_t* settings);
static obs_properties_t* get_properties();
};
} // namespace encoder
} // namespace obsffmpeg
#endif OBS_FFMPEG_ENCODER_PRORES_AW
source/ffmpeg/avframe-queue.cpp
+151
View File
@@ -0,0 +1,151 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#include "avframe-queue.hpp"
#include "tools.hpp"
AVFrame* ffmpeg::avframe_queue::create_frame()
{
AVFrame* frame = av_frame_alloc();
frame->width = this->resolution.first;
frame->height = this->resolution.second;
frame->format = this->format;
int res = av_frame_get_buffer(frame, 0);
if (res < 0) {
throw std::exception(ffmpeg::tools::get_error_description(res));
}
return frame;
}
void ffmpeg::avframe_queue::destroy_frame(AVFrame* frame)
{
if (frame == nullptr)
return;
av_frame_free(&frame);
}
ffmpeg::avframe_queue::avframe_queue() {}
ffmpeg::avframe_queue::~avframe_queue()
{
clear();
}
void ffmpeg::avframe_queue::set_resolution(uint32_t width, uint32_t height)
{
this->resolution.first = width;
this->resolution.second = height;
}
void ffmpeg::avframe_queue::get_resolution(uint32_t& width, uint32_t& height)
{
width = this->resolution.first;
height = this->resolution.second;
}
uint32_t ffmpeg::avframe_queue::get_width()
{
return this->resolution.first;
}
uint32_t ffmpeg::avframe_queue::get_height()
{
return this->resolution.second;
}
void ffmpeg::avframe_queue::set_pixel_format(AVPixelFormat format)
{
this->format = format;
}
AVPixelFormat ffmpeg::avframe_queue::get_pixel_format()
{
return this->format;
}
void ffmpeg::avframe_queue::precache(size_t count)
{
for (size_t n = 0; n < count; n++) {
push(create_frame());
}
}
void ffmpeg::avframe_queue::clear()
{
std::unique_lock<std::mutex> ulock(this->lock);
for (AVFrame* frame : frames) {
destroy_frame(frame);
}
frames.clear();
}
void ffmpeg::avframe_queue::push(AVFrame* frame)
{
std::unique_lock<std::mutex> ulock(this->lock);
frames.push_back(frame);
}
AVFrame* ffmpeg::avframe_queue::pop()
{
std::unique_lock<std::mutex> ulock(this->lock);
AVFrame* ret = nullptr;
while (ret == nullptr) {
if (frames.size() == 0) {
ret = create_frame();
} else {
ret = frames.front();
if (ret == nullptr) {
ret = create_frame();
} else {
frames.pop_front();
if ((ret->width != this->resolution.first) || (ret->height != this->resolution.second)
|| (ret->format != this->format)) {
destroy_frame(ret);
ret = nullptr;
}
}
}
}
return ret;
}
AVFrame* ffmpeg::avframe_queue::pop_only()
{
std::unique_lock<std::mutex> ulock(this->lock);
if (frames.size() == 0) {
return nullptr;
}
AVFrame* ret = frames.front();
if (ret == nullptr) {
return nullptr;
}
frames.pop_front();
return ret;
}
bool ffmpeg::avframe_queue::empty()
{
return frames.empty();
}
size_t ffmpeg::avframe_queue::size()
{
return frames.size();
}
source/ffmpeg/avframe-queue.hpp
+70
View File
@@ -0,0 +1,70 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef OBS_FFMPEG_FFMPEG_AVFRAME_QUEUE
#define OBS_FFMPEG_FFMPEG_AVFRAME_QUEUE
#pragma once
#include <mutex>
#include <deque>
extern "C" {
#include <libavutil/frame.h>
}
namespace ffmpeg {
class avframe_queue {
std::deque<AVFrame*> frames;
std::mutex lock;
std::pair<uint32_t, uint32_t> resolution;
AVPixelFormat format = AV_PIX_FMT_NONE;
AVFrame* create_frame();
void destroy_frame(AVFrame* frame);
public:
avframe_queue();
~avframe_queue();
void set_resolution(uint32_t width, uint32_t height);
void get_resolution(uint32_t& width, uint32_t& height);
uint32_t get_width();
uint32_t get_height();
void set_pixel_format(AVPixelFormat format);
AVPixelFormat get_pixel_format();
void precache(size_t count);
void clear();
void push(AVFrame* frame);
AVFrame* pop();
AVFrame* pop_only();
bool empty();
size_t size();
};
} // namespace ffmpeg
#endif OBS_FFMPEG_FFMPEG_AVFRAME_QUEUE
source/ffmpeg/swscale.cpp
+196
View File
@@ -0,0 +1,196 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#include "swscale.hpp"
#include <stdexcept>
ffmpeg::swscale::swscale() {}
ffmpeg::swscale::~swscale()
{
finalize();
}
void ffmpeg::swscale::set_source_size(uint32_t width, uint32_t height)
{
source_size.first = width;
source_size.second = height;
}
void ffmpeg::swscale::get_source_size(uint32_t& width, uint32_t& height)
{
width = this->source_size.first;
height = this->source_size.second;
}
std::pair<uint32_t, uint32_t> ffmpeg::swscale::get_source_size()
{
return this->source_size;
}
uint32_t ffmpeg::swscale::get_source_width()
{
return this->source_size.first;
}
uint32_t ffmpeg::swscale::get_source_height()
{
return this->source_size.second;
}
void ffmpeg::swscale::set_source_format(AVPixelFormat format)
{
source_format = format;
}
AVPixelFormat ffmpeg::swscale::get_source_format()
{
return this->source_format;
}
void ffmpeg::swscale::set_source_color(bool full_range, AVColorSpace space)
{
source_full_range = full_range;
source_colorspace = space;
}
void ffmpeg::swscale::set_source_colorspace(AVColorSpace space)
{
this->source_colorspace = space;
}
AVColorSpace ffmpeg::swscale::get_source_colorspace()
{
return this->source_colorspace;
}
void ffmpeg::swscale::set_source_full_range(bool full_range)
{
this->source_full_range = full_range;
}
bool ffmpeg::swscale::is_source_full_range()
{
return this->source_full_range;
}
void ffmpeg::swscale::set_target_size(uint32_t width, uint32_t height)
{
target_size.first = width;
target_size.second = height;
}
void ffmpeg::swscale::get_target_size(uint32_t& width, uint32_t& height) {}
std::pair<uint32_t, uint32_t> ffmpeg::swscale::get_target_size()
{
return this->target_size;
}
uint32_t ffmpeg::swscale::get_target_width()
{
return this->target_size.first;
}
uint32_t ffmpeg::swscale::get_target_height()
{
return this->target_size.second;
}
void ffmpeg::swscale::set_target_format(AVPixelFormat format)
{
target_format = format;
}
AVPixelFormat ffmpeg::swscale::get_target_format()
{
return this->target_format;
}
void ffmpeg::swscale::set_target_color(bool full_range, AVColorSpace space)
{
target_full_range = full_range;
target_colorspace = space;
}
void ffmpeg::swscale::set_target_colorspace(AVColorSpace space)
{
this->target_colorspace = space;
}
AVColorSpace ffmpeg::swscale::get_target_colorspace()
{
return this->target_colorspace;
}
void ffmpeg::swscale::set_target_full_range(bool full_range)
{
this->target_full_range = full_range;
}
bool ffmpeg::swscale::is_target_full_range()
{
return this->target_full_range;
}
bool ffmpeg::swscale::initialize(int flags)
{
if (this->context) {
return false;
}
if (source_size.first == 0 || source_size.second == 0 || source_format == AV_PIX_FMT_NONE
|| source_colorspace == AVCOL_SPC_UNSPECIFIED) {
throw std::invalid_argument("not all source parameters were set");
}
if (target_size.first == 0 || target_size.second == 0 || target_format == AV_PIX_FMT_NONE
|| target_colorspace == AVCOL_SPC_UNSPECIFIED) {
throw std::invalid_argument("not all target parameters were set");
}
this->context = sws_getContext(source_size.first, source_size.second, source_format, target_size.first,
target_size.second, target_format, flags, nullptr, nullptr, nullptr);
if (!this->context) {
return false;
}
sws_setColorspaceDetails(this->context, sws_getCoefficients(source_colorspace), source_full_range ? 1 : 0,
sws_getCoefficients(target_colorspace), target_full_range ? 1 : 0, 1l << 16 | 0l,
1l << 16 | 0l, 1l << 16 | 0l);
return true;
}
bool ffmpeg::swscale::finalize()
{
if (this->context) {
sws_freeContext(this->context);
this->context = nullptr;
return true;
}
return false;
}
int32_t ffmpeg::swscale::convert(const uint8_t* const source_data[], const int source_stride[], int32_t source_row,
int32_t source_rows, uint8_t* const target_data[], const int target_stride[])
{
if (!this->context) {
return 0;
}
int height =
sws_scale(this->context, source_data, source_stride, source_row, source_rows, target_data, target_stride);
return height;
}
source/ffmpeg/swscale.hpp
+82
View File
@@ -0,0 +1,82 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef OBS_FFMPEG_FFMPEG_SWSCALE
#define OBS_FFMPEG_FFMPEG_SWSCALE
#pragma once
#include <cinttypes>
#include <utility>
extern "C" {
#include <libavutil/pixfmt.h>
#include <libswscale/swscale.h>
}
namespace ffmpeg {
class swscale {
std::pair<uint32_t, uint32_t> source_size;
AVPixelFormat source_format = AV_PIX_FMT_NONE;
bool source_full_range = false;
AVColorSpace source_colorspace = AVCOL_SPC_UNSPECIFIED;
std::pair<uint32_t, uint32_t> target_size;
AVPixelFormat target_format = AV_PIX_FMT_NONE;
bool target_full_range = false;
AVColorSpace target_colorspace = AVCOL_SPC_UNSPECIFIED;
SwsContext* context = nullptr;
public:
swscale();
~swscale();
void set_source_size(uint32_t width, uint32_t height);
void get_source_size(uint32_t& width, uint32_t& height);
std::pair<uint32_t, uint32_t> get_source_size();
uint32_t get_source_width();
uint32_t get_source_height();
void set_source_format(AVPixelFormat format);
AVPixelFormat get_source_format();
void set_source_color(bool full_range, AVColorSpace space);
void set_source_colorspace(AVColorSpace space);
AVColorSpace get_source_colorspace();
void set_source_full_range(bool full_range);
bool is_source_full_range();
void set_target_size(uint32_t width, uint32_t height);
void get_target_size(uint32_t& width, uint32_t& height);
std::pair<uint32_t, uint32_t> get_target_size();
uint32_t get_target_width();
uint32_t get_target_height();
void set_target_format(AVPixelFormat format);
AVPixelFormat get_target_format();
void set_target_color(bool full_range, AVColorSpace space);
void set_target_colorspace(AVColorSpace space);
AVColorSpace get_target_colorspace();
void set_target_full_range(bool full_range);
bool is_target_full_range();
bool initialize(int flags);
bool finalize();
int32_t convert(const uint8_t* const source_data[], const int source_stride[], int32_t source_row,
int32_t source_rows, uint8_t* const target_data[], const int target_stride[]);
};
} // namespace ffmpeg
#endif OBS_FFMPEG_FFMPEG_SWSCALE
source/ffmpeg/tools.cpp
+126
View File
@@ -0,0 +1,126 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#include "tools.hpp"
#include <stdexcept>
extern "C" {
#include <libavutil/error.h>
#include <libavutil/pixdesc.h>
}
const char* ffmpeg::tools::get_pixel_format_name(AVPixelFormat v)
{
return av_get_pix_fmt_name(v);
}
const char* ffmpeg::tools::get_color_space_name(AVColorSpace v)
{
switch (v) {
case AVCOL_SPC_RGB:
return "RGB";
case AVCOL_SPC_BT709:
return "BT.709";
case AVCOL_SPC_FCC:
return "FCC Title 47 CoFR 73.682 (a)(20)";
case AVCOL_SPC_BT470BG:
return "BT.601 625";
case AVCOL_SPC_SMPTE170M:
case AVCOL_SPC_SMPTE240M:
return "BT.601 525";
case AVCOL_SPC_YCGCO:
return "ITU-T SG16";
case AVCOL_SPC_BT2020_NCL:
return "BT.2020 NCL";
case AVCOL_SPC_BT2020_CL:
return "BT.2020 CL";
case AVCOL_SPC_SMPTE2085:
return "SMPTE 2085";
case AVCOL_SPC_CHROMA_DERIVED_NCL:
return "Chroma NCL";
case AVCOL_SPC_CHROMA_DERIVED_CL:
return "Chroma CL";
case AVCOL_SPC_ICTCP:
return "BT.2100";
case AVCOL_SPC_NB:
return "Not Part of ABI";
}
return "Unknown";
}
const char* ffmpeg::tools::get_error_description(int error)
{
switch (error) {
case AVERROR(EPERM):
return "Permission Denied";
case AVERROR(ENOMEM):
return "Out Of Memory";
case AVERROR(EINVAL):
return "Invalid Value for Parameter";
}
return "Not Translated Yet";
}
AVPixelFormat ffmpeg::tools::obs_videoformat_to_avpixelformat(video_format v)
{
switch (v) {
// 32-Bits
case VIDEO_FORMAT_BGRX:
return AV_PIX_FMT_BGRA;
case VIDEO_FORMAT_BGRA:
return AV_PIX_FMT_BGRA;
case VIDEO_FORMAT_RGBA:
return AV_PIX_FMT_RGBA;
case VIDEO_FORMAT_I444:
return AV_PIX_FMT_YUV444P;
case VIDEO_FORMAT_YUY2:
return AV_PIX_FMT_YUYV422;
case VIDEO_FORMAT_YVYU:
return AV_PIX_FMT_YVYU422;
case VIDEO_FORMAT_UYVY:
return AV_PIX_FMT_UYVY422;
case VIDEO_FORMAT_I420:
return AV_PIX_FMT_YUV420P;
case VIDEO_FORMAT_NV12:
return AV_PIX_FMT_NV12;
}
throw std::invalid_argument("unknown format");
}
AVColorSpace ffmpeg::tools::obs_videocolorspace_to_avcolorspace(video_colorspace v)
{
switch (v) {
case VIDEO_CS_DEFAULT:
case VIDEO_CS_709:
return AVCOL_SPC_BT709;
case VIDEO_CS_601:
return AVCOL_SPC_SMPTE170M;
}
throw std::invalid_argument("unknown color space");
}
AVColorRange ffmpeg::tools::obs_videorangetype_to_avcolorrange(video_range_type v)
{
switch (v) {
case VIDEO_RANGE_DEFAULT:
case VIDEO_RANGE_FULL:
return AVCOL_RANGE_JPEG;
case VIDEO_RANGE_PARTIAL:
return AVCOL_RANGE_MPEG;
}
throw std::invalid_argument("unknown range");
}
source/ffmpeg/tools.hpp
+44
View File
@@ -0,0 +1,44 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef OBS_FFMPEG_FFMPEG_UTILITY
#define OBS_FFMPEG_FFMPEG_UTILITY
#pragma once
#include <obs.h>
extern "C" {
#include <libavutil/pixfmt.h>
}
namespace ffmpeg {
namespace tools {
const char* get_pixel_format_name(AVPixelFormat v);
const char* get_color_space_name(AVColorSpace v);
const char* get_error_description(int error);
AVPixelFormat obs_videoformat_to_avpixelformat(video_format v);
AVColorSpace obs_videocolorspace_to_avcolorspace(video_colorspace v);
AVColorRange obs_videorangetype_to_avcolorrange(video_range_type v);
}
} // namespace ffmpeg
#endif OBS_FFMPEG_FFMPEG_UTILITY
source/plugin.cpp
+55
View File
@@ -0,0 +1,55 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#include "plugin.hpp"
#include <obs-module.h>
#include <obs.h>
#include "utility.hpp"
#include "encoders/prores_aw.hpp"
extern "C" {
#pragma warning(push)
#pragma warning(disable : 4244)
#include <libavcodec/avcodec.h>
#pragma warning(pop)
}
MODULE_EXPORT bool obs_module_load(void)
{
try {
avcodec_register_all();
obsffmpeg::encoder::prores_aw::initialize();
return true;
} catch (std::exception ex) {
PLOG_ERROR("Exception during initalization: %s.", ex.what());
} catch (...) {
PLOG_ERROR("Unrecognized exception during initalization.");
}
return false;
}
MODULE_EXPORT void obs_module_unload(void)
{
try {
obsffmpeg::encoder::prores_aw::finalize();
} catch (std::exception ex) {
PLOG_ERROR("Exception during finalizing: %s.", ex.what());
} catch (...) {
PLOG_ERROR("Unrecognized exception during finalizing.");
}
}
source/plugin.hpp
+30
View File
@@ -0,0 +1,30 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef OBS_FFMPEG_PLUGIN_HPP
#define OBS_FFMPEG_PLUGIN_HPP
#pragma once
#include <functional>
#include <list>
namespace obsffmpeg {
} // namespace obsffmpeg
#endif OBS_FFMPEG_PLUGIN_HPP
source/utility.cpp
View File
source/utility.hpp
+48
View File
@@ -0,0 +1,48 @@
// FFMPEG Video Encoder Integration for OBS Studio
// Copyright (C) 2018 - 2018 Michael Fabian Dirks
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#ifndef OBS_FFMPEG_UTILITY_HPP
#define OBS_FFMPEG_UTILITY_HPP
#pragma once
#include "version.hpp"
// Logging
#define PLOG(level, ...) blog(level, "["##PROJECT_NAME##"] " __VA_ARGS__);
#define PLOG_ERROR(...) PLOG(LOG_ERROR, __VA_ARGS__)
#define PLOG_WARNING(...) PLOG(LOG_WARNING, __VA_ARGS__)
#define PLOG_INFO(...) PLOG(LOG_INFO, __VA_ARGS__)
#define PLOG_DEBUG(...) PLOG(LOG_DEBUG, __VA_ARGS__)
// Function Name
#ifndef __FUNCTION_NAME__
#if defined(_WIN32) || defined(_WIN64) //WINDOWS
#define __FUNCTION_NAME__ __FUNCTION__
#else //*NIX
#define __FUNCTION_NAME__ __func__
#endif
#endif
// I18n
#define TRANSLATE(x) obs_module_text(x)
#define DESC(x) x ".Description"
// Other
#define vstr(s) dstr(s)
#define dstr(s) #s
#endif OBS_FFMPEG_UTILITY_HPP