oak-team/oak-editor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

various changes to rendering flow and structure

Browse Source
This commit is contained in:
itsmattkc
2019-10-23 00:42:52 +11:00
parent 5f86b9b9c7
commit 7dec79ceaa
42 changed files with 663 additions and 888 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/render/CMakeLists.txt
+2
View File
@@ -35,5 +35,7 @@ set(OLIVE_SOURCES
render/renderframebuffer.cpp
render/rendertexture.h
render/rendertexture.cpp
render/videoparams.h
render/videoparams.cpp
PARENT_SCOPE
)
app/render/audio/CMakeLists.txt
+2
View File
@@ -16,6 +16,8 @@
set(OLIVE_SOURCES
${OLIVE_SOURCES}
render/audio/audioparams.h
render/audio/audioparams.cpp
render/audio/audiorenderer.h
render/audio/audiorenderer.cpp
render/audio/audiorendererdownloadthread.h
app/render/audio/audioparams.cpp
+89
View File
@@ -0,0 +1,89 @@
#include "audioparams.h"
extern "C" {
#include <libavformat/avformat.h>
}
AudioParams::AudioParams() :
sample_rate_(0),
channel_layout_(0)
{
}
AudioParams::AudioParams(const int &sample_rate, const uint64_t &channel_layout) :
sample_rate_(sample_rate),
channel_layout_(channel_layout)
{
}
const int &AudioParams::sample_rate() const
{
return sample_rate_;
}
const uint64_t &AudioParams::channel_layout() const
{
return channel_layout_;
}
AudioRenderingParams::AudioRenderingParams() :
format_(olive::SAMPLE_FMT_INVALID)
{
}
AudioRenderingParams::AudioRenderingParams(const int &sample_rate, const uint64_t &channel_layout, const olive::SampleFormat &format) :
AudioParams(sample_rate, channel_layout),
format_(format)
{
}
AudioRenderingParams::AudioRenderingParams(const AudioParams &params, const olive::SampleFormat &format) :
AudioParams(params),
format_(format)
{
}
const olive::SampleFormat &AudioRenderingParams::format() const
{
return format_;
}
int AudioRenderingParams::time_to_bytes(const rational &time) const
{
Q_ASSERT(is_valid());
return qFloor(time.toDouble() * sample_rate()) * channel_count() * sample_size();
}
int AudioRenderingParams::channel_count() const
{
return av_get_channel_layout_nb_channels(channel_layout());
}
int AudioRenderingParams::sample_size() const
{
switch (format_) {
case olive::SAMPLE_FMT_U8:
return 1;
case olive::SAMPLE_FMT_S16:
return 2;
case olive::SAMPLE_FMT_S32:
case olive::SAMPLE_FMT_FLT:
return 4;
case olive::SAMPLE_FMT_DBL:
return 8;
case olive::SAMPLE_FMT_INVALID:
case olive::SAMPLE_FMT_COUNT:
break;
}
return 0;
}
bool AudioRenderingParams::is_valid() const
{
return (sample_rate() > 0
&& channel_layout() > 0
&& format_ != olive::SAMPLE_FMT_INVALID
&& format_ != olive::SAMPLE_FMT_COUNT);
}
app/render/audio/audioparams.h
+42
View File
@@ -0,0 +1,42 @@
#ifndef AUDIOPARAMS_H
#define AUDIOPARAMS_H
#include <QtMath>
#include "audio/sampleformat.h"
#include "common/rational.h"
class AudioParams
{
public:
AudioParams();
AudioParams(const int& sample_rate, const uint64_t& channel_layout);
const int& sample_rate() const;
const uint64_t& channel_layout() const;
private:
int sample_rate_;
uint64_t channel_layout_;
};
class AudioRenderingParams : public AudioParams {
public:
AudioRenderingParams();
AudioRenderingParams(const int& sample_rate, const uint64_t& channel_layout, const olive::SampleFormat& format);
AudioRenderingParams(const AudioParams& params, const olive::SampleFormat& format);
int time_to_bytes(const rational& time) const;
int channel_count() const;
int sample_size() const;
bool is_valid() const;
const olive::SampleFormat& format() const;
private:
olive::SampleFormat format_;
};
#endif // AUDIOPARAMS_H
app/render/audio/audiorenderer.cpp
+58 -288
View File
@@ -36,11 +36,7 @@
AudioRendererProcessor::AudioRendererProcessor(QObject *parent) :
QObject(parent),
started_(false),
width_(0),
height_(0),
divider_(1),
caching_(false),
push_time_(-1),
starting_(false),
viewer_node_(nullptr)
{
@@ -63,10 +59,6 @@ void AudioRendererProcessor::SetCacheName(const QString &s)
void AudioRendererProcessor::InvalidateCache(const rational &start_range, const rational &end_range)
{
if (timebase_.isNull()) {
return;
}
// Adjust range to min/max values
rational start_range_adj = qMax(rational(0), start_range);
rational end_range_adj = qMin(viewer_node_->Length(), end_range);
@@ -76,101 +68,45 @@ void AudioRendererProcessor::InvalidateCache(const rational &start_range, const
<< "and"
<< end_range_adj.toDouble();
// Snap start_range to timebase
double start_range_dbl = start_range_adj.toDouble();
double start_range_numf = start_range_dbl * static_cast<double>(timebase_.denominator());
int64_t start_range_numround = qFloor(start_range_numf/static_cast<double>(timebase_.numerator())) * timebase_.numerator();
rational true_start_range(start_range_numround, timebase_.denominator());
bool append = true;
for (rational r=true_start_range;r<=end_range_adj;r+=timebase_) {
// Try to order the queue from closest to the playhead to furthest
rational last_time = last_time_requested_;
for (int i=0;i<cache_queue_.size();i++) {
const TimeRange& const_range = cache_queue_.at(i);
rational diff = r - last_time;
if (diff < 0) {
// FIXME: Hardcoded number
// If the number is before the playhead, we still prioritize its closeness but not nearly as much (5:1 in this
// example)
diff = qAbs(diff) * 5;
}
bool contains = false;
bool added = false;
QLinkedList<rational>::iterator insert_iterator;
for (QLinkedList<rational>::iterator i = cache_queue_.begin();i != cache_queue_.end();i++) {
rational compare = *i;
if (!added) {
rational compare_diff = compare - last_time;
if (compare_diff > diff) {
insert_iterator = i;
added = true;
}
if (start_range_adj >= const_range.in()
&& start_range_adj <= const_range.out()) {
append = false;
if (const_range.out() < end_range_adj) {
// Same in point but longer, extend
cache_queue_[i].set_out(end_range_adj);
}
if (compare == r) {
contains = true;
break;
break;
} else if (end_range_adj <= const_range.out()
&& end_range_adj >= const_range.in()) {
append = false;
if (const_range.in() > start_range_adj) {
// Same out point but longer, extend
cache_queue_[i].set_in(start_range_adj);
}
break;
}
}
if (!contains) {
if (added) {
cache_queue_.insert(insert_iterator, r);
} else {
cache_queue_.append(r);
}
}
if (append) {
cache_queue_.append(TimeRange(start_range_adj, end_range_adj));
}
CacheNext();
}
void AudioRendererProcessor::SetTimebase(const rational &timebase)
{
timebase_ = timebase;
timebase_dbl_ = timebase_.toDouble();
}
void AudioRendererProcessor::SetParameters(const int &width,
const int &height,
const olive::PixelFormat &format,
const olive::RenderMode &mode,
const int& divider)
void AudioRendererProcessor::SetParameters(const AudioRenderingParams& params)
{
// Since we're changing parameters, all the existing threads are invalid and must be removed. They will start again
// next time this Node has to process anything.
Stop();
// Set new parameters
width_ = width;
height_ = height;
format_ = format;
mode_ = mode;
// divider's default value is 0, so we can assume if it's 0 a divider wasn't specified
if (divider > 0) {
divider_ = divider;
}
CalculateEffectiveDimensions();
// Regenerate the cache ID
GenerateCacheIDInternal();
}
void AudioRendererProcessor::SetDivider(const int &divider)
{
Q_ASSERT(divider_ > 0);
Stop();
divider_ = divider;
CalculateEffectiveDimensions();
params_ = params;
// Regenerate the cache ID
GenerateCacheIDInternal();
@@ -193,7 +129,7 @@ void AudioRendererProcessor::Start()
threads_.resize(background_thread_count);
for (int i=0;i<threads_.size();i++) {
threads_[i] = std::make_shared<AudioRendererProcessThread>(this, ctx, effective_width_, effective_height_, divider_, format_, mode_);
threads_[i] = std::make_shared<AudioRendererProcessThread>(this, params_);
threads_[i]->StartThread(QThread::LowPriority);
// Ensure this connection is "Queued" so that it always runs in this object's threaded rather than any of the
@@ -207,46 +143,14 @@ void AudioRendererProcessor::Start()
// Connect first thread (master thread) to the callback
connect(threads_.first().get(),
SIGNAL(CachedFrame(RenderTexturePtr, const rational&, const QByteArray&)),
SIGNAL(CachedFrame(const QByteArray&, const rational&, const rational&)),
this,
SLOT(ThreadCallback(RenderTexturePtr, const rational&, const QByteArray&)),
SLOT(ThreadCallback(const QByteArray&, const rational&, const rational&)),
Qt::QueuedConnection);
connect(threads_.first().get(),
SIGNAL(FrameSkipped(const rational&, const QByteArray&)),
this,
SLOT(ThreadSkippedFrame(const rational&, const QByteArray&)),
Qt::QueuedConnection);
download_threads_.resize(background_thread_count);
for (int i=0;i<download_threads_.size();i++) {
// Create download thread
download_threads_[i] = std::make_shared<AudioRendererDownloadThread>(ctx, effective_width_, effective_height_, divider_, format_, mode_);
download_threads_[i]->StartThread(QThread::LowPriority);
connect(download_threads_[i].get(),
SIGNAL(Downloaded(const QByteArray&)),
this,
SLOT(DownloadThreadComplete(const QByteArray&)),
Qt::QueuedConnection);
}
last_download_thread_ = 0;
// Restore context now that thread creation is complete
ctx->makeCurrent(old_surface);
// Create master texture (the one sent to the viewer)
master_texture_ = std::make_shared<RenderTexture>();
master_texture_->Create(ctx, effective_width_, effective_height_, format_);
// Create internal FBO for copying textures
copy_buffer_.Create(ctx);
copy_buffer_.Attach(master_texture_);
copy_pipeline_ = olive::ShaderGenerator::DefaultPipeline();
cache_frame_load_buffer_.resize(PixelService::GetBufferSize(format_, effective_width_, effective_height_));
started_ = true;
}
@@ -258,26 +162,15 @@ void AudioRendererProcessor::Stop()
started_ = false;
foreach (AudioRendererDownloadThreadPtr download_thread_, download_threads_) {
download_thread_->Cancel();
}
download_threads_.clear();
foreach (AudioRendererProcessThreadPtr process_thread, threads_) {
process_thread->Cancel();
}
threads_.clear();
copy_buffer_.Destroy();
master_texture_ = nullptr;
copy_pipeline_ = nullptr;
cache_frame_load_buffer_.clear();
}
void AudioRendererProcessor::GenerateCacheIDInternal()
{
if (cache_name_.isEmpty() || effective_width_ == 0 || effective_height_ == 0) {
if (cache_name_.isEmpty() || !params_.is_valid()) {
return;
}
@@ -285,10 +178,9 @@ void AudioRendererProcessor::GenerateCacheIDInternal()
QCryptographicHash hash(QCryptographicHash::Sha1);
hash.addData(cache_name_.toUtf8());
hash.addData(QString::number(cache_time_).toUtf8());
hash.addData(QString::number(width_).toUtf8());
hash.addData(QString::number(height_).toUtf8());
hash.addData(QString::number(format_).toUtf8());
hash.addData(QString::number(divider_).toUtf8());
hash.addData(QString::number(params_.sample_rate()).toUtf8());
hash.addData(QString::number(params_.channel_layout()).toUtf8());
hash.addData(QString::number(params_.format()).toUtf8());
QByteArray bytes = hash.result();
cache_id_ = bytes.toHex();
@@ -303,9 +195,9 @@ void AudioRendererProcessor::CacheNext()
// Make sure cache has started
Start();
rational cache_frame = cache_queue_.takeFirst();
TimeRange cache_frame = cache_queue_.takeFirst();
qDebug() << "Caching" << cache_frame.toDouble();
qDebug() << "Caching" << cache_frame.in().toDouble() << "-" << cache_frame.out().toDouble();
threads_.first()->Queue(NodeDependency(viewer_node_->texture_input()->get_connected_output(), cache_frame), true, false);
@@ -317,90 +209,25 @@ QString AudioRendererProcessor::CachePathName(const QByteArray &hash)
QDir this_cache_dir = QDir(GetMediaCacheLocation()).filePath(cache_id_);
this_cache_dir.mkpath(".");
QString filename = QString("%1.exr").arg(QString(hash.toHex()));
QString filename = QString("%1.pcm").arg(QString(hash.toHex()));
return this_cache_dir.filePath(filename);
}
void AudioRendererProcessor::DeferMap(const rational &time, const QByteArray &hash)
{
deferred_maps_.append({time, hash});
}
bool AudioRendererProcessor::HasHash(const QByteArray &hash)
{
return QFileInfo::exists(CachePathName(hash));
}
bool AudioRendererProcessor::IsCaching(const QByteArray &hash)
{
cache_hash_list_mutex_.lock();
bool is_caching = cache_hash_list_.contains(hash);
cache_hash_list_mutex_.unlock();
return is_caching;
}
bool AudioRendererProcessor::TryCache(const QByteArray &hash)
{
cache_hash_list_mutex_.lock();
bool is_caching = cache_hash_list_.contains(hash);
if (!is_caching) {
cache_hash_list_.append(hash);
}
cache_hash_list_mutex_.unlock();
return !is_caching;
}
void AudioRendererProcessor::CalculateEffectiveDimensions()
{
effective_width_ = width_ / divider_;
effective_height_ = height_ / divider_;
}
void AudioRendererProcessor::ThreadCallback(RenderTexturePtr texture, const rational& time, const QByteArray& hash)
void AudioRendererProcessor::ThreadCallback(const QByteArray& samples, const rational& in, const rational& out)
{
// Threads are all done now, time to proceed
caching_ = false;
DeferMap(time, hash);
int start_offset = params_.time_to_bytes(in);
int end_offset = params_.time_to_bytes(out);
if (texture != nullptr) {
// We received a texture, time to start downloading it
QString fn = CachePathName(hash);
download_threads_[last_download_thread_%download_threads_.size()]->Queue(texture,
fn,
hash);
last_download_thread_++;
} else {
// There was no texture here, we must update the viewer
DownloadThreadComplete(hash);
// Ensure sample cache is at least large enough for this
if (sample_cache_.size() < end_offset) {
sample_cache_.resize(end_offset);
}
// If the connected output is using this time, signal it to update
if (last_time_requested_ == time) {
copy_buffer_.Bind();
texture->Bind();
QOpenGLContext::currentContext()->functions()->glViewport(0, 0, master_texture_->width(), master_texture_->height());
olive::gl::Blit(copy_pipeline_);
texture->Release();
copy_buffer_.Release();
push_time_ = time;
emit CachedFrameReady(time);
}
sample_cache_.replace(start_offset, samples.size(), samples);
CacheNext();
}
@@ -415,107 +242,53 @@ void AudioRendererProcessor::ThreadRequestSibling(NodeDependency dep)
}
}
void AudioRendererProcessor::ThreadSkippedFrame(const rational& time, const QByteArray& hash)
{
caching_ = false;
DeferMap(time, hash);
if (!IsCaching(hash)) {
DownloadThreadComplete(hash);
// Signal output to update value
emit CachedFrameReady(time);
}
CacheNext();
}
void AudioRendererProcessor::DownloadThreadComplete(const QByteArray &hash)
{
cache_hash_list_mutex_.lock();
cache_hash_list_.removeAll(hash);
cache_hash_list_mutex_.unlock();
for (int i=0;i<deferred_maps_.size();i++) {
const HashTimeMapping& deferred = deferred_maps_.at(i);
if (deferred_maps_.at(i).hash == hash) {
// Insert into hash map
time_hash_map_.insert(deferred.time, deferred.hash);
deferred_maps_.removeAt(i);
i--;
}
}
}
AudioRendererThreadBase* AudioRendererProcessor::CurrentThread()
{
return dynamic_cast<AudioRendererThreadBase*>(QThread::currentThread());
}
RenderInstance *AudioRendererProcessor::CurrentInstance()
AudioParams *AudioRendererProcessor::CurrentInstance()
{
AudioRendererThreadBase* thread = CurrentThread();
if (thread != nullptr) {
return thread->render_instance();
return thread->params();
}
return nullptr;
}
RenderTexturePtr AudioRendererProcessor::GetCachedFrame(const rational &time)
QByteArray AudioRendererProcessor::GetCachedSamples(const rational &in, const rational &out)
{
last_time_requested_ = time;
if (push_time_ >= 0) {
rational temp_push_time = push_time_;
push_time_ = -1;
if (time == temp_push_time) {
return master_texture_;
}
}
if (viewer_node_ == nullptr) {
if (viewer_node_ == nullptr || in == out) {
// Nothing is connected - nothing to show or render
return nullptr;
}
if (!params_.is_valid()) {
qWarning() << "Invalid parameters";
return nullptr;
}
if (cache_id_.isEmpty()) {
qWarning() << "RendererProcessor has no cache ID";
qWarning() << "No cache ID";
return nullptr;
}
if (timebase_.isNull()) {
qWarning() << "RendererProcessor has no timebase";
if (out < in || in < 0 || out < 0) {
qWarning() << "Invalid time requested";
return nullptr;
}
// Find frame in map
if (time_hash_map_.contains(time)) {
QString fn = CachePathName(time_hash_map_[time]);
int start_offset = qMin(params_.time_to_bytes(in), sample_cache_.size());
int end_offset = qMin(params_.time_to_bytes(out), sample_cache_.size());
int length = end_offset - start_offset;
if (QFileInfo::exists(fn)) {
auto in = OIIO::ImageInput::open(fn.toStdString());
if (in) {
in->read_image(PixelService::GetPixelFormatInfo(format_).oiio_desc, cache_frame_load_buffer_.data());
in->close();
master_texture_->Upload(cache_frame_load_buffer_.data());
return master_texture_;
} else {
qWarning() << "OIIO Error:" << OIIO::geterror().c_str();
}
}
if (length == 0) {
return nullptr;
}
return nullptr;
return sample_cache_.mid(start_offset, length);
}
void AudioRendererProcessor::SetViewerNode(ViewerOutput *viewer)
@@ -530,9 +303,6 @@ void AudioRendererProcessor::SetViewerNode(ViewerOutput *viewer)
connect(viewer_node_, SIGNAL(TextureChangedBetween(const rational&, const rational&)), this, SLOT(InvalidateCache(const rational&, const rational&)));
// FIXME: Hardcoded format and mode
SetParameters(viewer_node_->ViewerWidth(),
viewer_node_->ViewerHeight(),
olive::PIX_FMT_RGBA16F,
olive::kOffline);
AudioRenderingParams(viewer_node_->audio_params(), olive::SAMPLE_FMT_FLT);
}
}
app/render/audio/audiorenderer.h
+9 -78
View File
@@ -24,6 +24,7 @@
#include <QLinkedList>
#include <QOpenGLTexture>
#include "common/timerange.h"
#include "node/output/viewer/viewer.h"
#include "render/pixelformat.h"
#include "render/rendermodes.h"
@@ -49,8 +50,6 @@ public:
void SetCacheName(const QString& s);
void SetTimebase(const rational& timebase);
/**
* @brief Set parameters of the Renderer
*
@@ -69,28 +68,7 @@ public:
*
* Buffer pixel format
*/
void SetParameters(const int& width,
const int& height,
const olive::PixelFormat& format,
const olive::RenderMode& mode,
const int &divider = 0);
void SetDivider(const int& divider);
/**
* @brief Return whether a frame with this hash already exists
*/
bool HasHash(const QByteArray& hash);
/**
* @brief Return whether a frame is currently being cached
*/
bool IsCaching(const QByteArray& hash);
/**
* @brief Check if a frame is currently being cached, and if not reserve it
*/
bool TryCache(const QByteArray& hash);
void SetParameters(const AudioRenderingParams &params);
/**
* @brief Return current instance of a RenderThread (or nullptr if there is none)
@@ -100,21 +78,13 @@ public:
*/
static AudioRendererThreadBase* CurrentThread();
static RenderInstance* CurrentInstance();
static AudioParams* CurrentInstance();
RenderTexturePtr GetCachedFrame(const rational& time);
QByteArray GetCachedSamples(const rational& in, const rational& out);
void SetViewerNode(ViewerOutput* viewer);
signals:
void CachedFrameReady(const rational& time);
private:
struct HashTimeMapping {
rational time;
QByteArray hash;
};
/**
* @brief Allocate and start the multithreaded backend
*/
@@ -137,15 +107,11 @@ private:
*/
void CacheNext();
bool ShouldPushTexture(const rational &time);
/**
* @brief Return the path of the cached image at this time
*/
QString CachePathName(const QByteArray &hash);
void DeferMap(const rational &time, const QByteArray &hash);
/**
* @brief Internal list of RenderProcessThreads
*/
@@ -156,63 +122,28 @@ private:
*/
bool started_;
int width_;
int height_;
AudioRenderingParams params_;
void CalculateEffectiveDimensions();
int divider_;
int effective_width_;
int effective_height_;
olive::PixelFormat format_;
olive::RenderMode mode_;
rational last_time_requested_;
rational timebase_;
double timebase_dbl_;
QLinkedList<rational> cache_queue_;
QList<TimeRange> cache_queue_;
QString cache_name_;
qint64 cache_time_;
QString cache_id_;
bool caching_;
QVector<uchar*> cache_frame_load_buffer_;
QVector<AudioRendererDownloadThreadPtr> download_threads_;
int last_download_thread_;
RenderTexturePtr master_texture_;
rational push_time_;
RenderFramebuffer copy_buffer_;
ShaderPtr copy_pipeline_;
QMap<rational, QByteArray> time_hash_map_;
QMutex cache_hash_list_mutex_;
QVector<QByteArray> cache_hash_list_;
QList<HashTimeMapping> deferred_maps_;
bool starting_;
ViewerOutput* viewer_node_;
QByteArray sample_cache_;
private slots:
void InvalidateCache(const rational &start_range, const rational &end_range);
void ThreadCallback(RenderTexturePtr texture, const rational& time, const QByteArray& hash);
void ThreadCallback(const QByteArray& samples, const rational& in, const rational &out);
void ThreadRequestSibling(NodeDependency dep);
void ThreadSkippedFrame(const rational &time, const QByteArray &hash);
void DownloadThreadComplete(const QByteArray &hash);
};
#endif // AUDIORENDERER_H
app/render/audio/audiorendererdownloadthread.cpp
+2 -2
View File
@@ -7,7 +7,7 @@
#include "common/define.h"
#include "render/pixelservice.h"
AudioRendererDownloadThread::AudioRendererDownloadThread(QOpenGLContext *share_ctx,
/*AudioRendererDownloadThread::AudioRendererDownloadThread(QOpenGLContext *share_ctx,
const int &width,
const int &height,
const int &divider,
@@ -125,4 +125,4 @@ void AudioRendererDownloadThread::ProcessLoop()
}
f->glDeleteFramebuffers(1, &read_buffer_);
}
}*/
app/render/audio/audiorendererdownloadthread.h
+2 -2
View File
@@ -3,7 +3,7 @@
#include "audiorendererthreadbase.h"
class AudioRendererDownloadThread : public AudioRendererThreadBase
/*class AudioRendererDownloadThread : public AudioRendererThreadBase
{
Q_OBJECT
public:
@@ -44,6 +44,6 @@ private:
};
using AudioRendererDownloadThreadPtr = std::shared_ptr<AudioRendererDownloadThread>;
using AudioRendererDownloadThreadPtr = std::shared_ptr<AudioRendererDownloadThread>;*/
#endif // AUDIORENDERERDOWNLOADTHREAD_H
app/render/audio/audiorendererprocessthread.cpp
+12 -51
View File
@@ -23,13 +23,8 @@
#include "audiorenderer.h"
AudioRendererProcessThread::AudioRendererProcessThread(AudioRendererProcessor* parent,
QOpenGLContext *share_ctx,
const int &width,
const int &height,
const int &divider,
const olive::PixelFormat &format,
const olive::RenderMode &mode) :
AudioRendererThreadBase(share_ctx, width, height, divider, format, mode),
const AudioRenderingParams &params) :
AudioRendererThreadBase(params),
parent_(parent),
cancelled_(false)
{
@@ -93,49 +88,20 @@ void AudioRendererProcessThread::ProcessLoop()
NodeOutput* output_to_process = path_.node();
Node* node_to_process = output_to_process->parent();
texture_ = nullptr;
QList<Node*> all_deps;
bool has_hash = false;
bool can_cache = true;
if (!sibling_) {
node_to_process->Lock();
QList<NodeDependency> deps = node_to_process->RunDependencies(output_to_process, path_.in());
all_deps = node_to_process->GetDependencies();
foreach (Node* dep, all_deps) {
dep->Lock();
}
// Check hash
QCryptographicHash hasher(QCryptographicHash::Sha1);
node_to_process->Hash(&hasher, output_to_process, path_.time());
hash_ = hasher.result();
has_hash = parent_->HasHash(hash_);
can_cache = false;
}
if (!has_hash){
if ((can_cache = parent_->TryCache(hash_))) {
QList<NodeDependency> deps = node_to_process->RunDependencies(output_to_process, path_.time());
// Ask for other threads to run these deps while we're here
if (!deps.isEmpty()) {
for (int i=1;i<deps.size();i++) {
emit RequestSibling(deps.at(i));
}
}
// Get the requested value
texture_ = output_to_process->get_value(path_.time(), path_.time()).value<RenderTexturePtr>();
render_instance()->context()->functions()->glFinish();
// Ask for other threads to run these deps while we're here
if (!deps.isEmpty()) {
for (int i=1;i<deps.size();i++) {
emit RequestSibling(deps.at(i));
}
}
// Get the requested value
QByteArray samples = output_to_process->get_value(path_.in(), path_.out()).toByteArray();
if (!sibling_) {
foreach (Node* dep, all_deps) {
dep->Unlock();
@@ -144,12 +110,7 @@ void AudioRendererProcessThread::ProcessLoop()
node_to_process->Unlock();
}
if (can_cache) {
// We cached this frame, signal that it will need to be downloaded to disk
emit CachedFrame(texture_, path_.time(), hash_);
} else {
// This hash already exists, no need to cache, just map it
emit FrameSkipped(path_.time(), hash_);
}
// Signal that we cached some samples
emit CachedSamples(samples, path_.in(), path_.out());
}
}
app/render/audio/audiorendererprocessthread.h
+2 -12
View File
@@ -30,11 +30,7 @@ class AudioRendererProcessThread : public AudioRendererThreadBase
Q_OBJECT
public:
AudioRendererProcessThread(AudioRendererProcessor* parent,
QOpenGLContext* share_ctx,
const int& width,
const int& height, const int &divider,
const olive::PixelFormat& format,
const olive::RenderMode& mode);
const AudioRenderingParams &params);
bool Queue(const NodeDependency &dep, bool wait, bool sibling);
@@ -47,19 +43,13 @@ protected:
signals:
void RequestSibling(NodeDependency dep);
void CachedFrame(RenderTexturePtr texture, const rational& time, const QByteArray& hash);
void FrameSkipped(const rational& time, const QByteArray& hash);
void CachedSamples(const QByteArray& samples, const rational& in, const rational& out);
private:
AudioRendererProcessor* parent_;
NodeDependency path_;
QByteArray hash_;
RenderTexturePtr texture_;
QAtomicInt cancelled_;
bool sibling_;
app/render/audio/audiorendererthreadbase.cpp
+6 -20
View File
@@ -22,16 +22,14 @@
#include <QDebug>
AudioRendererThreadBase::AudioRendererThreadBase(QOpenGLContext *share_ctx, const int &width, const int &height, const int &divider, const olive::PixelFormat &format, const olive::RenderMode &mode) :
share_ctx_(share_ctx),
render_instance_(width, height, divider, format, mode)
AudioRendererThreadBase::AudioRendererThreadBase(const AudioRenderingParams &params) :
params_(params)
{
connect(share_ctx_, SIGNAL(aboutToBeDestroyed()), this, SLOT(Cancel()));
}
RenderInstance *AudioRendererThreadBase::render_instance()
AudioParams *AudioRendererThreadBase::params()
{
return &render_instance_;
return &params_;
}
void AudioRendererThreadBase::run()
@@ -39,23 +37,11 @@ void AudioRendererThreadBase::run()
// Lock mutex for main loop
mutex_.lock();
render_instance_.SetShareContext(share_ctx_);
// Allocate and create resources
bool started = render_instance_.Start();
// Signal that main thread can continue now
WakeCaller();
if (started) {
// Main loop (use Cancel() to exit it)
ProcessLoop();
}
// Free all resources
render_instance_.Stop();
// Main loop (use Cancel() to exit it)
ProcessLoop();
// Unlock mutex before exiting
mutex_.unlock();
app/render/audio/audiorendererthreadbase.h
+4 -11
View File
@@ -26,21 +26,16 @@
#include <QThread>
#include <QWaitCondition>
#include "audioparams.h"
#include "node/node.h"
#include "render/renderinstance.h"
class AudioRendererThreadBase : public QThread
{
Q_OBJECT
public:
AudioRendererThreadBase(QOpenGLContext* share_ctx,
const int& width,
const int& height,
const int& divider,
const olive::PixelFormat& format,
const olive::RenderMode& mode);
AudioRendererThreadBase(const AudioRenderingParams &params);
RenderInstance* render_instance();
AudioParams* params();
void StartThread(Priority priority = InheritPriority);
@@ -61,9 +56,7 @@ protected:
private:
void WakeCaller();
QOpenGLContext* share_ctx_;
RenderInstance render_instance_;
AudioRenderingParams params_;
};
app/render/renderinstance.cpp
+5 -33
View File
@@ -24,17 +24,9 @@
#include "render/gl/shadergenerators.h"
RenderInstance::RenderInstance(const int& width,
const int& height,
const int& divider,
const olive::PixelFormat& format,
const olive::RenderMode& mode) :
RenderInstance::RenderInstance(const VideoRenderingParams& params) :
share_ctx_(nullptr),
width_(width),
height_(height),
format_(format),
mode_(mode),
divider_(divider)
params_(params)
{
// Create offscreen surface
surface_.create();
@@ -82,7 +74,7 @@ bool RenderInstance::Start()
buffer_.Create(ctx_);
// Set viewport to the compositing dimensions
ctx_->functions()->glViewport(0, 0, width_, height_);
ctx_->functions()->glViewport(0, 0, params_.width(), params_.height());
ctx_->functions()->glEnable(GL_BLEND);
// Set up default pipeline
@@ -122,29 +114,9 @@ QOpenGLContext *RenderInstance::context()
return ctx_;
}
const int &RenderInstance::width() const
const VideoRenderingParams &RenderInstance::params() const
{
return width_;
}
const int &RenderInstance::height() const
{
return height_;
}
const int &RenderInstance::divider() const
{
return divider_;
}
const olive::PixelFormat &RenderInstance::format() const
{
return format_;
}
const olive::RenderMode &RenderInstance::mode() const
{
return mode_;
return params_;
}
ShaderPtr RenderInstance::default_pipeline() const
app/render/renderinstance.h
+4 -23
View File
@@ -28,6 +28,7 @@
#include "render/gl/shaderptr.h"
#include "render/renderframebuffer.h"
#include "render/rendermodes.h"
#include "render/videoparams.h"
/**
* @brief An object containing all resources necessary for each thread to support hardware accelerated rendering
@@ -40,11 +41,7 @@
class RenderInstance : public QObject
{
public:
RenderInstance(const int& width,
const int& height,
const int& divider,
const olive::PixelFormat& format,
const olive::RenderMode& mode);
RenderInstance(const VideoRenderingParams &params);
virtual ~RenderInstance() override;
@@ -80,15 +77,7 @@ public:
QOpenGLContext* context();
const int& width() const;
const int& height() const;
const int& divider() const;
const olive::PixelFormat& format() const;
const olive::RenderMode& mode() const;
const VideoRenderingParams& params() const;
ShaderPtr default_pipeline() const;
@@ -101,15 +90,7 @@ private:
RenderFramebuffer buffer_;
int width_;
int height_;
olive::PixelFormat format_;
olive::RenderMode mode_;
int divider_;
VideoRenderingParams params_;
ShaderPtr default_pipeline_;
};
app/render/video/videorenderer.cpp
+23 -69
View File
@@ -36,9 +36,6 @@
VideoRendererProcessor::VideoRendererProcessor(QObject *parent) :
QObject(parent),
started_(false),
width_(0),
height_(0),
divider_(1),
caching_(false),
push_time_(-1),
starting_(false),
@@ -63,7 +60,7 @@ void VideoRendererProcessor::SetCacheName(const QString &s)
void VideoRendererProcessor::InvalidateCache(const rational &start_range, const rational &end_range)
{
if (timebase_.isNull()) {
if (!params_.is_valid()) {
return;
}
@@ -78,11 +75,11 @@ void VideoRendererProcessor::InvalidateCache(const rational &start_range, const
// Snap start_range to timebase
double start_range_dbl = start_range_adj.toDouble();
double start_range_numf = start_range_dbl * static_cast<double>(timebase_.denominator());
int64_t start_range_numround = qFloor(start_range_numf/static_cast<double>(timebase_.numerator())) * timebase_.numerator();
rational true_start_range(start_range_numround, timebase_.denominator());
double start_range_numf = start_range_dbl * static_cast<double>(params_.time_base().denominator());
int64_t start_range_numround = qFloor(start_range_numf/static_cast<double>(params_.time_base().numerator())) * params_.time_base().numerator();
rational true_start_range(start_range_numround, params_.time_base().denominator());
for (rational r=true_start_range;r<=end_range_adj;r+=timebase_) {
for (rational r=true_start_range;r<=end_range_adj;r+=params_.time_base()) {
// Try to order the queue from closest to the playhead to furthest
rational last_time = last_time_requested_;
@@ -129,48 +126,14 @@ void VideoRendererProcessor::InvalidateCache(const rational &start_range, const
CacheNext();
}
void VideoRendererProcessor::SetTimebase(const rational &timebase)
{
timebase_ = timebase;
timebase_dbl_ = timebase_.toDouble();
}
void VideoRendererProcessor::SetParameters(const int &width,
const int &height,
const olive::PixelFormat &format,
const olive::RenderMode &mode,
const int& divider)
void VideoRendererProcessor::SetParameters(const VideoRenderingParams& params)
{
// Since we're changing parameters, all the existing threads are invalid and must be removed. They will start again
// next time this Node has to process anything.
Stop();
// Set new parameters
width_ = width;
height_ = height;
format_ = format;
mode_ = mode;
// divider's default value is 0, so we can assume if it's 0 a divider wasn't specified
if (divider > 0) {
divider_ = divider;
}
CalculateEffectiveDimensions();
// Regenerate the cache ID
GenerateCacheIDInternal();
}
void VideoRendererProcessor::SetDivider(const int &divider)
{
Q_ASSERT(divider_ > 0);
Stop();
divider_ = divider;
CalculateEffectiveDimensions();
params_ = params;
// Regenerate the cache ID
GenerateCacheIDInternal();
@@ -193,7 +156,7 @@ void VideoRendererProcessor::Start()
threads_.resize(background_thread_count);
for (int i=0;i<threads_.size();i++) {
threads_[i] = std::make_shared<RendererProcessThread>(this, ctx, effective_width_, effective_height_, divider_, format_, mode_);
threads_[i] = std::make_shared<RendererProcessThread>(this, ctx, params_);
threads_[i]->StartThread(QThread::LowPriority);
// Ensure this connection is "Queued" so that it always runs in this object's threaded rather than any of the
@@ -221,7 +184,7 @@ void VideoRendererProcessor::Start()
for (int i=0;i<download_threads_.size();i++) {
// Create download thread
download_threads_[i] = std::make_shared<VideoRendererDownloadThread>(ctx, effective_width_, effective_height_, divider_, format_, mode_);
download_threads_[i] = std::make_shared<VideoRendererDownloadThread>(ctx, params_);
download_threads_[i]->StartThread(QThread::LowPriority);
connect(download_threads_[i].get(),
@@ -238,14 +201,14 @@ void VideoRendererProcessor::Start()
// Create master texture (the one sent to the viewer)
master_texture_ = std::make_shared<RenderTexture>();
master_texture_->Create(ctx, effective_width_, effective_height_, format_);
master_texture_->Create(ctx, params_.effective_width(), params_.effective_height(), params_.format());
// Create internal FBO for copying textures
copy_buffer_.Create(ctx);
copy_buffer_.Attach(master_texture_);
copy_pipeline_ = olive::ShaderGenerator::DefaultPipeline();
cache_frame_load_buffer_.resize(PixelService::GetBufferSize(format_, effective_width_, effective_height_));
cache_frame_load_buffer_.resize(PixelService::GetBufferSize(params_.format(), params_.effective_width(), params_.effective_height()));
started_ = true;
}
@@ -277,7 +240,7 @@ void VideoRendererProcessor::Stop()
void VideoRendererProcessor::GenerateCacheIDInternal()
{
if (cache_name_.isEmpty() || effective_width_ == 0 || effective_height_ == 0) {
if (cache_name_.isEmpty() || !params_.is_valid()) {
return;
}
@@ -285,10 +248,10 @@ void VideoRendererProcessor::GenerateCacheIDInternal()
QCryptographicHash hash(QCryptographicHash::Sha1);
hash.addData(cache_name_.toUtf8());
hash.addData(QString::number(cache_time_).toUtf8());
hash.addData(QString::number(width_).toUtf8());
hash.addData(QString::number(height_).toUtf8());
hash.addData(QString::number(format_).toUtf8());
hash.addData(QString::number(divider_).toUtf8());
hash.addData(QString::number(params_.width()).toUtf8());
hash.addData(QString::number(params_.height()).toUtf8());
hash.addData(QString::number(params_.format()).toUtf8());
hash.addData(QString::number(params_.divider()).toUtf8());
QByteArray bytes = hash.result();
cache_id_ = bytes.toHex();
@@ -307,7 +270,7 @@ void VideoRendererProcessor::CacheNext()
qDebug() << "Caching" << cache_frame.toDouble();
threads_.first()->Queue(NodeDependency(viewer_node_->texture_input()->get_connected_output(), cache_frame), true, false);
threads_.first()->Queue(NodeDependency(viewer_node_->texture_input()->get_connected_output(), cache_frame, cache_frame), true, false);
caching_ = true;
}
@@ -358,12 +321,6 @@ bool VideoRendererProcessor::TryCache(const QByteArray &hash)
return !is_caching;
}
void VideoRendererProcessor::CalculateEffectiveDimensions()
{
effective_width_ = width_ / divider_;
effective_height_ = height_ / divider_;
}
void VideoRendererProcessor::ThreadCallback(RenderTexturePtr texture, const rational& time, const QByteArray& hash)
{
// Threads are all done now, time to proceed
@@ -485,12 +442,12 @@ RenderTexturePtr VideoRendererProcessor::GetCachedFrame(const rational &time)
}
if (cache_id_.isEmpty()) {
qWarning() << "RendererProcessor has no cache ID";
qWarning() << "No cache ID";
return nullptr;
}
if (timebase_.isNull()) {
qWarning() << "RendererProcessor has no timebase";
if (!params_.is_valid()) {
qWarning() << "Invalid parameters";
return nullptr;
}
@@ -502,7 +459,7 @@ RenderTexturePtr VideoRendererProcessor::GetCachedFrame(const rational &time)
auto in = OIIO::ImageInput::open(fn.toStdString());
if (in) {
in->read_image(PixelService::GetPixelFormatInfo(format_).oiio_desc, cache_frame_load_buffer_.data());
in->read_image(PixelService::GetPixelFormatInfo(params_.format()).oiio_desc, cache_frame_load_buffer_.data());
in->close();
@@ -529,10 +486,7 @@ void VideoRendererProcessor::SetViewerNode(ViewerOutput *viewer)
if (viewer_node_ != nullptr) {
connect(viewer_node_, SIGNAL(TextureChangedBetween(const rational&, const rational&)), this, SLOT(InvalidateCache(const rational&, const rational&)));
// FIXME: Hardcoded format and mode
SetParameters(viewer_node_->ViewerWidth(),
viewer_node_->ViewerHeight(),
olive::PIX_FMT_RGBA16F,
olive::kOffline);
// FIXME: Hardcoded format, mode, and divider
SetParameters(VideoRenderingParams(viewer_node_->video_params(), olive::PIX_FMT_RGBA16F, olive::kOffline, 2));
}
}
app/render/video/videorenderer.h
+2 -24
View File
@@ -49,8 +49,6 @@ public:
void SetCacheName(const QString& s);
void SetTimebase(const rational& timebase);
/**
* @brief Set parameters of the Renderer
*
@@ -69,13 +67,7 @@ public:
*
* Buffer pixel format
*/
void SetParameters(const int& width,
const int& height,
const olive::PixelFormat& format,
const olive::RenderMode& mode,
const int &divider = 0);
void SetDivider(const int& divider);
void SetParameters(const VideoRenderingParams &params);
/**
* @brief Return whether a frame with this hash already exists
@@ -156,24 +148,10 @@ private:
*/
bool started_;
int width_;
int height_;
void CalculateEffectiveDimensions();
int divider_;
int effective_width_;
int effective_height_;
olive::PixelFormat format_;
olive::RenderMode mode_;
VideoRenderingParams params_;
rational last_time_requested_;
rational timebase_;
double timebase_dbl_;
QLinkedList<rational> cache_queue_;
QString cache_name_;
qint64 cache_time_;
app/render/video/videorendererdownloadthread.cpp
+7 -11
View File
@@ -8,12 +8,8 @@
#include "render/pixelservice.h"
VideoRendererDownloadThread::VideoRendererDownloadThread(QOpenGLContext *share_ctx,
const int &width,
const int &height,
const int &divider,
const olive::PixelFormat &format,
const olive::RenderMode &mode) :
VideoRendererThreadBase(share_ctx, width, height, divider, format, mode),
const VideoRenderingParams& params) :
VideoRendererThreadBase(share_ctx, params),
cancelled_(false)
{
}
@@ -49,17 +45,17 @@ void VideoRendererDownloadThread::ProcessLoop()
DownloadQueueEntry entry;
int buffer_size = PixelService::GetBufferSize(render_instance()->format(),
render_instance()->width(),
render_instance()->height());
int buffer_size = PixelService::GetBufferSize(render_instance()->params().format(),
render_instance()->params().width(),
render_instance()->params().height());
QVector<uchar> data_buffer;
data_buffer.resize(buffer_size);
PixelFormatInfo format_info = PixelService::GetPixelFormatInfo(render_instance()->format());
PixelFormatInfo format_info = PixelService::GetPixelFormatInfo(render_instance()->params().format());
// Set up OIIO::ImageSpec for compressing cached images on disk
OIIO::ImageSpec spec(render_instance()->width(), render_instance()->height(), kRGBAChannels, format_info.oiio_desc);
OIIO::ImageSpec spec(render_instance()->params().width(), render_instance()->params().height(), kRGBAChannels, format_info.oiio_desc);
spec.attribute("compression", "dwaa:200");
while (!cancelled_) {
app/render/video/videorendererdownloadthread.h
+1 -5
View File
@@ -8,11 +8,7 @@ class VideoRendererDownloadThread : public VideoRendererThreadBase
Q_OBJECT
public:
VideoRendererDownloadThread(QOpenGLContext* share_ctx,
const int& width,
const int& height,
const int &divider,
const olive::PixelFormat& format,
const olive::RenderMode& mode);
const VideoRenderingParams &params);
void Queue(RenderTexturePtr texture, const QString &fn, const QByteArray &hash);
app/render/video/videorendererprocessthread.cpp
+7 -11
View File
@@ -24,12 +24,8 @@
RendererProcessThread::RendererProcessThread(VideoRendererProcessor* parent,
QOpenGLContext *share_ctx,
const int &width,
const int &height,
const int &divider,
const olive::PixelFormat &format,
const olive::RenderMode &mode) :
VideoRendererThreadBase(share_ctx, width, height, divider, format, mode),
const VideoRenderingParams &params) :
VideoRendererThreadBase(share_ctx, params),
parent_(parent),
cancelled_(false)
{
@@ -109,7 +105,7 @@ void RendererProcessThread::ProcessLoop()
// Check hash
QCryptographicHash hasher(QCryptographicHash::Sha1);
node_to_process->Hash(&hasher, output_to_process, path_.time());
node_to_process->Hash(&hasher, output_to_process, path_.in());
hash_ = hasher.result();
has_hash = parent_->HasHash(hash_);
@@ -120,7 +116,7 @@ void RendererProcessThread::ProcessLoop()
if ((can_cache = parent_->TryCache(hash_))) {
QList<NodeDependency> deps = node_to_process->RunDependencies(output_to_process, path_.time());
QList<NodeDependency> deps = node_to_process->RunDependencies(output_to_process, path_.in());
// Ask for other threads to run these deps while we're here
if (!deps.isEmpty()) {
@@ -130,7 +126,7 @@ void RendererProcessThread::ProcessLoop()
}
// Get the requested value
texture_ = output_to_process->get_value(path_.time(), path_.time()).value<RenderTexturePtr>();
texture_ = output_to_process->get_value(path_.in(), path_.in()).value<RenderTexturePtr>();
render_instance()->context()->functions()->glFinish();
}
@@ -146,10 +142,10 @@ void RendererProcessThread::ProcessLoop()
if (can_cache) {
// We cached this frame, signal that it will need to be downloaded to disk
emit CachedFrame(texture_, path_.time(), hash_);
emit CachedFrame(texture_, path_.in(), hash_);
} else {
// This hash already exists, no need to cache, just map it
emit FrameSkipped(path_.time(), hash_);
emit FrameSkipped(path_.in(), hash_);
}
}
}
app/render/video/videorendererprocessthread.h
+1 -4
View File
@@ -31,10 +31,7 @@ class RendererProcessThread : public VideoRendererThreadBase
public:
RendererProcessThread(VideoRendererProcessor* parent,
QOpenGLContext* share_ctx,
const int& width,
const int& height, const int &divider,
const olive::PixelFormat& format,
const olive::RenderMode& mode);
const VideoRenderingParams &params);
bool Queue(const NodeDependency &dep, bool wait, bool sibling);
app/render/video/videorendererthreadbase.cpp
+2 -2
View File
@@ -22,9 +22,9 @@
#include <QDebug>
VideoRendererThreadBase::VideoRendererThreadBase(QOpenGLContext *share_ctx, const int &width, const int &height, const int &divider, const olive::PixelFormat &format, const olive::RenderMode &mode) :
VideoRendererThreadBase::VideoRendererThreadBase(QOpenGLContext *share_ctx, const VideoRenderingParams &params) :
share_ctx_(share_ctx),
render_instance_(width, height, divider, format, mode)
render_instance_(params)
{
connect(share_ctx_, SIGNAL(aboutToBeDestroyed()), this, SLOT(Cancel()));
}
app/render/video/videorendererthreadbase.h
+1 -6
View File
@@ -33,12 +33,7 @@ class VideoRendererThreadBase : public QThread
{
Q_OBJECT
public:
VideoRendererThreadBase(QOpenGLContext* share_ctx,
const int& width,
const int& height,
const int& divider,
const olive::PixelFormat& format,
const olive::RenderMode& mode);
VideoRendererThreadBase(QOpenGLContext* share_ctx, const VideoRenderingParams& params);
RenderInstance* render_instance();
app/render/videoparams.cpp
+93
View File
@@ -0,0 +1,93 @@
#include "videoparams.h"
VideoParams::VideoParams() :
width_(0),
height_(0)
{
}
VideoParams::VideoParams(const int &width, const int &height, const rational &time_base) :
width_(width),
height_(height),
time_base_(time_base)
{
}
const int &VideoParams::width() const
{
return width_;
}
const int &VideoParams::height() const
{
return height_;
}
const rational &VideoParams::time_base() const
{
return time_base_;
}
VideoRenderingParams::VideoRenderingParams() :
format_(olive::PIX_FMT_INVALID)
{
}
VideoRenderingParams::VideoRenderingParams(const int &width, const int &height, const rational &time_base, const olive::PixelFormat &format, const olive::RenderMode& mode, const int &divider) :
VideoParams(width, height, time_base),
format_(format),
mode_(mode),
divider_(divider)
{
calculate_effective_size();
}
VideoRenderingParams::VideoRenderingParams(const VideoParams &params, const olive::PixelFormat &format, const olive::RenderMode& mode, const int& divider) :
VideoParams(params),
format_(format),
mode_(mode),
divider_(divider)
{
calculate_effective_size();
}
const int &VideoRenderingParams::divider() const
{
return divider_;
}
const int& VideoRenderingParams::effective_width() const
{
return effective_width_;
}
const int& VideoRenderingParams::effective_height() const
{
return effective_height_;
}
const olive::PixelFormat &VideoRenderingParams::format() const
{
return format_;
}
const olive::RenderMode &VideoRenderingParams::mode() const
{
return mode_;
}
void VideoRenderingParams::calculate_effective_size()
{
effective_width_ = width() / divider_;
effective_height_ = height() / divider_;
}
bool VideoRenderingParams::is_valid() const
{
return (width() > 0
&& height() > 0
&& !time_base().isNull()
&& format_ != olive::PIX_FMT_INVALID
&& format_ != olive::PIX_FMT_COUNT);
}
app/render/videoparams.h
+50
View File
@@ -0,0 +1,50 @@
#ifndef VIDEOPARAMS_H
#define VIDEOPARAMS_H
#include "common/rational.h"
#include "pixelformat.h"
#include "rendermodes.h"
class VideoParams
{
public:
VideoParams();
VideoParams(const int& width, const int& height, const rational& time_base);
const int& width() const;
const int& height() const;
const rational& time_base() const;
private:
int width_;
int height_;
rational time_base_;
};
class VideoRenderingParams : public VideoParams {
public:
VideoRenderingParams();
VideoRenderingParams(const int& width, const int& height, const rational& time_base, const olive::PixelFormat& format, const olive::RenderMode& mode, const int& divider = 1);
VideoRenderingParams(const VideoParams& params, const olive::PixelFormat& format, const olive::RenderMode& mode, const int& divider = 1);
const int& divider() const;
const int& effective_width() const;
const int& effective_height() const;
bool is_valid() const;
const olive::PixelFormat& format() const;
const olive::RenderMode& mode() const;
private:
void calculate_effective_size();
olive::PixelFormat format_;
olive::RenderMode mode_;
int divider_;
int effective_width_;
int effective_height_;
};
#endif // VIDEOPARAMS_H