oak-editor/app/task/render/render.h

/***

  Olive - Non-Linear Video Editor
  Copyright (C) 2022 Olive Team
  Modifications Copyright (C) 2025 mikesolar

  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 3 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, see <http://www.gnu.org/licenses/>.

***/

#ifndef OAK_RENDERTASK_H
#define OAK_RENDERTASK_H

#include <QtConcurrent/QtConcurrent>

#include "node/block/subtitle/subtitle.h"
#include "node/color/colormanager/colormanager.h"
#include "node/output/viewer/viewer.h"
#include "task/task.h"
#include "render/renderticket.h"

namespace olive
{

class RenderTask : public Task {
	Q_OBJECT
public:
	RenderTask();

	virtual ~RenderTask() override;

protected:
	bool render(ColorManager *manager, const TimeRangeList &video_range,
				const TimeRangeList &audio_range,
				const TimeRange &subtitle_range, RenderMode::Mode mode,
				FrameHashCache *cache, const QSize &force_size = QSize(0, 0),
				const QMatrix4x4 &force_matrix = QMatrix4x4(),
				PixelFormat force_format = PixelFormat::invalid,
				int force_channel_count = 0,
				ColorProcessorPtr force_color_output = nullptr,
				const ColorTransform &force_color_transform = ColorTransform());

	virtual bool download_frame(QThread *thread, FramePtr frame,
							   const Rational &time);

	virtual bool frame_downloaded(FramePtr frame, const Rational &time) = 0;

	virtual bool audio_downloaded(const TimeRange &range,
								 const SampleBuffer &samples) = 0;

	virtual bool encode_subtitle(const SubtitleBlock *subtitle);

	ViewerOutput *viewer() const
	{
		return viewer_;
	}

	void set_viewer(ViewerOutput *v)
	{
		viewer_ = v;
	}

	const VideoParams &video_params() const
	{
		return video_params_;
	}

	void set_video_params(const VideoParams &video_params)
	{
		video_params_ = video_params;
	}

	const AudioParams &audio_params() const
	{
		return audio_params_;
	}

	void set_audio_params(const AudioParams &audio_params)
	{
		audio_params_ = audio_params;
	}

	virtual void CancelEvent() override
	{
		finished_watcher_mutex_.lock();
		finished_watcher_wait_cond_.wakeAll();
		finished_watcher_mutex_.unlock();
	}

	virtual bool two_step_frame_rendering() const
	{
		return true;
	}

	void set_native_progress_signalling_enabled(bool e)
	{
		native_progress_signalling_ = e;
	}

	/**
   * @brief Only valid after Render() is called
   */
	int64_t get_total_number_of_frames() const
	{
		return total_number_of_frames_;
	}

private:
	void prepare_watcher(RenderTicketWatcher *watcher, QThread *thread);

	void increment_running_tickets();

	void start_ticket(QThread *watcher_thread, ColorManager *manager,
					 const Rational &time, RenderMode::Mode mode,
					 FrameHashCache *cache, const QSize &force_size,
					 const QMatrix4x4 &force_matrix, PixelFormat force_format,
					 int force_channel_count,
					 ColorProcessorPtr force_color_output,
					 const ColorTransform &force_color_transform);

	ViewerOutput *viewer_;

	VideoParams video_params_;

	AudioParams audio_params_;

	QVector<RenderTicketWatcher *> running_watchers_;
	std::list<RenderTicketWatcher *> finished_watchers_;
	int running_tickets_;
	QMutex finished_watcher_mutex_;
	QWaitCondition finished_watcher_wait_cond_;

	bool native_progress_signalling_;

	int64_t total_number_of_frames_;

private slots:
	void ticket_done(RenderTicketWatcher *watcher);
};

}

#endif // OAK_RENDERTASK_H