rays-video 0.2.0 → 0.3.0

data/src/video.cpp

@@ -1,7 +1,9 @@
 #include "video.h"
 
 
-#include <xot/util.h>
+#include <cmath>
+#include <memory>
+#include <map>
 #include <beeps/sound.h>
 #include "rays/bitmap.h"
 #include "rays/exception.h"
@@ -11,6 +13,64 @@ namespace Rays
 {
 
 
+	struct VideoReader
+	{
+
+		typedef std::shared_ptr<VideoReader>     Ptr;
+
+		typedef std::  weak_ptr<VideoReader> WeakPtr;
+
+		VideoDecoder decoder;
+
+		Image pixels;
+
+		ssize_t loaded_index = -1;
+
+		VideoReader (const VideoDecoder& decoder, float pixel_density)
+		:	decoder(decoder),
+			pixels(
+				(int) (decoder.width()  / pixel_density),
+				(int) (decoder.height() / pixel_density),
+				RGBA, pixel_density)
+		{
+		}
+
+	};// VideoReader
+
+
+	struct FrameLoader : public Image::Loader
+	{
+
+		VideoReader::Ptr reader;
+
+		ssize_t index;
+
+		FrameLoader (const VideoReader::Ptr& reader, ssize_t index)
+		:	reader(reader), index(index)
+		{
+		}
+
+		bool load (Bitmap* bitmap) override
+		{
+			VideoReader* r = reader.get();
+			if (r->loaded_index == index)
+				return false;
+
+			r->decoder.get_bitmap(bitmap, index);
+			r->loaded_index = index;
+			return true;
+		}
+
+	};// FrameLoader
+
+
+	static Image
+	make_frame (const VideoReader::Ptr& reader, ssize_t index)
+	{
+		return Image(reader->pixels, new FrameLoader(reader, index));
+	}
+
+
 	struct Video::Data
 	{
 
@@ -22,57 +82,98 @@ namespace Rays
 
 		std::vector<Image> images;
 
+		std::map<String, VideoReader::WeakPtr> readers;
+
 		VideoAudioInList audio_tracks;
 
 		Beeps::SoundPlayer player;
 
-	};// Video::Data
+		VideoReader::Ptr get_reader (const VideoDecoder& decoder)
+		{
+			if (!decoder)
+				argument_error(__FILE__, __LINE__, "invalid decoder");
+
+			VideoReader::WeakPtr& weak = readers[decoder.path()];
+			VideoReader::Ptr reader    = weak.lock();
+			if (!reader)
+			{
+				reader.reset(new VideoReader(VideoDecoder(decoder.path()), pixel_density));
+				weak = reader;
+			}
+			return reader;
+		}
 
+		Image to_frame (const Image& image)
+		{
+			auto* loader = dynamic_cast<const FrameLoader*>(image.loader());
+			if (!loader) return image;
 
-	struct VideoImageData : public Image::Data
-	{
+			return make_frame(get_reader(loader->reader->decoder), loader->index);
+		}
 
-		VideoReader reader;
+	};// Video::Data
 
-		size_t index;
 
-		VideoImageData (const VideoReader& reader, size_t index)
-		:	reader(reader), index(index)
+	static void
+	check_index (const Video& video, size_t index)
+	{
+		if (video.empty())
 		{
+			index_error(
+				__FILE__, __LINE__, "index %zu is out of range (empty)", index);
 		}
-
-		void preprocess (const Image* image) const override
+		if (index >= video.size())
 		{
-			Image decoded = reader.decode_image(index, 1);
-			Bitmap bitmap = decoded.bitmap();
-			if (bitmap) Xot::hint_memory_usage(bitmap.size());
-			const_cast<Image*>(image)->self = decoded.self;
+			index_error(
+				__FILE__, __LINE__, "index %zu is out of range (0..%zu)", index, video.size() - 1);
 		}
+	}
 
-	};// VideoImageData
-
+	static void
+	check_frame (const Video& video, const Image& image)
+	{
+		if (!image)
+			argument_error(__FILE__, __LINE__, "image is empty");
+
+		long   w = std::lround(image.width());
+		long   h = std::lround(image.height());
+		long  pw = std::lround(image.width()  * image.pixel_density());
+		long  ph = std::lround(image.height() * image.pixel_density());
+		long  vw = std::lround(video.width());
+		long  vh = std::lround(video.height());
+		long vpw = std::lround(video.width()  * video.pixel_density());
+		long vph = std::lround(video.height() * video.pixel_density());
+		if (w != vw || h != vh || pw != vpw || ph != vph)
+		{
+			argument_error(
+				__FILE__, __LINE__,
+				"frame size %ldx%ld (%ldx%ld px) does not match the video size %ldx%ld (%ldx%ld px)",
+				w, h, pw, ph, vw, vh, vpw, vph);
+		}
+	}
 
 	Video
 	load_video (const char* path)
 	{
-		VideoReader reader(path);
-		if (!reader)
+		VideoDecoder decoder(path);
+		if (!decoder)
 			invalid_state_error(__FILE__, __LINE__);
 
 		Video video;
 		Video::Data* self   = video.self.get();
-		self->width         = reader.width();
-		self->height        = reader.height();
-		self->fps           = reader.fps();
+		self->width         = decoder.width();
+		self->height        = decoder.height();
+		self->fps           = decoder.fps();
 		self->pixel_density = 1;
 		self->position      = 0;
 
-		size_t size = reader.size();
+		VideoReader::Ptr reader = self->get_reader(decoder);
+		size_t size             = decoder.size();
 		self->images.reserve(size);
 		for (size_t i = 0; i < size; ++i)
-			self->images.push_back(Image(new VideoImageData(reader, i)));
+			self->images.push_back(make_frame(reader, i));
 
-		self->audio_tracks = reader.get_audio_tracks();
+		self->audio_tracks = decoder.get_audio_tracks();
 
 		return video;
 	}
@@ -108,29 +209,12 @@ namespace Rays
 	{
 		Video v;
 		*v.self = *self;
-		return v;
-	}
 
-	void
-	Video::insert (size_t index, const Image& image)
-	{
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__, "video is not initialized");
-
-		self->images.insert(self->images.begin() + index, image);
-	}
-
-	void
-	Video::append (const Image& image)
-	{
-		insert(size(), image);
-	}
+		v.self->readers.clear();
+		for (auto& image : v.self->images)
+			image = v.self->to_frame(image);
 
-	void
-	Video::remove (size_t index)
-	{
-		if (index >= size()) return;
-		self->images.erase(self->images.begin() + index);
+		return v;
 	}
 
 	void
@@ -158,18 +242,6 @@ namespace Rays
 		if (self->player) self->player.stop();
 	}
 
-	void
-	Video::set_time_scale (float scale)
-	{
-		if (self->player) self->player.set_time_scale(scale);
-	}
-
-	float
-	Video::time_scale () const
-	{
-		return self->player ? self->player.time_scale() : 1;
-	}
-
 	coord
 	Video::width () const
 	{
@@ -182,28 +254,16 @@ namespace Rays
 		return self->height;
 	}
 
-	float
-	Video::fps () const
-	{
-		return self->fps;
-	}
-
 	float
 	Video::pixel_density () const
 	{
 		return self->pixel_density;
 	}
 
-	size_t
-	Video::size () const
-	{
-		return self->images.size();
-	}
-
-	bool
-	Video::empty () const
+	float
+	Video::fps () const
 	{
-		return self->images.empty();
+		return self->fps;
 	}
 
 	void
@@ -222,6 +282,75 @@ namespace Rays
 		return self->position;
 	}
 
+	void
+	Video::set_time_scale (float scale)
+	{
+		if (self->player) self->player.set_time_scale(scale);
+	}
+
+	float
+	Video::time_scale () const
+	{
+		return self->player ? self->player.time_scale() : 1;
+	}
+
+	void
+	Video::insert (size_t index, const Image& image)
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__, "video is not initialized");
+		if (index > size())
+		{
+			index_error(
+				__FILE__, __LINE__, "index %zu is out of range (0..%zu)", index, size());
+		}
+		check_frame(*this, image);
+
+		self->images.insert(self->images.begin() + index, self->to_frame(image));
+	}
+
+	void
+	Video::append (const Image& image)
+	{
+		insert(size(), image);
+	}
+
+	void
+	Video::remove (size_t index)
+	{
+		if (index >= size()) return;
+		self->images.erase(self->images.begin() + index);
+	}
+
+	void
+	Video::set (size_t index, const Image& image)
+	{
+		check_index(*this, index);
+		check_frame(*this, image);
+
+		self->images[index] = self->to_frame(image);
+	}
+
+	Image
+	Video::get (size_t index) const
+	{
+		check_index(*this, index);
+
+		return self->images[index];
+	}
+
+	size_t
+	Video::size () const
+	{
+		return self->images.size();
+	}
+
+	bool
+	Video::empty () const
+	{
+		return self->images.empty();
+	}
+
 	Video::const_iterator
 	Video::begin () const
 	{
@@ -237,19 +366,7 @@ namespace Rays
 	Image
 	Video::operator [] (size_t index) const
 	{
-		if (empty())
-		{
-			index_error(
-				__FILE__, __LINE__, "index %zu is out of range (empty)",
-				index);
-		}
-		if (index >= size())
-		{
-			index_error(
-				__FILE__, __LINE__, "index %zu is out of range (0..%zu)",
-				index, size() - 1);
-		}
-		return self->images[index];
+		return get(index);
 	}
 
 	Video::operator Image () const

data/src/video.h

@@ -12,19 +12,21 @@ namespace Rays
 {
 
 
-	class VideoReader
+	class VideoDecoder
 	{
 
 		public:
 
-			VideoReader ();
+			VideoDecoder ();
 
-			VideoReader (const char* path);
+			VideoDecoder (const char* path);
 
-			Image decode_image (size_t index, float pixel_density) const;
+			void get_bitmap (Bitmap* bitmap, size_t index);
 
 			VideoAudioInList get_audio_tracks () const;
 
+			const char* path () const;
+
 			coord width () const;
 
 			coord height () const;
@@ -41,7 +43,7 @@ namespace Rays
 
 			Xot::PSharedImpl<Data> self;
 
-	};// VideoReader
+	};// VideoDecoder
 
 
 }// Rays

data/src/win32/video.cpp

@@ -8,63 +8,69 @@ namespace Rays
 {
 
 
-	struct VideoReader::Data
+	struct VideoDecoder::Data
 	{
-	};// VideoReader::Data
+	};// VideoDecoder::Data
 
 
-	VideoReader::VideoReader ()
+	VideoDecoder::VideoDecoder ()
 	{
 	}
 
-	VideoReader::VideoReader (const char*)
+	VideoDecoder::VideoDecoder (const char*)
 	{
 		not_implemented_error(__FILE__, __LINE__);
 	}
 
-	Image
-	VideoReader::decode_image (size_t, float) const
+	void
+	VideoDecoder::get_bitmap (Bitmap*, size_t)
 	{
 		not_implemented_error(__FILE__, __LINE__);
 	}
 
 	VideoAudioInList
-	VideoReader::get_audio_tracks () const
+	VideoDecoder::get_audio_tracks () const
 	{
 		return {};
 	}
 
+	const char*
+	VideoDecoder::path () const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
 	coord
-	VideoReader::width () const
+	VideoDecoder::width () const
 	{
 		return 0;
 	}
 
 	coord
-	VideoReader::height () const
+	VideoDecoder::height () const
 	{
 		return 0;
 	}
 
 	float
-	VideoReader::fps () const
+	VideoDecoder::fps () const
 	{
 		return 0;
 	}
 
 	size_t
-	VideoReader::size () const
+	VideoDecoder::size () const
 	{
 		return 0;
 	}
 
-	VideoReader::operator bool () const
+	VideoDecoder::operator bool () const
 	{
 		return false;
 	}
 
 	bool
-	VideoReader::operator ! () const
+	VideoDecoder::operator ! () const
 	{
 		return !operator bool();
 	}