/**
 * @file
 * @brief Source file for Timeline class
 * @author Jonathan Thomas <jonathan@openshot.org>
 *
 * @ref License
 */

// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later

#include "Timeline.h"

#include "CacheBase.h"
#include "CacheDisk.h"
#include "CacheMemory.h"
#include "CrashHandler.h"
#include "FrameMapper.h"
#include "Exceptions.h"
#include "effects/Mask.h"

#include <algorithm>
#include <QDir>
#include <QFileInfo>
#include <QRegularExpression>
#include <unordered_map>
#include <cmath>
#include <cstdint>

using namespace openshot;

// Default Constructor for the timeline (which sets the canvas width and height)
Timeline::Timeline(int width, int height, Fraction fps, int sample_rate, int channels, ChannelLayout channel_layout) :
		is_open(false), auto_map_clips(true), managed_cache(true), path(""), max_time(0.0), cache_epoch(0)
{
	// Create CrashHandler and Attach (incase of errors)
	CrashHandler::Instance();

	// Init viewport size (curve based, because it can be animated)
	viewport_scale = Keyframe(100.0);
	viewport_x = Keyframe(0.0);
	viewport_y = Keyframe(0.0);

	// Init background color
	color.red = Keyframe(0.0);
	color.green = Keyframe(0.0);
	color.blue = Keyframe(0.0);

	// Init FileInfo struct (clear all values)
	info.width = width;
	info.height = height;
	preview_width = info.width;
	preview_height = info.height;
	info.fps = fps;
	info.sample_rate = sample_rate;
	info.channels = channels;
	info.channel_layout = channel_layout;
	info.video_timebase = fps.Reciprocal();
	info.duration = 60 * 30; // 30 minute default duration
	info.has_audio = true;
	info.has_video = true;
	info.video_length = info.fps.ToFloat() * info.duration;
	info.display_ratio = openshot::Fraction(width, height);
	info.display_ratio.Reduce();
	info.pixel_ratio = openshot::Fraction(1, 1);
	info.acodec = "openshot::timeline";
	info.vcodec = "openshot::timeline";

	// Init max image size
	SetMaxSize(info.width, info.height);

	// Init cache
	final_cache = new CacheMemory();
	const int cache_frames = std::max(Settings::Instance()->CACHE_MIN_FRAMES, OPEN_MP_NUM_PROCESSORS * 4);
	final_cache->SetMaxBytesFromInfo(cache_frames, info.width, info.height, info.sample_rate, info.channels);
}

// Delegating constructor that copies parameters from a provided ReaderInfo
Timeline::Timeline(const ReaderInfo info) : Timeline::Timeline(
	info.width, info.height, info.fps, info.sample_rate,
	info.channels, info.channel_layout) {}

// Constructor for the timeline (which loads a JSON structure from a file path, and initializes a timeline)
Timeline::Timeline(const std::string& projectPath, bool convert_absolute_paths) :
		is_open(false), auto_map_clips(true), managed_cache(true), path(projectPath), max_time(0.0), cache_epoch(0) {

	// Create CrashHandler and Attach (incase of errors)
	CrashHandler::Instance();

	// Init final cache as NULL (will be created after loading json)
	final_cache = NULL;

	// Init viewport size (curve based, because it can be animated)
	viewport_scale = Keyframe(100.0);
	viewport_x = Keyframe(0.0);
	viewport_y = Keyframe(0.0);

	// Init background color
	color.red = Keyframe(0.0);
	color.green = Keyframe(0.0);
	color.blue = Keyframe(0.0);

	// Check if path exists
	QFileInfo filePath(QString::fromStdString(path));
	if (!filePath.exists()) {
		throw InvalidFile("Timeline project file could not be opened.", path);
	}

	// Check OpenShot Install Path exists
	Settings *s = Settings::Instance();
	QDir openshotPath(QString::fromStdString(s->PATH_OPENSHOT_INSTALL));
	if (!openshotPath.exists()) {
		throw InvalidFile("PATH_OPENSHOT_INSTALL could not be found.", s->PATH_OPENSHOT_INSTALL);
	}
	QDir openshotTransPath(openshotPath.filePath("transitions"));
	if (!openshotTransPath.exists()) {
		throw InvalidFile("PATH_OPENSHOT_INSTALL/transitions could not be found.", openshotTransPath.path().toStdString());
	}

	// Determine asset path
	QString asset_name = filePath.baseName().left(30) + "_assets";
	QDir asset_folder(filePath.dir().filePath(asset_name));
	if (!asset_folder.exists()) {
		// Create directory if needed
		asset_folder.mkpath(".");
	}

	// Load UTF-8 project file into QString
	QFile projectFile(QString::fromStdString(path));
	projectFile.open(QFile::ReadOnly);
	QString projectContents = QString::fromUtf8(projectFile.readAll());

	// Convert all relative paths into absolute paths (if requested)
	if (convert_absolute_paths) {

		// Find all "image" or "path" references in JSON (using regex). Must loop through match results
		// due to our path matching needs, which are not possible with the QString::replace() function.
		QRegularExpression allPathsRegex(QStringLiteral("\"(image|path)\":.*?\"(.*?)\""));
		std::vector<QRegularExpressionMatch> matchedPositions;
		QRegularExpressionMatchIterator i = allPathsRegex.globalMatch(projectContents);
		while (i.hasNext()) {
			QRegularExpressionMatch match = i.next();
			if (match.hasMatch()) {
				// Push all match objects into a vector (so we can reverse them later)
				matchedPositions.push_back(match);
			}
		}

		// Reverse the matches (bottom of file to top, so our replacements don't break our match positions)
		std::vector<QRegularExpressionMatch>::reverse_iterator itr;
		for (itr = matchedPositions.rbegin(); itr != matchedPositions.rend(); itr++) {
			QRegularExpressionMatch match = *itr;
			QString relativeKey = match.captured(1); // image or path
			QString relativePath = match.captured(2); // relative file path
			QString absolutePath = "";

			// Find absolute path of all path, image (including special replacements of @assets and @transitions)
			if (relativePath.startsWith("@assets")) {
				absolutePath = QFileInfo(asset_folder.absoluteFilePath(relativePath.replace("@assets", "."))).canonicalFilePath();
			} else if (relativePath.startsWith("@transitions")) {
				absolutePath = QFileInfo(openshotTransPath.absoluteFilePath(relativePath.replace("@transitions", "."))).canonicalFilePath();
			} else {
				absolutePath = QFileInfo(filePath.absoluteDir().absoluteFilePath(relativePath)).canonicalFilePath();
			}

			// Replace path in JSON content, if an absolute path was successfully found
			if (!absolutePath.isEmpty()) {
				projectContents.replace(match.capturedStart(0), match.capturedLength(0), "\"" + relativeKey + "\": \"" + absolutePath + "\"");
			}
		}
		// Clear matches
		matchedPositions.clear();
	}

	// Set JSON of project
	SetJson(projectContents.toStdString());

	// Calculate valid duration and set has_audio and has_video
	// based on content inside this Timeline's clips.
	float calculated_duration = 0.0;
	for (auto clip : clips)
	{
		float clip_last_frame = clip->Position() + clip->Duration();
		if (clip_last_frame > calculated_duration)
			calculated_duration = clip_last_frame;
		if (clip->Reader() && clip->Reader()->info.has_audio)
			info.has_audio = true;
		if (clip->Reader() && clip->Reader()->info.has_video)
			info.has_video = true;

	}
	info.video_length = calculated_duration * info.fps.ToFloat();
	info.duration = calculated_duration;

	// Init FileInfo settings
	info.acodec = "openshot::timeline";
	info.vcodec = "openshot::timeline";
	info.video_timebase = info.fps.Reciprocal();
	info.has_video = true;
	info.has_audio = true;

	// Init max image size
	SetMaxSize(info.width, info.height);

	// Init cache
	final_cache = new CacheMemory();
	const int cache_frames = std::max(Settings::Instance()->CACHE_MIN_FRAMES, OPEN_MP_NUM_PROCESSORS * 4);
	final_cache->SetMaxBytesFromInfo(cache_frames, info.width, info.height, info.sample_rate, info.channels);
}

Timeline::~Timeline() {
	if (is_open) {
		// Auto Close if not already
		Close();
	}

	// Remove all clips, effects, and frame mappers
	Clear();

	// Destroy previous cache (if managed by timeline)
	if (managed_cache && final_cache) {
		delete final_cache;
		final_cache = NULL;
	}
}

// Add to the tracked_objects map a pointer to a tracked object (TrackedObjectBBox)
void Timeline::AddTrackedObject(std::shared_ptr<openshot::TrackedObjectBase> trackedObject){

	// Search for the tracked object on the map
	auto iterator = tracked_objects.find(trackedObject->Id());

	if (iterator != tracked_objects.end()){
		// Tracked object's id already present on the map, overwrite it
		iterator->second = trackedObject;
	}
	else{
		// Tracked object's id not present -> insert it on the map
		tracked_objects[trackedObject->Id()] = trackedObject;
	}

	return;
}

// Return tracked object pointer by it's id
std::shared_ptr<openshot::TrackedObjectBase> Timeline::GetTrackedObject(std::string id) const{

	// Search for the tracked object on the map
	auto iterator = tracked_objects.find(id);

	if (iterator != tracked_objects.end()){
		// Id found, return the pointer to the tracked object
		std::shared_ptr<openshot::TrackedObjectBase> trackedObject = iterator->second;
		return trackedObject;
	}
	else {
		// Id not found, return a null pointer
		return nullptr;
	}
}

// Return the ID's of the tracked objects as a list of strings
std::list<std::string> Timeline::GetTrackedObjectsIds() const{

	// Create a list of strings
	std::list<std::string> trackedObjects_ids;

	// Iterate through the tracked_objects map
	for (auto const& it: tracked_objects){
		// Add the IDs to the list
		trackedObjects_ids.push_back(it.first);
	}

	return trackedObjects_ids;
}

#ifdef USE_OPENCV
// Return the trackedObject's properties as a JSON string
std::string Timeline::GetTrackedObjectValues(std::string id, int64_t frame_number) const {

	// Initialize the JSON object
	Json::Value trackedObjectJson;

	// Search for the tracked object on the map
	auto iterator = tracked_objects.find(id);

	if (iterator != tracked_objects.end())
	{
		// Id found, Get the object pointer and cast it as a TrackedObjectBBox
		std::shared_ptr<TrackedObjectBBox> trackedObject = std::static_pointer_cast<TrackedObjectBBox>(iterator->second);

		// Get the trackedObject values for it's first frame
		if (trackedObject->ExactlyContains(frame_number)){
			BBox box = trackedObject->GetBox(frame_number);
			float x1 = box.cx - (box.width/2);
			float y1 = box.cy - (box.height/2);
			float x2 = box.cx + (box.width/2);
			float y2 = box.cy + (box.height/2);
			float rotation = box.angle;

			trackedObjectJson["x1"] = x1;
			trackedObjectJson["y1"] = y1;
			trackedObjectJson["x2"] = x2;
			trackedObjectJson["y2"] = y2;
			trackedObjectJson["rotation"] = rotation;

		} else {
			BBox box = trackedObject->BoxVec.begin()->second;
			float x1 = box.cx - (box.width/2);
			float y1 = box.cy - (box.height/2);
			float x2 = box.cx + (box.width/2);
			float y2 = box.cy + (box.height/2);
			float rotation = box.angle;

			trackedObjectJson["x1"] = x1;
			trackedObjectJson["y1"] = y1;
			trackedObjectJson["x2"] = x2;
			trackedObjectJson["y2"] = y2;
			trackedObjectJson["rotation"] = rotation;
		}

	}
	else {
		// Id not found, return all 0 values
		trackedObjectJson["x1"] = 0;
		trackedObjectJson["y1"] = 0;
		trackedObjectJson["x2"] = 0;
		trackedObjectJson["y2"] = 0;
		trackedObjectJson["rotation"] = 0;
	}

	return trackedObjectJson.toStyledString();
}
#endif

// Add an openshot::Clip to the timeline
void Timeline::AddClip(Clip* clip)
{
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// Assign timeline to clip
	clip->ParentTimeline(this);

	// Clear cache of clip and nested reader (if any)
	if (clip->Reader() && clip->Reader()->GetCache())
		clip->Reader()->GetCache()->Clear();

	// All clips should be converted to the frame rate of this timeline
	if (auto_map_clips) {
		// Apply framemapper (or update existing framemapper)
		apply_mapper_to_clip(clip);
	}

	// Add clip to list
	clips.push_back(clip);

	// Sort clips
	sort_clips();
}

// Add an effect to the timeline
void Timeline::AddEffect(EffectBase* effect)
{
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// Assign timeline to effect
	effect->ParentTimeline(this);

	// Add effect to list
	effects.push_back(effect);

	// Sort effects
	sort_effects();
}

// Remove an effect from the timeline
void Timeline::RemoveEffect(EffectBase* effect)
{
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	effects.remove(effect);

	// Delete effect object (if timeline allocated it)
	if (allocated_effects.count(effect)) {
		allocated_effects.erase(effect); // erase before nulling the pointer
		delete effect;
		effect = NULL;
	}

	// Sort effects
	sort_effects();
}

// Remove an openshot::Clip to the timeline
void Timeline::RemoveClip(Clip* clip)
{
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	clips.remove(clip);
	
	// Delete clip object (if timeline allocated it)
	if (allocated_clips.count(clip)) {
		allocated_clips.erase(clip);         // erase before nulling the pointer
		delete clip;
		clip = NULL;
	}

	// Sort clips
	sort_clips();
}

// Look up a clip
openshot::Clip* Timeline::GetClip(const std::string& id)
{
	// Find the matching clip (if any)
	for (const auto& clip : clips) {
		if (clip->Id() == id) {
			return clip;
		}
	}
	return nullptr;
}

// Look up a timeline effect
openshot::EffectBase* Timeline::GetEffect(const std::string& id)
{
	// Find the matching effect (if any)
	for (const auto& effect : effects) {
		if (effect->Id() == id) {
			return effect;
		}
	}
	return nullptr;
}

openshot::EffectBase* Timeline::GetClipEffect(const std::string& id)
{
	// Search all clips for matching effect ID
	for (const auto& clip : clips) {
		const auto e = clip->GetEffect(id);
		if (e != nullptr) {
			return e;
		}
	}
	return nullptr;
}

// Return the list of effects on all clips
std::list<openshot::EffectBase*> Timeline::ClipEffects() const {

	// Initialize the list
	std::list<EffectBase*> timelineEffectsList;

	// Loop through all clips
	for (const auto& clip : clips) {

		// Get the clip's list of effects
		std::list<EffectBase*> clipEffectsList = clip->Effects();

		// Append the clip's effects to the list
		timelineEffectsList.insert(timelineEffectsList.end(), clipEffectsList.begin(), clipEffectsList.end());
	}

	return timelineEffectsList;
}

// Compute the end time of the latest timeline element
double Timeline::GetMaxTime() {
	// Return cached max_time variable (threadsafe)
	return max_time;
}

// Compute the highest frame# based on the latest time and FPS
int64_t Timeline::GetMaxFrame() {
	const double fps = info.fps.ToDouble();
	const double t = GetMaxTime();
	// Inclusive start, exclusive end -> ceil at the end boundary
	return static_cast<int64_t>(std::ceil(t * fps));
}

// Compute the first frame# based on the first clip position
int64_t Timeline::GetMinFrame() {
	const double fps = info.fps.ToDouble();
	const double t = GetMinTime();
	// Inclusive start -> floor at the start boundary, then 1-index
	return static_cast<int64_t>(std::floor(t * fps)) + 1;
}

// Compute the start time of the first timeline clip
double Timeline::GetMinTime() {
	// Return cached min_time variable (threadsafe)
	return min_time;
}

// Apply a FrameMapper to a clip which matches the settings of this timeline
void Timeline::apply_mapper_to_clip(Clip* clip)
{
	// Serialize mapper replacement/reconfiguration with active frame generation.
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// Determine type of reader
	ReaderBase* clip_reader = NULL;
	if (clip->Reader()->Name() == "FrameMapper")
	{
		// Get the existing reader
		clip_reader = (ReaderBase*) clip->Reader();

		// Update the mapping
		FrameMapper* clip_mapped_reader = (FrameMapper*) clip_reader;
		clip_mapped_reader->ChangeMapping(info.fps, PULLDOWN_NONE, info.sample_rate, info.channels, info.channel_layout);

	} else {

		// Create a new FrameMapper to wrap the current reader
		FrameMapper* mapper = new FrameMapper(clip->Reader(), info.fps, PULLDOWN_NONE, info.sample_rate, info.channels, info.channel_layout);
		allocated_frame_mappers.insert(mapper);
		clip_reader = (ReaderBase*) mapper;
	}

	// Update clip reader
	clip->Reader(clip_reader);
}

// Apply the timeline's framerate and samplerate to all clips
void Timeline::ApplyMapperToClips()
{
	// Clear all cached frames
	ClearAllCache();

	// Loop through all clips
	for (auto clip : clips)
	{
		// Apply framemapper (or update existing framemapper)
		apply_mapper_to_clip(clip);
	}
}

// Calculate time of a frame number, based on a framerate
double Timeline::calculate_time(int64_t number, Fraction rate)
{
	// Get float version of fps fraction
	double raw_fps = rate.ToFloat();

	// Return the time (in seconds) of this frame
	return double(number - 1) / raw_fps;
}

// Apply effects to the source frame (if any)
std::shared_ptr<Frame> Timeline::apply_effects(std::shared_ptr<Frame> frame, int64_t timeline_frame_number, int layer, TimelineInfoStruct* options)
{
	// Debug output
	ZmqLogger::Instance()->AppendDebugMethod(
		"Timeline::apply_effects",
		"frame->number", frame->number,
		"timeline_frame_number", timeline_frame_number,
		"layer", layer);

	// Find Effects at this position and layer
	for (auto effect : effects)
	{
		// Does clip intersect the current requested time
		const double fpsD = info.fps.ToDouble();
		int64_t effect_start_position = static_cast<int64_t>(std::llround(effect->Position() * fpsD)) + 1;
		int64_t effect_end_position   = static_cast<int64_t>(std::llround((effect->Position() + effect->Duration()) * fpsD));

		bool does_effect_intersect = (effect_start_position <= timeline_frame_number && effect_end_position >= timeline_frame_number && effect->Layer() == layer);

		// Clip is visible
		if (does_effect_intersect)
		{
			// Determine the frame needed for this clip (based on the position on the timeline)
			int64_t effect_start_frame  = static_cast<int64_t>(std::llround(effect->Start() * fpsD)) + 1;
			int64_t effect_frame_number = timeline_frame_number - effect_start_position + effect_start_frame;

			if (!options->is_top_clip)
				continue; // skip effect, if overlapped/covered by another clip on same layer

			if (options->is_before_clip_keyframes != effect->info.apply_before_clip)
				continue; // skip effect, if this filter does not match

			// Debug output
			ZmqLogger::Instance()->AppendDebugMethod(
				"Timeline::apply_effects (Process Effect)",
				"effect_frame_number", effect_frame_number,
				"does_effect_intersect", does_effect_intersect);

			// Apply the effect to this frame
			frame = effect->ProcessFrame(frame, effect_frame_number);
		}

	} // end effect loop

	// Return modified frame
	return frame;
}

// Get or generate a blank frame
std::shared_ptr<Frame> Timeline::GetOrCreateFrame(std::shared_ptr<Frame> background_frame, Clip* clip, int64_t number, openshot::TimelineInfoStruct* options)
{
	std::shared_ptr<Frame> new_frame;

	// Init some basic properties about this frame
	int samples_in_frame = Frame::GetSamplesPerFrame(number, info.fps, info.sample_rate, info.channels);

	try {
		// Debug output
		ZmqLogger::Instance()->AppendDebugMethod(
			"Timeline::GetOrCreateFrame (from reader)",
			"number", number,
			"samples_in_frame", samples_in_frame);

		// Attempt to get a frame (but this could fail if a reader has just been closed)
		new_frame = std::shared_ptr<Frame>(clip->GetFrame(background_frame, number, options));

		// Return real frame
		return new_frame;

	} catch (const ReaderClosed & e) {
		// ...
	} catch (const OutOfBoundsFrame & e) {
		// ...
	}

	// Debug output
	ZmqLogger::Instance()->AppendDebugMethod(
		"Timeline::GetOrCreateFrame (create blank)",
		"number", number,
		"samples_in_frame", samples_in_frame);

	// Create blank frame
	return new_frame;
}

// Process a new layer of video or audio
void Timeline::add_layer(std::shared_ptr<Frame> new_frame, Clip* source_clip, int64_t clip_frame_number, bool is_top_clip, float max_volume)
{
	// Create timeline options (with details about this current frame request)
	TimelineInfoStruct options{};
	options.is_top_clip = is_top_clip;
	options.is_before_clip_keyframes = true;

	// Get the clip's frame, composited on top of the current timeline frame
	std::shared_ptr<Frame> source_frame;
	source_frame = GetOrCreateFrame(new_frame, source_clip, clip_frame_number, &options);

	// No frame found... so bail
	if (!source_frame)
		return;

	// Debug output
	ZmqLogger::Instance()->AppendDebugMethod(
		"Timeline::add_layer",
		"new_frame->number", new_frame->number,
		"clip_frame_number", clip_frame_number);

	/* COPY AUDIO - with correct volume */
	if (source_clip->Reader()->info.has_audio) {
		// Debug output
		ZmqLogger::Instance()->AppendDebugMethod(
			"Timeline::add_layer (Copy Audio)",
			"source_clip->Reader()->info.has_audio", source_clip->Reader()->info.has_audio,
			"source_frame->GetAudioChannelsCount()", source_frame->GetAudioChannelsCount(),
			"info.channels", info.channels,
			"clip_frame_number", clip_frame_number);

		if (source_frame->GetAudioChannelsCount() == info.channels && source_clip->has_audio.GetInt(clip_frame_number) != 0)
		{
			// Ensure timeline frame matches the source samples once per frame
			if (new_frame->GetAudioSamplesCount() != source_frame->GetAudioSamplesCount()){
				new_frame->ResizeAudio(info.channels, source_frame->GetAudioSamplesCount(), info.sample_rate, info.channel_layout);
			}

			// Apply transition-driven equal-power audio fades for clips covered by a Mask transition.
			const auto transition_audio_gains = ResolveTransitionAudioGains(source_clip, new_frame->number, is_top_clip);

			for (int channel = 0; channel < source_frame->GetAudioChannelsCount(); channel++)
			{
				// Get volume from previous frame and this frame
				float previous_volume = source_clip->volume.GetValue(clip_frame_number - 1);
				float volume = source_clip->volume.GetValue(clip_frame_number);
				previous_volume *= transition_audio_gains.first;
				volume *= transition_audio_gains.second;
				int channel_filter = source_clip->channel_filter.GetInt(clip_frame_number); // optional channel to filter (if not -1)
				int channel_mapping = source_clip->channel_mapping.GetInt(clip_frame_number); // optional channel to map this channel to (if not -1)

				// Apply volume mixing strategy
				if (source_clip->mixing == VOLUME_MIX_AVERAGE && max_volume > 1.0) {
					// Don't allow this clip to exceed 100% (divide volume equally between all overlapping clips with volume
					previous_volume = previous_volume / max_volume;
					volume = volume / max_volume;
				}
				else if (source_clip->mixing == VOLUME_MIX_REDUCE && max_volume > 1.0) {
					// Reduce clip volume by a bit, hoping it will prevent exceeding 100% (but it is very possible it will)
					previous_volume = previous_volume * 0.77;
					volume = volume * 0.77;
				}

				// If channel filter enabled, check for correct channel (and skip non-matching channels)
				if (channel_filter != -1 && channel_filter != channel)
					continue; // skip to next channel

				// If no volume on this frame or previous frame, do nothing
				if (previous_volume == 0.0 && volume == 0.0)
					continue; // skip to next channel

				// If channel mapping disabled, just use the current channel
				if (channel_mapping == -1)
					channel_mapping = channel;

				// Apply ramp to source frame (if needed)
				if (!isEqual(previous_volume, 1.0) || !isEqual(volume, 1.0))
					source_frame->ApplyGainRamp(channel_mapping, 0, source_frame->GetAudioSamplesCount(), previous_volume, volume);

				// Copy audio samples (and set initial volume).  Mix samples with existing audio samples.  The gains are added together, to
				// be sure to set the gain's correctly, so the sum does not exceed 1.0 (of audio distortion will happen).
				new_frame->AddAudio(false, channel_mapping, 0, source_frame->GetAudioSamples(channel), source_frame->GetAudioSamplesCount(), 1.0);
			}
		}
		else
			// Debug output
			ZmqLogger::Instance()->AppendDebugMethod(
				"Timeline::add_layer (No Audio Copied - Wrong # of Channels)",
				"source_clip->Reader()->info.has_audio",
					source_clip->Reader()->info.has_audio,
				"source_frame->GetAudioChannelsCount()",
					source_frame->GetAudioChannelsCount(),
				"info.channels", info.channels,
				"clip_frame_number", clip_frame_number);
	}

	// Debug output
	ZmqLogger::Instance()->AppendDebugMethod(
		"Timeline::add_layer (Transform: Composite Image Layer: Completed)",
		"source_frame->number", source_frame->number,
		"new_frame->GetImage()->width()", new_frame->GetWidth(),
		"new_frame->GetImage()->height()", new_frame->GetHeight());
}

// Update the list of 'opened' clips
void Timeline::update_open_clips(Clip *clip, bool does_clip_intersect)
{
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	ZmqLogger::Instance()->AppendDebugMethod(
		"Timeline::update_open_clips (before)",
		"does_clip_intersect", does_clip_intersect,
		"closing_clips.size()", closing_clips.size(),
		"open_clips.size()", open_clips.size());

	// is clip already in list?
	bool clip_found = open_clips.count(clip);

	if (clip_found && !does_clip_intersect)
	{
		// Remove clip from 'opened' list, because it's closed now
		open_clips.erase(clip);

		// Close clip
		clip->Close();
	}
	else if (!clip_found && does_clip_intersect)
	{
		// Add clip to 'opened' list, because it's missing
		open_clips[clip] = clip;

		try {
			// Open the clip
			clip->Open();

		} catch (const InvalidFile & e) {
			// ...
		}
	}

	// Debug output
	ZmqLogger::Instance()->AppendDebugMethod(
		"Timeline::update_open_clips (after)",
		"does_clip_intersect", does_clip_intersect,
		"clip_found", clip_found,
		"closing_clips.size()", closing_clips.size(),
		"open_clips.size()", open_clips.size());
}

// Calculate the max and min duration (in seconds) of the timeline, based on all the clips, and cache the value
void Timeline::calculate_max_duration() {
	double last_clip = 0.0;
	double last_effect = 0.0;
	double first_clip = std::numeric_limits<double>::max();
	double first_effect = std::numeric_limits<double>::max();

	// Find the last and first clip
	if (!clips.empty()) {
		// Find the clip with the maximum end frame
		const auto max_clip = std::max_element(
			clips.begin(), clips.end(), CompareClipEndFrames());
		last_clip = (*max_clip)->Position() + (*max_clip)->Duration();

		// Find the clip with the minimum start position (ignoring layer)
		const auto min_clip = std::min_element(
			clips.begin(), clips.end(), [](const openshot::Clip* lhs, const openshot::Clip* rhs) {
				return lhs->Position() < rhs->Position();
			});
		first_clip = (*min_clip)->Position();
	}

	// Find the last and first effect
	if (!effects.empty()) {
		// Find the effect with the maximum end frame
		const auto max_effect = std::max_element(
			effects.begin(), effects.end(), CompareEffectEndFrames());
		last_effect = (*max_effect)->Position() + (*max_effect)->Duration();

		// Find the effect with the minimum start position
		const auto min_effect = std::min_element(
			effects.begin(), effects.end(), [](const openshot::EffectBase* lhs, const openshot::EffectBase* rhs) {
				return lhs->Position() < rhs->Position();
			});
		first_effect = (*min_effect)->Position();
	}

	// Calculate the max and min time
	max_time = std::max(last_clip, last_effect);
	min_time = std::min(first_clip, first_effect);

	// If no clips or effects exist, set min_time to 0
	if (clips.empty() && effects.empty()) {
		min_time = 0.0;
		max_time = 0.0;
	}
}

// Sort clips by position on the timeline
void Timeline::sort_clips()
{
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// Debug output
	ZmqLogger::Instance()->AppendDebugMethod(
		"Timeline::SortClips",
		"clips.size()", clips.size());

	// sort clips
	clips.sort(CompareClips());

	// calculate max timeline duration
	calculate_max_duration();
}

// Sort effects by position on the timeline
void Timeline::sort_effects()
{
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// sort clips
	effects.sort(CompareEffects());

	// calculate max timeline duration
	calculate_max_duration();
}

// Clear all clips from timeline
void Timeline::Clear()
{
	ZmqLogger::Instance()->AppendDebugMethod("Timeline::Clear");

	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// Close all open clips
	for (auto clip : clips)
	{
		update_open_clips(clip, false);

		// Delete clip object (if timeline allocated it)
		bool allocated = allocated_clips.count(clip);
		if (allocated) {
			delete clip;
		}
	}
	// Clear all clips
	clips.clear();
	allocated_clips.clear();

	// Close all effects
	for (auto effect : effects)
	{
		// Delete effect object (if timeline allocated it)
		bool allocated = allocated_effects.count(effect);
		if (allocated) {
			delete effect;
		}
	}
	// Clear all effects
	effects.clear();
	allocated_effects.clear();

	// Delete all FrameMappers
	for (auto mapper : allocated_frame_mappers)
	{
		mapper->Reader(NULL);
		mapper->Close();
		delete mapper;
	}
	allocated_frame_mappers.clear();
}

// Close the reader (and any resources it was consuming)
void Timeline::Close()
{
	ZmqLogger::Instance()->AppendDebugMethod("Timeline::Close");

	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// Close all open clips
	for (auto clip : clips)
	{
		// Open or Close this clip, based on if it's intersecting or not
		update_open_clips(clip, false);
	}

	// Mark timeline as closed
	is_open = false;

	// Clear all cache (deep clear, including nested Readers)
	ClearAllCache(true);
}

// Open the reader (and start consuming resources)
void Timeline::Open()
{
	is_open = true;
}

// Compare 2 floating point numbers for equality
bool Timeline::isEqual(double a, double b)
{
	return fabs(a - b) < 0.000001;
}

// Get an openshot::Frame object for a specific frame number of this reader.
std::shared_ptr<Frame> Timeline::GetFrame(int64_t requested_frame)
{
	// Adjust out of bounds frame number
	if (requested_frame < 1)
		requested_frame = 1;
	const int64_t max_frame = GetMaxFrame();
	const bool past_timeline_end = (max_frame > 0 && requested_frame > max_frame);

	// Check cache
	std::shared_ptr<Frame> frame;
	if (!past_timeline_end)
		frame = final_cache->GetFrame(requested_frame);
	if (frame) {
		// Debug output
		ZmqLogger::Instance()->AppendDebugMethod(
			"Timeline::GetFrame (Cached frame found)",
			"requested_frame", requested_frame);

		// Return cached frame
		return frame;
	}
	else
	{
		// Prevent async calls to the following code
		const std::lock_guard<std::recursive_mutex> lock(getFrameMutex);

		// Check cache 2nd time
		std::shared_ptr<Frame> frame;
		if (!past_timeline_end)
			frame = final_cache->GetFrame(requested_frame);
		if (frame) {
			// Debug output
			ZmqLogger::Instance()->AppendDebugMethod(
					"Timeline::GetFrame (Cached frame found on 2nd check)",
					"requested_frame", requested_frame);

			// Return cached frame
			return frame;
		} else {
			// Get a list of clips that intersect with the requested section of timeline
			// This also opens the readers for intersecting clips, and marks non-intersecting clips as 'needs closing'
			std::vector<Clip *> nearby_clips;
			nearby_clips = find_intersecting_clips(requested_frame, 1, true);

			// Debug output
			ZmqLogger::Instance()->AppendDebugMethod(
					"Timeline::GetFrame (processing frame)",
					"requested_frame", requested_frame,
					"omp_get_thread_num()", omp_get_thread_num());

			// Init some basic properties about this frame
			int samples_in_frame = Frame::GetSamplesPerFrame(requested_frame, info.fps, info.sample_rate, info.channels);

			// Create blank frame (which will become the requested frame)
			std::shared_ptr<Frame> new_frame(std::make_shared<Frame>(requested_frame, preview_width, preview_height, "#000000", samples_in_frame, info.channels));
			new_frame->AddAudioSilence(samples_in_frame);
			new_frame->SampleRate(info.sample_rate);
			new_frame->ChannelsLayout(info.channel_layout);

			// Debug output
			ZmqLogger::Instance()->AppendDebugMethod(
					"Timeline::GetFrame (Adding solid color)",
					"requested_frame", requested_frame,
					"info.width", info.width,
					"info.height", info.height);

			// Add Background Color to 1st layer (if animated or not black)
			if ((color.red.GetCount() > 1 || color.green.GetCount() > 1 || color.blue.GetCount() > 1) ||
				(color.red.GetValue(requested_frame) != 0.0 || color.green.GetValue(requested_frame) != 0.0 ||
				 color.blue.GetValue(requested_frame) != 0.0))
				new_frame->AddColor(preview_width, preview_height, color.GetColorHex(requested_frame));

			// Debug output
			ZmqLogger::Instance()->AppendDebugMethod(
					"Timeline::GetFrame (Loop through clips)",
					"requested_frame", requested_frame,
					"clips.size()", clips.size(),
					"nearby_clips.size()", nearby_clips.size());

			// Precompute per-clip timing for this requested frame
			struct ClipInfo {
				Clip* clip;
				int64_t start_pos;
				int64_t end_pos;
				int64_t start_frame;
				int64_t frame_number;
				bool intersects;
			};
			std::vector<ClipInfo> clip_infos;
			clip_infos.reserve(nearby_clips.size());
			const double fpsD = info.fps.ToDouble();

			for (auto clip : nearby_clips) {
				int64_t start_pos  = static_cast<int64_t>(std::llround(clip->Position() * fpsD)) + 1;
				int64_t end_pos    = static_cast<int64_t>(std::llround((clip->Position() + clip->Duration()) * fpsD));
				bool intersects    = (start_pos <= requested_frame && end_pos >= requested_frame);
				int64_t start_frame = static_cast<int64_t>(std::llround(clip->Start() * fpsD)) + 1;
				int64_t frame_number = requested_frame - start_pos + start_frame;
				clip_infos.push_back({clip, start_pos, end_pos, start_frame, frame_number, intersects});
			}

			// Determine top clip per layer (linear, no nested loop)
			std::unordered_map<int, int64_t> top_start_for_layer;
			std::unordered_map<int, Clip*> top_clip_for_layer;
			for (const auto& ci : clip_infos) {
				if (!ci.intersects) continue;
				const int layer = ci.clip->Layer();
				auto it = top_start_for_layer.find(layer);
				if (it == top_start_for_layer.end() || ci.start_pos > it->second) {
					top_start_for_layer[layer] = ci.start_pos;   // strictly greater to match prior logic
					top_clip_for_layer[layer]  = ci.clip;
				}
			}

			// Compute max_volume across all overlapping clips once
			float max_volume_sum = 0.0f;
			for (const auto& ci : clip_infos) {
				if (!ci.intersects) continue;
				if (ci.clip->Reader() && ci.clip->Reader()->info.has_audio &&
				    ci.clip->has_audio.GetInt(ci.frame_number) != 0) {
					max_volume_sum += static_cast<float>(ci.clip->volume.GetValue(ci.frame_number));
				}
			}

			// Compose intersecting clips in a single pass
			for (const auto& ci : clip_infos) {
				// Debug output
				ZmqLogger::Instance()->AppendDebugMethod(
						"Timeline::GetFrame (Does clip intersect)",
						"requested_frame", requested_frame,
						"clip->Position()", ci.clip->Position(),
						"clip->Duration()", ci.clip->Duration(),
						"does_clip_intersect", ci.intersects);

				// Clip is visible
				if (ci.intersects) {
					// Is this the top clip on its layer?
					bool is_top_clip = false;
					const int layer = ci.clip->Layer();
					auto top_it = top_clip_for_layer.find(layer);
					if (top_it != top_clip_for_layer.end())
						is_top_clip = (top_it->second == ci.clip);

					// Determine the frame needed for this clip (based on the position on the timeline)
					int64_t clip_frame_number = ci.frame_number;

					// Debug output
					ZmqLogger::Instance()->AppendDebugMethod(
							"Timeline::GetFrame (Calculate clip's frame #)",
							"clip->Position()", ci.clip->Position(),
							"clip->Start()", ci.clip->Start(),
							"info.fps.ToFloat()", info.fps.ToFloat(),
							"clip_frame_number", clip_frame_number);

					// Add clip's frame as layer
					add_layer(new_frame, ci.clip, clip_frame_number, is_top_clip, max_volume_sum);

				} else {
					// Debug output
					ZmqLogger::Instance()->AppendDebugMethod(
							"Timeline::GetFrame (clip does not intersect)",
							"requested_frame", requested_frame,
							"does_clip_intersect", ci.intersects);
				}

			} // end clip loop

			// Debug output
			ZmqLogger::Instance()->AppendDebugMethod(
					"Timeline::GetFrame (Add frame to cache)",
					"requested_frame", requested_frame,
					"info.width", info.width,
					"info.height", info.height);

			// Set frame # on mapped frame
			new_frame->SetFrameNumber(requested_frame);

				// Add final frame to cache (only for valid timeline range)
				if (!past_timeline_end)
					final_cache->Add(new_frame);
			// Return frame (or blank frame)
			return new_frame;
		}
	}
}


// Find intersecting clips (or non intersecting clips)
std::vector<Clip*> Timeline::find_intersecting_clips(int64_t requested_frame, int number_of_frames, bool include)
{
	// Find matching clips
	std::vector<Clip*> matching_clips;

	// Calculate time of frame
	const int64_t min_requested_frame = requested_frame;
	const int64_t max_requested_frame = requested_frame + (number_of_frames - 1);

	// Find Clips at this time
	matching_clips.reserve(clips.size());
	const double fpsD = info.fps.ToDouble();
	for (auto clip : clips)
	{
		// Does clip intersect the current requested time
		int64_t clip_start_position = static_cast<int64_t>(std::llround(clip->Position() * fpsD)) + 1;
		int64_t clip_end_position   = static_cast<int64_t>(std::llround((clip->Position() + clip->Duration()) * fpsD)) + 1;

		bool does_clip_intersect =
				(clip_start_position <= min_requested_frame || clip_start_position <= max_requested_frame) &&
				(clip_end_position >= min_requested_frame || clip_end_position >= max_requested_frame);

		// Debug output
		ZmqLogger::Instance()->AppendDebugMethod(
			"Timeline::find_intersecting_clips (Is clip near or intersecting)",
			"requested_frame", requested_frame,
			"min_requested_frame", min_requested_frame,
			"max_requested_frame", max_requested_frame,
			"clip->Position()", clip->Position(),
			"does_clip_intersect", does_clip_intersect);

		// Open (or schedule for closing) this clip, based on if it's intersecting or not
		update_open_clips(clip, does_clip_intersect);

		// Clip is visible
		if (does_clip_intersect && include)
			// Add the intersecting clip
			matching_clips.push_back(clip);

		else if (!does_clip_intersect && !include)
			// Add the non-intersecting clip
			matching_clips.push_back(clip);

	} // end clip loop

	// return list
	return matching_clips;
}

// Set the cache object used by this reader
void Timeline::SetCache(CacheBase* new_cache) {
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> lock(getFrameMutex);

	// Destroy previous cache (if managed by timeline)
	if (managed_cache && final_cache) {
		delete final_cache;
		final_cache = NULL;
		managed_cache = false;
	}

	// Set new cache
	final_cache = new_cache;
}

// Generate JSON string of this object
std::string Timeline::Json() const {

	// Return formatted string
	return JsonValue().toStyledString();
}

// Generate Json::Value for this object
Json::Value Timeline::JsonValue() const {

	// Create root json object
	Json::Value root = ReaderBase::JsonValue(); // get parent properties
	root["type"] = "Timeline";
	root["viewport_scale"] = viewport_scale.JsonValue();
	root["viewport_x"] = viewport_x.JsonValue();
	root["viewport_y"] = viewport_y.JsonValue();
	root["color"] = color.JsonValue();
	root["path"] = path;

	// Add array of clips
	root["clips"] = Json::Value(Json::arrayValue);

	// Find Clips at this time
	for (const auto existing_clip : clips)
	{
		root["clips"].append(existing_clip->JsonValue());
	}

	// Add array of effects
	root["effects"] = Json::Value(Json::arrayValue);

	// loop through effects
	for (const auto existing_effect: effects)
	{
		root["effects"].append(existing_effect->JsonValue());
	}

	// return JsonValue
	return root;
}

// Load JSON string into this object
void Timeline::SetJson(const std::string value) {

	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> lock(getFrameMutex);

	// Parse JSON string into JSON objects
	try
	{
		const Json::Value root = openshot::stringToJson(value);
		// Set all values that match
		SetJsonValue(root);
	}
	catch (const std::exception& e)
	{
		// Error parsing JSON (or missing keys)
		throw InvalidJSON("JSON is invalid (missing keys or invalid data types)");
	}
}

// Load Json::Value into this object
void Timeline::SetJsonValue(const Json::Value root) {

	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> lock(getFrameMutex);

	// Close timeline before we do anything (this closes all clips)
	bool was_open = is_open;
	Close();

	// Set parent data
	ReaderBase::SetJsonValue(root);

	// Set data from Json (if key is found)
	if (!root["path"].isNull())
		path = root["path"].asString();

	if (!root["clips"].isNull()) {
		// Clear existing clips
		clips.clear();

		// loop through clips
		for (const Json::Value existing_clip : root["clips"]) {
			// Skip NULL nodes
			if (existing_clip.isNull()) {
				continue;
			}

			// Create Clip
			Clip *c = new Clip();

			// Keep track of allocated clip objects
			allocated_clips.insert(c);

			// When a clip is attached to an object, it searches for the object
			// on it's parent timeline. Setting the parent timeline of the clip here
			// allows attaching it to an object when exporting the project (because)
			// the exporter script initializes the clip and it's effects
			// before setting its parent timeline.
			c->ParentTimeline(this);

			// Load Json into Clip
			c->SetJsonValue(existing_clip);

			// Add Clip to Timeline
			AddClip(c);
		}
	}

	if (!root["effects"].isNull()) {
		// Clear existing effects
		effects.clear();

		// loop through effects
		for (const Json::Value existing_effect :root["effects"]) {
			// Skip NULL nodes
			if (existing_effect.isNull()) {
				continue;
			}

			// Create Effect
			EffectBase *e = NULL;

			if (!existing_effect["type"].isNull()) {
				// Create instance of effect
				if ( (e = EffectInfo().CreateEffect(existing_effect["type"].asString())) ) {

					// Keep track of allocated effect objects
					allocated_effects.insert(e);

					// Load Json into Effect
					e->SetJsonValue(existing_effect);

					// Add Effect to Timeline
					AddEffect(e);
				}
			}
		}
	}

	if (!root["duration"].isNull()) {
		// Update duration of timeline
		info.duration = root["duration"].asDouble();
		info.video_length = info.fps.ToFloat() * info.duration;
	}

	// Update preview settings
	preview_width = info.width;
	preview_height = info.height;

	// Resort (and recalculate min/max duration)
	sort_clips();
	sort_effects();

	// Re-open if needed
	if (was_open)
		Open();

	// Timeline content changed: notify cache clients to rescan active window.
	BumpCacheEpoch();
}

// Apply a special formatted JSON object, which represents a change to the timeline (insert, update, delete)
void Timeline::ApplyJsonDiff(std::string value) {

	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> lock(getFrameMutex);

	// Parse JSON string into JSON objects
	try
	{
		const Json::Value root = openshot::stringToJson(value);
		// Process the JSON change array, loop through each item
		for (const Json::Value change : root) {
			std::string change_key = change["key"][(uint)0].asString();

			// Process each type of change
			if (change_key == "clips")
				// Apply to CLIPS
				apply_json_to_clips(change);

			else if (change_key == "effects")
				// Apply to EFFECTS
				apply_json_to_effects(change);

			else
				// Apply to TIMELINE
				apply_json_to_timeline(change);

		}

		// Timeline content changed: notify cache clients to rescan active window.
		if (!root.empty()) {
			BumpCacheEpoch();
		}
	}
	catch (const std::exception& e)
	{
		// Error parsing JSON (or missing keys)
		throw InvalidJSON("JSON is invalid (missing keys or invalid data types)");
	}
}

void Timeline::BumpCacheEpoch() {
	cache_epoch.fetch_add(1, std::memory_order_relaxed);
}

// Apply JSON diff to clips
void Timeline::apply_json_to_clips(Json::Value change) {

	// Get key and type of change
	std::string change_type = change["type"].asString();
	std::string clip_id = "";
	Clip *existing_clip = NULL;

	// Find id of clip (if any)
	for (auto key_part : change["key"]) {
		// Get each change
		if (key_part.isObject()) {
			// Check for id
			if (!key_part["id"].isNull()) {
				// Set the id
				clip_id = key_part["id"].asString();

				// Find matching clip in timeline (if any)
				for (auto c : clips)
				{
					if (c->Id() == clip_id) {
						existing_clip = c;
						break; // clip found, exit loop
					}
				}
				break; // id found, exit loop
			}
		}
	}

	// Check for a more specific key (targetting this clip's effects)
	// For example: ["clips", {"id:123}, "effects", {"id":432}]
	if (existing_clip && change["key"].size() == 4 && change["key"][2] == "effects")
	{
		// This change is actually targetting a specific effect under a clip (and not the clip)
		Json::Value key_part = change["key"][3];

		if (key_part.isObject()) {
			// Check for id
			if (!key_part["id"].isNull())
			{
				// Set the id
				std::string effect_id = key_part["id"].asString();

				// Find matching effect in timeline (if any)
				std::list<EffectBase*> effect_list = existing_clip->Effects();
				for (auto e : effect_list)
				{
					if (e->Id() == effect_id) {
						// Apply the change to the effect directly
						apply_json_to_effects(change, e);

						// Effect-only diffs must clear the owning clip cache.
						if (existing_clip->GetCache()) {
							existing_clip->GetCache()->Clear();
						}

						// Calculate start and end frames that this impacts, and remove those frames from the cache
						int64_t new_starting_frame = (existing_clip->Position() * info.fps.ToDouble()) + 1;
						int64_t new_ending_frame = ((existing_clip->Position() + existing_clip->Duration()) * info.fps.ToDouble()) + 1;
						final_cache->Remove(new_starting_frame - 8, new_ending_frame + 8);

						return; // effect found, don't update clip
					}
				}
			}
		}
	}

	// Determine type of change operation
	if (change_type == "insert") {

		// Create clip
		Clip *clip = new Clip();

		// Keep track of allocated clip objects
		allocated_clips.insert(clip);

		// Set properties of clip from JSON
		clip->SetJsonValue(change["value"]);

		// Add clip to timeline
		AddClip(clip);

		// Calculate start and end frames that this impacts, and remove those frames from the cache
		int64_t new_starting_frame = (clip->Position() * info.fps.ToDouble()) + 1;
		int64_t new_ending_frame = ((clip->Position() + clip->Duration()) * info.fps.ToDouble()) + 1;
		final_cache->Remove(new_starting_frame - 8, new_ending_frame + 8);

	} else if (change_type == "update") {

		// Update existing clip
		if (existing_clip) {
			// Calculate start and end frames prior to the update
			int64_t old_starting_frame = (existing_clip->Position() * info.fps.ToDouble()) + 1;
			int64_t old_ending_frame = ((existing_clip->Position() + existing_clip->Duration()) * info.fps.ToDouble()) + 1;

			// Update clip properties from JSON
			existing_clip->SetJsonValue(change["value"]);

			// Calculate new start and end frames after the update
			int64_t new_starting_frame = (existing_clip->Position() * info.fps.ToDouble()) + 1;
			int64_t new_ending_frame = ((existing_clip->Position() + existing_clip->Duration()) * info.fps.ToDouble()) + 1;

			// Remove both the old and new ranges from the timeline cache
			final_cache->Remove(old_starting_frame - 8, old_ending_frame + 8);
			final_cache->Remove(new_starting_frame - 8, new_ending_frame + 8);

			// Apply framemapper (or update existing framemapper)
			if (auto_map_clips) {
				apply_mapper_to_clip(existing_clip);
			}
		}

	} else if (change_type == "delete") {

		// Remove existing clip
		if (existing_clip) {
			// Remove clip from timeline
			RemoveClip(existing_clip);

			// Calculate start and end frames that this impacts, and remove those frames from the cache
			int64_t old_starting_frame = (existing_clip->Position() * info.fps.ToDouble()) + 1;
			int64_t old_ending_frame = ((existing_clip->Position() + existing_clip->Duration()) * info.fps.ToDouble()) + 1;
			final_cache->Remove(old_starting_frame - 8, old_ending_frame + 8);
		}

	}

	// Re-Sort Clips (since they likely changed)
	sort_clips();
}

// Apply JSON diff to effects
void Timeline::apply_json_to_effects(Json::Value change) {

	// Get key and type of change
	std::string change_type = change["type"].asString();
	EffectBase *existing_effect = NULL;

	// Find id of an effect (if any)
	for (auto key_part : change["key"]) {

		if (key_part.isObject()) {
			// Check for id
			if (!key_part["id"].isNull())
			{
				// Set the id
				std::string effect_id = key_part["id"].asString();

				// Find matching effect in timeline (if any)
				for (auto e : effects)
				{
					if (e->Id() == effect_id) {
						existing_effect = e;
						break; // effect found, exit loop
					}
				}
				break; // id found, exit loop
			}
		}
	}

	// Now that we found the effect, apply the change to it
	if (existing_effect || change_type == "insert") {
		// Apply change to effect
		apply_json_to_effects(change, existing_effect);
	}
}

// Apply JSON diff to effects (if you already know which effect needs to be updated)
void Timeline::apply_json_to_effects(Json::Value change, EffectBase* existing_effect) {

	// Get key and type of change
	std::string change_type = change["type"].asString();

	// Calculate start and end frames that this impacts, and remove those frames from the cache
	if (!change["value"].isArray() && !change["value"]["position"].isNull()) {
		int64_t new_starting_frame = (change["value"]["position"].asDouble() * info.fps.ToDouble()) + 1;
		int64_t new_ending_frame = ((change["value"]["position"].asDouble() + change["value"]["end"].asDouble() - change["value"]["start"].asDouble()) * info.fps.ToDouble()) + 1;
		final_cache->Remove(new_starting_frame - 8, new_ending_frame + 8);
	}

	// Determine type of change operation
	if (change_type == "insert") {

		// Determine type of effect
		std::string effect_type = change["value"]["type"].asString();

		// Create Effect
		EffectBase *e = NULL;

		// Init the matching effect object
		if ( (e = EffectInfo().CreateEffect(effect_type)) ) {

			// Keep track of allocated effect objects
			allocated_effects.insert(e);

			// Load Json into Effect
			e->SetJsonValue(change["value"]);

			// Add Effect to Timeline
			AddEffect(e);
		}

	} else if (change_type == "update") {

		// Update existing effect
		if (existing_effect) {

			// Calculate start and end frames that this impacts, and remove those frames from the cache
			int64_t old_starting_frame = (existing_effect->Position() * info.fps.ToDouble()) + 1;
			int64_t old_ending_frame = ((existing_effect->Position() + existing_effect->Duration()) * info.fps.ToDouble()) + 1;
			final_cache->Remove(old_starting_frame - 8, old_ending_frame + 8);

			// Update effect properties from JSON
			existing_effect->SetJsonValue(change["value"]);
		}

	} else if (change_type == "delete") {

		// Remove existing effect
		if (existing_effect) {

			// Calculate start and end frames that this impacts, and remove those frames from the cache
			int64_t old_starting_frame = (existing_effect->Position() * info.fps.ToDouble()) + 1;
			int64_t old_ending_frame = ((existing_effect->Position() + existing_effect->Duration()) * info.fps.ToDouble()) + 1;
			final_cache->Remove(old_starting_frame - 8, old_ending_frame + 8);

			// Remove effect from timeline
			RemoveEffect(existing_effect);
		}

	}

	// Re-Sort Effects (since they likely changed)
	sort_effects();
}

// Apply JSON diff to timeline properties
void Timeline::apply_json_to_timeline(Json::Value change) {
	bool cache_dirty = true;

	// Get key and type of change
	std::string change_type = change["type"].asString();
	std::string root_key = change["key"][(uint)0].asString();
	std::string sub_key = "";
	if (change["key"].size() >= 2)
		sub_key = change["key"][(uint)1].asString();

	// Determine type of change operation
	if (change_type == "insert" || change_type == "update") {

		// INSERT / UPDATE
		// Check for valid property
		if (root_key == "color")
			// Set color
			color.SetJsonValue(change["value"]);
		else if (root_key == "viewport_scale")
			// Set viewport scale
			viewport_scale.SetJsonValue(change["value"]);
		else if (root_key == "viewport_x")
			// Set viewport x offset
			viewport_x.SetJsonValue(change["value"]);
		else if (root_key == "viewport_y")
			// Set viewport y offset
			viewport_y.SetJsonValue(change["value"]);
		else if (root_key == "duration") {
			// Update duration of timeline
			info.duration = change["value"].asDouble();
			info.video_length = info.fps.ToFloat() * info.duration;

			// We don't want to clear cache for duration adjustments
			cache_dirty = false;
		}
		else if (root_key == "width") {
			// Set width
			info.width = change["value"].asInt();
			preview_width = info.width;
		}
		else if (root_key == "height") {
			// Set height
			info.height = change["value"].asInt();
			preview_height = info.height;
		}
		else if (root_key == "fps" && sub_key == "" && change["value"].isObject()) {
			// Set fps fraction
			if (!change["value"]["num"].isNull())
				info.fps.num = change["value"]["num"].asInt();
			if (!change["value"]["den"].isNull())
				info.fps.den = change["value"]["den"].asInt();
		}
		else if (root_key == "fps" && sub_key == "num")
			// Set fps.num
			info.fps.num = change["value"].asInt();
		else if (root_key == "fps" && sub_key == "den")
			// Set fps.den
			info.fps.den = change["value"].asInt();
		else if (root_key == "display_ratio" && sub_key == "" && change["value"].isObject()) {
			// Set display_ratio fraction
			if (!change["value"]["num"].isNull())
				info.display_ratio.num = change["value"]["num"].asInt();
			if (!change["value"]["den"].isNull())
				info.display_ratio.den = change["value"]["den"].asInt();
		}
		else if (root_key == "display_ratio" && sub_key == "num")
			// Set display_ratio.num
			info.display_ratio.num = change["value"].asInt();
		else if (root_key == "display_ratio" && sub_key == "den")
			// Set display_ratio.den
			info.display_ratio.den = change["value"].asInt();
		else if (root_key == "pixel_ratio" && sub_key == "" && change["value"].isObject()) {
			// Set pixel_ratio fraction
			if (!change["value"]["num"].isNull())
				info.pixel_ratio.num = change["value"]["num"].asInt();
			if (!change["value"]["den"].isNull())
				info.pixel_ratio.den = change["value"]["den"].asInt();
		}
		else if (root_key == "pixel_ratio" && sub_key == "num")
			// Set pixel_ratio.num
			info.pixel_ratio.num = change["value"].asInt();
		else if (root_key == "pixel_ratio" && sub_key == "den")
			// Set pixel_ratio.den
			info.pixel_ratio.den = change["value"].asInt();

		else if (root_key == "sample_rate")
			// Set sample rate
			info.sample_rate = change["value"].asInt();
		else if (root_key == "channels")
			// Set channels
			info.channels = change["value"].asInt();
		else if (root_key == "channel_layout")
			// Set channel layout
			info.channel_layout = (ChannelLayout) change["value"].asInt();
		else
			// Error parsing JSON (or missing keys)
			throw InvalidJSONKey("JSON change key is invalid", change.toStyledString());


	} else if (change["type"].asString() == "delete") {

		// DELETE / RESET
		// Reset the following properties (since we can't delete them)
		if (root_key == "color") {
			color = Color();
			color.red = Keyframe(0.0);
			color.green = Keyframe(0.0);
			color.blue = Keyframe(0.0);
		}
		else if (root_key == "viewport_scale")
			viewport_scale = Keyframe(1.0);
		else if (root_key == "viewport_x")
			viewport_x = Keyframe(0.0);
		else if (root_key == "viewport_y")
			viewport_y = Keyframe(0.0);
		else
			// Error parsing JSON (or missing keys)
			throw InvalidJSONKey("JSON change key is invalid", change.toStyledString());

	}

	if (cache_dirty) {
		// Clear entire cache
		ClearAllCache();
	}
}

// Clear all caches
void Timeline::ClearAllCache(bool deep) {
	// Get lock (prevent getting frames while this happens)
	const std::lock_guard<std::recursive_mutex> guard(getFrameMutex);

	// Clear primary cache
	if (final_cache) {
		final_cache->Clear();
	}

	// Loop through all clips
	try {
		for (const auto clip : clips) {
			// Clear cache on clip and reader if present
			if (clip->Reader()) {
				if (auto rc = clip->Reader()->GetCache())
					rc->Clear();

				// Clear nested Reader (if deep clear requested)
				if (deep && clip->Reader()->Name() == "FrameMapper") {
					FrameMapper *nested_reader = static_cast<FrameMapper *>(clip->Reader());
					if (nested_reader->Reader()) {
						if (auto nc = nested_reader->Reader()->GetCache())
							nc->Clear();
					}
				}
			}

			// Clear clip cache
			if (auto cc = clip->GetCache())
				cc->Clear();
		}
	} catch (const ReaderClosed & e) {
		// ...
	}

	// Cache content changed: notify cache clients to rebuild their window baseline.
	BumpCacheEpoch();
}

// Set Max Image Size (used for performance optimization). Convenience function for setting
// Settings::Instance()->MAX_WIDTH and Settings::Instance()->MAX_HEIGHT.
void Timeline::SetMaxSize(int width, int height) {
	// Maintain aspect ratio regardless of what size is passed in
	QSize display_ratio_size = QSize(info.width, info.height);
	QSize proposed_size = QSize(std::min(width, info.width), std::min(height, info.height));

	// Scale QSize up to proposed size
	display_ratio_size.scale(proposed_size, Qt::KeepAspectRatio);

	// Update preview settings
	preview_width = display_ratio_size.width();
	preview_height = display_ratio_size.height();
}

// Resolve equal-power audio gains from transition placement relative to the clip edges.
std::pair<float, float> Timeline::ResolveTransitionAudioGains(Clip* source_clip, int64_t timeline_frame_number, bool is_top_clip) const
{
	constexpr double half_pi = 1.57079632679489661923;

	if (!source_clip)
		return {1.0f, 1.0f};

	const double fpsD = info.fps.ToDouble();
	Mask* active_mask = nullptr;
	int64_t effect_start_position = 0;
	int64_t effect_end_position = 0;

	// Find the single active transition on this layer that requested overlapping audio fades.
	for (auto effect : effects) {
		if (effect->Layer() != source_clip->Layer())
			continue;

		auto* mask = dynamic_cast<Mask*>(effect);
		if (!mask || !mask->fade_audio_hint)
			continue;

		const int64_t start_pos = static_cast<int64_t>(std::llround(effect->Position() * fpsD)) + 1;
		const int64_t end_pos = static_cast<int64_t>(std::llround((effect->Position() + effect->Duration()) * fpsD));
		if (start_pos > timeline_frame_number || end_pos < timeline_frame_number)
			continue;

		if (active_mask)
			return {1.0f, 1.0f};

		active_mask = mask;
		effect_start_position = start_pos;
		effect_end_position = end_pos;
	}

	if (!active_mask)
		return {1.0f, 1.0f};

	struct AudibleClipInfo {
		Clip* clip;
		int64_t start_pos;
		int64_t end_pos;
	};

	std::vector<AudibleClipInfo> audible_clips;
	audible_clips.reserve(2);

	// Collect the audible clips covered by this transition on the current layer.
	for (auto clip : clips) {
		if (clip->Layer() != source_clip->Layer())
			continue;
		if (!clip->Reader() || !clip->Reader()->info.has_audio)
			continue;

		const int64_t clip_start_pos = static_cast<int64_t>(std::llround(clip->Position() * fpsD)) + 1;
		const int64_t clip_end_pos = static_cast<int64_t>(std::llround((clip->Position() + clip->Duration()) * fpsD));
		if (clip_start_pos > timeline_frame_number || clip_end_pos < timeline_frame_number)
			continue;

		const int64_t clip_start_frame = static_cast<int64_t>(std::llround(clip->Start() * fpsD)) + 1;
		const int64_t clip_frame_number = timeline_frame_number - clip_start_pos + clip_start_frame;
		if (clip->has_audio.GetInt(clip_frame_number) == 0)
			continue;

		audible_clips.push_back({clip, clip_start_pos, clip_end_pos});
		if (audible_clips.size() > 2)
			return {1.0f, 1.0f};
	}

	if (audible_clips.empty())
		return {1.0f, 1.0f};

	// Skip clips that are not actually participating in this transition audio decision.
	const auto source_it = std::find_if(
		audible_clips.begin(),
		audible_clips.end(),
		[source_clip](const AudibleClipInfo& info) {
			return info.clip == source_clip;
		});
	if (source_it == audible_clips.end())
		return {1.0f, 1.0f};

	// Keep the current top/non-top clip routing intact when two clips overlap.
	if (audible_clips.size() == 2) {
		auto top_it = std::max_element(
			audible_clips.begin(),
			audible_clips.end(),
			[](const AudibleClipInfo& lhs, const AudibleClipInfo& rhs) {
				if (lhs.start_pos != rhs.start_pos)
					return lhs.start_pos < rhs.start_pos;
				return std::less<Clip*>()(lhs.clip, rhs.clip);
			});
		if ((is_top_clip && source_clip != top_it->clip) || (!is_top_clip && source_clip == top_it->clip))
			return {1.0f, 1.0f};
	}

	// Infer fade direction from which transition edge is closer to this clip.
	const int64_t left_distance = std::llabs(effect_start_position - source_it->start_pos);
	const int64_t right_distance = std::llabs(effect_end_position - source_it->end_pos);
	const bool clip_fades_in = left_distance <= right_distance;

	// Evaluate the current frame and previous frame so Timeline can preserve per-frame gain ramps.
	const auto compute_gain = [&](int64_t frame_number) -> float {
		if (effect_end_position <= effect_start_position)
			return 1.0f;

		const double span = static_cast<double>(effect_end_position - effect_start_position);
		double t = static_cast<double>(frame_number - effect_start_position) / span;
		if (t < 0.0)
			t = 0.0;
		else if (t > 1.0)
			t = 1.0;

		return static_cast<float>(clip_fades_in ? std::sin(t * half_pi) : std::cos(t * half_pi));
	};

	return {compute_gain(timeline_frame_number - 1), compute_gain(timeline_frame_number)};
}
