oak-editor/engine/codec/frame.cpp

/***

  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/>.

***/

#include "frame.h"

#include <OpenImageIO/imagebuf.h>
#include <QDebug>
#include <QtGlobal>
#include <QtMath>

#include "common/oiioutils.h"
#include "render/framemanager.h"

namespace olive
{

Frame::Frame()
	: data_(nullptr)
	, data_size_(0)
	, timestamp_(0)
{
}

Frame::~Frame()
{
	destroy();
}

FramePtr Frame::create()
{
	return std::make_shared<Frame>();
}

const VideoParams &Frame::video_params() const
{
	return params_;
}

void Frame::set_video_params(const VideoParams &params)
{
	params_ = params;

	linesize_ = generate_linesize_bytes(width(), params_.format(),
										params_.channel_count());
	linesize_pixels_ = linesize_ / params_.get_bytes_per_pixel();
}

FramePtr Frame::interlace(FramePtr top, FramePtr bottom)
{
	if (top->video_params() != bottom->video_params()) {
		qCritical()
			<< "Tried to interlace two frames that had incompatible parameters";
		return nullptr;
	}

	FramePtr interlaced = Frame::create();
	interlaced->set_video_params(top->video_params());
	interlaced->allocate();

	int linesize = interlaced->linesize_bytes();

	for (int i = 0; i < interlaced->height(); i++) {
		FramePtr which = (i % 2 == 0) ? top : bottom;

		memcpy(interlaced->data() + i * linesize,
			   which->const_data() + i * linesize, linesize);
	}

	return interlaced;
}

int Frame::generate_linesize_bytes(int width, PixelFormat format,
								   int channel_count)
{
	// Align to 32 bytes (not sure if this is necessary?)
	return VideoParams::get_bytes_per_pixel(format, channel_count) *
		   ((width + 31) & ~31);
}

Color Frame::get_pixel(int x, int y) const
{
	if (!contains_pixel(x, y)) {
		return Color();
	}

	int byte_offset =
		y * linesize_bytes() + x * video_params().get_bytes_per_pixel();

	return Color(reinterpret_cast<const char *>(data_ + byte_offset),
				 video_params().format(), video_params().channel_count());
}

bool Frame::contains_pixel(int x, int y) const
{
	return (is_allocated() && x >= 0 && x < width() && y >= 0 && y < height());
}

void Frame::set_pixel(int x, int y, const Color &c)
{
	if (!contains_pixel(x, y)) {
		return;
	}

	int byte_offset =
		y * linesize_bytes() + x * video_params().get_bytes_per_pixel();

	c.to_data(reinterpret_cast<char *>(data_ + byte_offset),
			 video_params().format(), video_params().channel_count());
}

bool Frame::allocate()
{
	// Assume this frame is intended to be a video frame
	if (!params_.is_valid()) {
		qWarning() << "Tried to allocate a frame with invalid parameters";
		return false;
	}

	if (is_allocated()) {
		// Already allocated
		return true;
	}

	data_size_ = linesize_ * height();
	data_ = FrameManager::allocate(data_size_);

	return true;
}

void Frame::destroy()
{
	if (is_allocated()) {
		FrameManager::deallocate(data_size_, data_);

		data_size_ = 0;
		data_ = nullptr;
	}
}

FramePtr Frame::convert(PixelFormat format) const
{
	// Create new params with destination format
	VideoParams params = params_;
	params.set_format(format);

	// Create new frame
	FramePtr converted = Frame::create();
	converted->set_video_params(params);
	converted->set_timestamp(timestamp_);
	converted->allocate();

	// Do the conversion through OIIO for convenience
	OIIO::ImageBuf src(
		OIIO::ImageSpec(width(), height(), channel_count(),
						OIIOUtils::get_oiio_base_type_from_format(this->format())));

	OIIOUtils::frame_to_buffer(this, &src);

	OIIO::ImageBuf dst(OIIO::ImageSpec(
		converted->width(), converted->height(), channel_count(),
		OIIOUtils::get_oiio_base_type_from_format(format)));

	if (dst.copy_pixels(src)) {
		OIIOUtils::buffer_to_frame(&dst, converted.get());
		return converted;
	} else {
		return nullptr;
	}
}

}