Merge branch 'develop' into store-qt-version

2026-03-02 08:53:52 -08:00 · 2020-06-11 12:06:10 -04:00
parent 0e79844ed9 c29174f18b
commit 07fef5b878
14 changed files with 414 additions and 87 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -32,8 +32,12 @@ addons:
    - curl

 jobs:
-  include:

+  # The FFmpeg 3.2 backport PPA has gone missing
+  allow_failures:
+    - name: "FFmpeg 3.2 GCC (Ubuntu 16.04 Xenial)"
+
+  include:
    - name: "Coverage + FFmpeg 3.4 GCC (Ubuntu 18.04 Bionic)"
      env:
        - BUILD_VERSION=coverage_ffmpeg34
@@ -45,7 +49,6 @@ jobs:
        apt:
          sources:
          - sourceline: 'ppa:openshot.developers/libopenshot-daily'
-          - sourceline: 'ppa:beineri/opt-qt-5.12.3-bionic'
          packages:
          - *p_common
          - qt5-default
@@ -54,19 +57,17 @@ jobs:
          - lcov
          - binutils-common # For c++filt

-    - name: "FFmpeg 4 GCC (Ubuntu 18.04 Bionic)"
+    - name: "FFmpeg 4 GCC (Ubuntu 20.04 Focal)"
      env:
        - BUILD_VERSION=ffmpeg4
        - CMAKE_EXTRA_ARGS=""
        - TEST_TARGET=test
      os: linux
-      dist: bionic
+      dist: focal
      addons:
        apt:
          sources:
          - sourceline: 'ppa:openshot.developers/libopenshot-daily'
-          - sourceline: 'ppa:beineri/opt-qt-5.12.3-bionic'
-          - sourceline: 'ppa:jonathonf/ffmpeg-4'
          packages:
          - *p_common
          - qt5-default
@@ -92,7 +93,6 @@ jobs:
        apt:
          sources:
          - sourceline: 'ppa:openshot.developers/libopenshot-daily'
-          - sourceline: 'ppa:beineri/opt-qt-5.12.3-bionic'
          packages:
          - *p_common
          - qt5-default
@@ -110,7 +110,6 @@ jobs:
        apt:
          sources:
          - sourceline: 'ppa:openshot.developers/libopenshot-daily'
-          - sourceline: 'ppa:beineri/opt-qt-5.10.0-xenial'
          - sourceline: 'ppa:jon-hedgerows/ffmpeg-backports'
          packages:
          - *p_common
--- a/include/Clip.h
+++ b/include/Clip.h
@@ -139,11 +139,11 @@ namespace openshot {
 		void reverse_buffer(juce::AudioSampleBuffer* buffer);

 	public:
-		openshot::GravityType gravity; ///< The gravity of a clip determines where it snaps to its parent
-		openshot::ScaleType scale; ///< The scale determines how a clip should be resized to fit its parent
-		openshot::AnchorType anchor; ///< The anchor determines what parent a clip should snap to
-    openshot::FrameDisplayType display; ///< The format to display the frame number (if any)
-		openshot::VolumeMixType mixing; ///< What strategy should be followed when mixing audio with other clips
+		openshot::GravityType gravity;   ///< The gravity of a clip determines where it snaps to its parent
+		openshot::ScaleType scale;		 ///< The scale determines how a clip should be resized to fit its parent
+		openshot::AnchorType anchor;     ///< The anchor determines what parent a clip should snap to
+		openshot::FrameDisplayType display; ///< The format to display the frame number (if any)
+		openshot::VolumeMixType mixing;  ///< What strategy should be followed when mixing audio with other clips

 		/// Default Constructor
 		Clip();
@@ -207,15 +207,19 @@ namespace openshot {
 		bool Waveform() { return waveform; } ///< Get the waveform property of this clip
 		void Waveform(bool value) { waveform = value; } ///< Set the waveform property of this clip

-		// Scale and Location curves
+		// Scale, Location, and Alpha curves
 		openshot::Keyframe scale_x; ///< Curve representing the horizontal scaling in percent (0 to 1)
 		openshot::Keyframe scale_y; ///< Curve representing the vertical scaling in percent (0 to 1)
 		openshot::Keyframe location_x; ///< Curve representing the relative X position in percent based on the gravity (-1 to 1)
 		openshot::Keyframe location_y; ///< Curve representing the relative Y position in percent based on the gravity (-1 to 1)
-
-		// Alpha and Rotation curves
 		openshot::Keyframe alpha; ///< Curve representing the alpha (1 to 0)
+
+		// Rotation and Shear curves (origin point (x,y) is adjustable for both rotation and shear)
 		openshot::Keyframe rotation; ///< Curve representing the rotation (0 to 360)
+		openshot::Keyframe shear_x; ///< Curve representing X shear angle in degrees (-45.0=left, 45.0=right)
+		openshot::Keyframe shear_y; ///< Curve representing Y shear angle in degrees (-45.0=down, 45.0=up)
+		openshot::Keyframe origin_x; ///< Curve representing X origin point (0.0=0% (left), 1.0=100% (right))
+		openshot::Keyframe origin_y; ///< Curve representing Y origin point (0.0=0% (top), 1.0=100% (bottom))

 		// Time and Volume curves
 		openshot::Keyframe time; ///< Curve representing the frames over time to play (used for speed and direction of video)
@@ -231,9 +235,7 @@ namespace openshot {
 		openshot::Keyframe crop_x; ///< Curve representing X offset in percent (-1.0=-100%, 0.0=0%, 1.0=100%)
 		openshot::Keyframe crop_y; ///< Curve representing Y offset in percent (-1.0=-100%, 0.0=0%, 1.0=100%)

-		// Shear and perspective curves
-		openshot::Keyframe shear_x; ///< Curve representing X shear angle in degrees (-45.0=left, 45.0=right)
-		openshot::Keyframe shear_y; ///< Curve representing Y shear angle in degrees (-45.0=down, 45.0=up)
+		// Perspective curves
 		openshot::Keyframe perspective_c1_x; ///< Curves representing X for coordinate 1
 		openshot::Keyframe perspective_c1_y; ///< Curves representing Y for coordinate 1
 		openshot::Keyframe perspective_c2_x; ///< Curves representing X for coordinate 2
--- a/include/DummyReader.h
+++ b/include/DummyReader.h
@@ -46,17 +46,65 @@
 namespace openshot
 {
 	/**
-	 * @brief This class is used as a simple, dummy reader, which always returns a blank frame.
+	 * @brief This class is used as a simple, dummy reader, which can be very useful when writing
+	 * unit tests. It can return a single blank frame or it can return custom frame objects
+	 * which were passed into the constructor with a Cache object.
 	 *
 	 * A dummy reader can be created with any framerate or samplerate. This is useful in unit
 	 * tests that need to test different framerates or samplerates.
+	 *
+	 * @code
+	 * 	// Create cache object to store fake Frame objects
+	 * 	CacheMemory cache;
+	 *
+	 * // Now let's create some test frames
+	 * for (int64_t frame_number = 1; frame_number <= 30; frame_number++)
+	 * {
+	 *   // Create blank frame (with specific frame #, samples, and channels)
+	 *   // Sample count should be 44100 / 30 fps = 1470 samples per frame
+	 *   int sample_count = 1470;
+	 *   std::shared_ptr<openshot::Frame> f(new openshot::Frame(frame_number, sample_count, 2));
+	 *
+	 *   // Create test samples with incrementing value
+	 *   float *audio_buffer = new float[sample_count];
+	 *   for (int64_t sample_number = 0; sample_number < sample_count; sample_number++)
+	 *   {
+	 *     // Generate an incrementing audio sample value (just as an example)
+	 *     audio_buffer[sample_number] = float(frame_number) + (float(sample_number) / float(sample_count));
+	 *   }
+	 *
+	 *   // Add custom audio samples to Frame (bool replaceSamples, int destChannel, int destStartSample, const float* source,
+	 *   //                                    int numSamples, float gainToApplyToSource = 1.0f)
+	 *   f->AddAudio(true, 0, 0, audio_buffer, sample_count, 1.0); // add channel 1
+	 *   f->AddAudio(true, 1, 0, audio_buffer, sample_count, 1.0); // add channel 2
+	 *
+	 *   // Add test frame to cache
+	 *   cache.Add(f);
+	 * }
+	 *
+	 * // Create a reader (Fraction fps, int width, int height, int sample_rate, int channels, float duration, CacheBase* cache)
+	 * openshot::DummyReader r(openshot::Fraction(30, 1), 1920, 1080, 44100, 2, 30.0, &cache);
+	 * r.Open(); // Open the reader
+	 *
+	 * // Now let's verify our DummyReader works
+	 * std::shared_ptr<openshot::Frame> f = r.GetFrame(1);
+	 * // r.GetFrame(1)->GetAudioSamples(0)[1] should equal 1.00068033 based on our above calculations
+	 *
+	 * // Clean up
+	 * r.Close();
+	 * cache.Clear()
+	 * @endcode
 	 */
 	class DummyReader : public ReaderBase
 	{
 	private:
+		CacheBase* dummy_cache;
 		std::shared_ptr<openshot::Frame> image_frame;
 		bool is_open;

+		/// Initialize variables used by constructor
+		void init(Fraction fps, int width, int height, int sample_rate, int channels, float duration);
+
 	public:

 		/// Blank constructor for DummyReader, with default settings.
@@ -65,6 +113,9 @@ namespace openshot
 		/// Constructor for DummyReader.
 		DummyReader(openshot::Fraction fps, int width, int height, int sample_rate, int channels, float duration);

+		/// Constructor for DummyReader which takes a frame cache object.
+		DummyReader(openshot::Fraction fps, int width, int height, int sample_rate, int channels, float duration, CacheBase* cache);
+
 		virtual ~DummyReader();

 		/// Close File
--- a/include/FFmpegUtilities.h
+++ b/include/FFmpegUtilities.h
@@ -163,11 +163,10 @@
 		#define AV_FREE_CONTEXT(av_context) avcodec_free_context(&av_context)
 		#define AV_GET_CODEC_TYPE(av_stream) av_stream->codecpar->codec_type
 		#define AV_FIND_DECODER_CODEC_ID(av_stream) av_stream->codecpar->codec_id
-		auto AV_GET_CODEC_CONTEXT = [](AVStream* av_stream, AVCodec* av_codec) { \
-			AVCodecContext *context = avcodec_alloc_context3(av_codec); \
-			avcodec_parameters_to_context(context, av_stream->codecpar); \
-			return context; \
-		};
+		#define AV_GET_CODEC_CONTEXT(av_stream, av_codec) \
+			({ AVCodecContext *context = avcodec_alloc_context3(av_codec); \
+			   avcodec_parameters_to_context(context, av_stream->codecpar); \
+			   context; })
 		#define AV_GET_CODEC_PAR_CONTEXT(av_stream, av_codec) av_codec;
 		#define AV_GET_CODEC_FROM_STREAM(av_stream,codec_in)
 		#define AV_GET_CODEC_ATTRIBUTES(av_stream, av_context) av_stream->codecpar
@@ -199,11 +198,10 @@
 		#define AV_FREE_CONTEXT(av_context) avcodec_free_context(&av_context)
 		#define AV_GET_CODEC_TYPE(av_stream) av_stream->codecpar->codec_type
 		#define AV_FIND_DECODER_CODEC_ID(av_stream) av_stream->codecpar->codec_id
-		auto AV_GET_CODEC_CONTEXT = [](AVStream* av_stream, AVCodec* av_codec) { \
-			AVCodecContext *context = avcodec_alloc_context3(av_codec); \
-			avcodec_parameters_to_context(context, av_stream->codecpar); \
-			return context; \
-		};
+		#define AV_GET_CODEC_CONTEXT(av_stream, av_codec) \
+			({ AVCodecContext *context = avcodec_alloc_context3(av_codec); \
+			   avcodec_parameters_to_context(context, av_stream->codecpar); \
+			   context; })
 		#define AV_GET_CODEC_PAR_CONTEXT(av_stream, av_codec) av_codec;
 		#define AV_GET_CODEC_FROM_STREAM(av_stream,codec_in)
 		#define AV_GET_CODEC_ATTRIBUTES(av_stream, av_context) av_stream->codecpar
--- a/include/Qt/AudioPlaybackThread.h
+++ b/include/Qt/AudioPlaybackThread.h
@@ -75,7 +75,7 @@ namespace openshot
 		static AudioDeviceManagerSingleton * Instance();

 		/// Public device manager property
-		AudioDeviceManager audioDeviceManager;
+		juce::AudioDeviceManager audioDeviceManager;

 		/// Close audio device
 		void CloseAudioDevice();
@@ -86,9 +86,9 @@ namespace openshot
     */
    class AudioPlaybackThread : juce::Thread
    {
-		AudioSourcePlayer player;
-		AudioTransportSource transport;
-		MixerAudioSource mixer;
+		juce::AudioSourcePlayer player;
+		juce::AudioTransportSource transport;
+		juce::MixerAudioSource mixer;
 		AudioReaderSource *source;
 		double sampleRate;
 		int numChannels;
--- a/src/Clip.cpp
+++ b/src/Clip.cpp
@@ -89,6 +89,8 @@ void Clip::init_settings()
 	// Init shear and perspective curves
 	shear_x = Keyframe(0.0);
 	shear_y = Keyframe(0.0);
+	origin_x = Keyframe(0.5);
+	origin_y = Keyframe(0.5);
 	perspective_c1_x = Keyframe(-1.0);
 	perspective_c1_y = Keyframe(-1.0);
 	perspective_c2_x = Keyframe(-1.0);
@@ -148,8 +150,11 @@ Clip::Clip(ReaderBase* new_reader) : resampler(NULL), reader(new_reader), alloca
 	Open();
 	Close();

-	// Update duration
-	End(reader->info.duration);
+	// Update duration and set parent
+	if (reader) {
+		End(reader->info.duration);
+		reader->SetClip(this);
+	}
 }

 // Constructor with filepath
@@ -202,9 +207,10 @@ Clip::Clip(std::string path) : resampler(NULL), reader(NULL), allocated_reader(N
 		}
 	}

-	// Update duration
+	// Update duration and set parent
 	if (reader) {
 		End(reader->info.duration);
+		reader->SetClip(this);
 		allocated_reader = reader;
 		init_reader_rotation();
 	}
@@ -712,6 +718,8 @@ std::string Clip::PropertiesJSON(int64_t requested_frame) const {
 	root["shear_x"] = add_property_json("Shear X", shear_x.GetValue(requested_frame), "float", "", &shear_x, -1.0, 1.0, false, requested_frame);
 	root["shear_y"] = add_property_json("Shear Y", shear_y.GetValue(requested_frame), "float", "", &shear_y, -1.0, 1.0, false, requested_frame);
 	root["rotation"] = add_property_json("Rotation", rotation.GetValue(requested_frame), "float", "", &rotation, -360, 360, false, requested_frame);
+	root["origin_x"] = add_property_json("Origin X", origin_x.GetValue(requested_frame), "float", "", &origin_x, 0.0, 1.0, false, requested_frame);
+	root["origin_y"] = add_property_json("Origin Y", origin_y.GetValue(requested_frame), "float", "", &origin_y, 0.0, 1.0, false, requested_frame);
 	root["volume"] = add_property_json("Volume", volume.GetValue(requested_frame), "float", "", &volume, 0.0, 1.0, false, requested_frame);
 	root["time"] = add_property_json("Time", time.GetValue(requested_frame), "float", "", &time, 0.0, 30 * 60 * 60 * 48, false, requested_frame);
 	root["channel_filter"] = add_property_json("Channel Filter", channel_filter.GetValue(requested_frame), "int", "", &channel_filter, -1, 10, false, requested_frame);
@@ -768,6 +776,8 @@ Json::Value Clip::JsonValue() const {
 	root["crop_y"] = crop_y.JsonValue();
 	root["shear_x"] = shear_x.JsonValue();
 	root["shear_y"] = shear_y.JsonValue();
+	root["origin_x"] = origin_x.JsonValue();
+	root["origin_y"] = origin_y.JsonValue();
 	root["channel_filter"] = channel_filter.JsonValue();
 	root["channel_mapping"] = channel_mapping.JsonValue();
 	root["has_audio"] = has_audio.JsonValue();
@@ -865,6 +875,10 @@ void Clip::SetJsonValue(const Json::Value root) {
 		shear_x.SetJsonValue(root["shear_x"]);
 	if (!root["shear_y"].isNull())
 		shear_y.SetJsonValue(root["shear_y"]);
+	if (!root["origin_x"].isNull())
+		origin_x.SetJsonValue(root["origin_x"]);
+	if (!root["origin_y"].isNull())
+		origin_y.SetJsonValue(root["origin_y"]);
 	if (!root["channel_filter"].isNull())
 		channel_filter.SetJsonValue(root["channel_filter"]);
 	if (!root["channel_mapping"].isNull())
--- a/src/DummyReader.cpp
+++ b/src/DummyReader.cpp
@@ -32,16 +32,8 @@

 using namespace openshot;

-// Blank constructor for DummyReader, with default settings.
-DummyReader::DummyReader() {
-
-	// Call actual constructor with default values
-	DummyReader(Fraction(24,1), 1280, 768, 44100, 2, 30.0);
-}
-
-// Constructor for DummyReader.  Pass a framerate and samplerate.
-DummyReader::DummyReader(Fraction fps, int width, int height, int sample_rate, int channels, float duration) {
-
+// Initialize variables used by constructor
+void DummyReader::init(Fraction fps, int width, int height, int sample_rate, int channels, float duration) {
 	// Set key info settings
 	info.has_audio = false;
 	info.has_video = true;
@@ -68,10 +60,30 @@ DummyReader::DummyReader(Fraction fps, int width, int height, int sample_rate, i
 	// Set the ratio based on the reduced fraction
 	info.display_ratio.num = size.num;
 	info.display_ratio.den = size.den;
+}

-	// Open and Close the reader, to populate its attributes (such as height, width, etc...)
-	Open();
-	Close();
+// Blank constructor for DummyReader, with default settings.
+DummyReader::DummyReader() : dummy_cache(NULL), is_open(false) {
+
+	// Initialize important variables
+	init(Fraction(24,1), 1280, 768, 44100, 2, 30.0);
+}
+
+// Constructor for DummyReader.  Pass a framerate and samplerate.
+DummyReader::DummyReader(Fraction fps, int width, int height, int sample_rate, int channels, float duration) : dummy_cache(NULL), is_open(false) {
+
+	// Initialize important variables
+	init(fps, width, height, sample_rate, channels, duration);
+}
+
+// Constructor which also takes a cache object
+DummyReader::DummyReader(Fraction fps, int width, int height, int sample_rate, int channels, float duration, CacheBase* cache) : is_open(false) {
+
+	// Initialize important variables
+	init(fps, width, height, sample_rate, channels, duration);
+
+	// Set cache object
+	dummy_cache = (CacheBase*) cache;
 }

 DummyReader::~DummyReader() {
@@ -102,21 +114,40 @@ void DummyReader::Close()
 	}
 }

-// Get an openshot::Frame object for a specific frame number of this reader.
+// Get an openshot::Frame object for a specific frame number of this reader. It is either a blank frame
+// or a custom frame added with passing a Cache object to the constructor.
 std::shared_ptr<Frame> DummyReader::GetFrame(int64_t requested_frame)
 {
 	// Check for open reader (or throw exception)
 	if (!is_open)
 		throw ReaderClosed("The ImageReader is closed.  Call Open() before calling this method.", "dummy");

-	if (image_frame)
-	{
+	int dummy_cache_count = 0;
+	if (dummy_cache) {
+		dummy_cache_count = dummy_cache->Count();
+	}
+
+	if (dummy_cache_count == 0 && image_frame) {
 		// Create a scoped lock, allowing only a single thread to run the following code at one time
 		const GenericScopedLock<CriticalSection> lock(getFrameCriticalSection);

 		// Always return same frame (regardless of which frame number was requested)
 		image_frame->number = requested_frame;
 		return image_frame;
+
+	} else if (dummy_cache_count > 0) {
+		// Create a scoped lock, allowing only a single thread to run the following code at one time
+		const GenericScopedLock<CriticalSection> lock(getFrameCriticalSection);
+
+		// Get a frame from the dummy cache
+		std::shared_ptr<openshot::Frame> f = dummy_cache->GetFrame(requested_frame);
+		if (f) {
+			// return frame from cache (if found)
+			return f;
+		} else {
+			// No cached frame found
+			throw InvalidFile("Requested frame not found. You can only access Frame numbers that exist in the Cache object.", "dummy");
+		}
 	}
 	else
 		// no frame loaded
--- a/src/FFmpegWriter.cpp
+++ b/src/FFmpegWriter.cpp
@@ -255,7 +255,7 @@ void FFmpegWriter::SetVideoOptions(bool has_video, std::string codec, Fraction f
 	}
 	if (bit_rate >= 1000)            // bit_rate is the bitrate in b/s
 		info.video_bit_rate = bit_rate;
-	if ((bit_rate >= 0) && (bit_rate < 64))    // bit_rate is the bitrate in crf
+	if ((bit_rate >= 0) && (bit_rate < 256))    // bit_rate is the bitrate in crf
 		info.video_bit_rate = bit_rate;

 	info.interlaced_frame = interlaced;
@@ -358,7 +358,7 @@ void FFmpegWriter::SetOption(StreamType stream, std::string name, std::string va
 	// Was option found?
 	if (option || (name == "g" || name == "qmin" || name == "qmax" || name == "max_b_frames" || name == "mb_decision" ||
 				   name == "level" || name == "profile" || name == "slices" || name == "rc_min_rate" || name == "rc_max_rate" ||
-				   name == "rc_buffer_size" || name == "crf" || name == "cqp")) {
+				   name == "rc_buffer_size" || name == "crf" || name == "cqp" || name == "qp")) {
 		// Check for specific named options
 		if (name == "g")
 			// Set gop_size
@@ -479,6 +479,15 @@ void FFmpegWriter::SetOption(StreamType stream, std::string name, std::string va
 					case AV_CODEC_ID_AV1 :
 						c->bit_rate = 0;
 						av_opt_set_int(c->priv_data, "crf", std::min(std::stoi(value),63), 0);
+						if (strstr(info.vcodec.c_str(), "svt_av1") != NULL) {
+							av_opt_set_int(c->priv_data, "preset", 6, 0);
+							av_opt_set_int(c->priv_data, "forced-idr",1,0);
+						}
+						if (strstr(info.vcodec.c_str(), "rav1e") != NULL) {
+							av_opt_set_int(c->priv_data, "speed", 7, 0);
+							av_opt_set_int(c->priv_data, "tile-rows", 2, 0);
+							av_opt_set_int(c->priv_data, "tile-columns", 4, 0);
+						}
 						break;
 #endif
 					case AV_CODEC_ID_VP8 :
@@ -500,7 +509,14 @@ void FFmpegWriter::SetOption(StreamType stream, std::string name, std::string va
 						}
 						break;
 					case AV_CODEC_ID_HEVC :
-						av_opt_set_int(c->priv_data, "crf", std::min(std::stoi(value), 51), 0); // 0-51
+						if (strstr(info.vcodec.c_str(), "svt_hevc") != NULL) {
+							av_opt_set_int(c->priv_data, "preset", 7, 0);
+							av_opt_set_int(c->priv_data, "forced-idr",1,0);
+							av_opt_set_int(c->priv_data, "qp",std::min(std::stoi(value), 51),0);
+						}
+						else {
+							av_opt_set_int(c->priv_data, "crf", std::min(std::stoi(value), 51), 0); // 0-51
+						}
 						if (std::stoi(value) == 0) {
 							av_opt_set(c->priv_data, "preset", "veryslow", 0);
 							av_opt_set_int(c->priv_data, "lossless", 1, 0);
@@ -520,6 +536,48 @@ void FFmpegWriter::SetOption(StreamType stream, std::string name, std::string va
 						c->bit_rate = (int) (mbs);
 				}
 			}
+#endif
+		} else if (name == "qp") {
+			// encode quality and special settings like lossless
+			// This might be better in an extra methods as more options
+			// and way to set quality are possible
+#if (LIBAVCODEC_VERSION_MAJOR >= 58)
+				switch (c->codec_id) {
+					case AV_CODEC_ID_AV1 :
+						c->bit_rate = 0;
+						if (strstr(info.vcodec.c_str(), "svt_av1") != NULL) {
+							av_opt_set_int(c->priv_data, "qp", std::min(std::stoi(value),63), 0);
+							av_opt_set_int(c->priv_data, "preset", 6, 0);
+							av_opt_set_int(c->priv_data, "forced-idr",1,0);
+						}
+						else if (strstr(info.vcodec.c_str(), "rav1e") != NULL) {
+							// Set number of tiles to a fixed value
+							// TODO Let user choose number of tiles 
+							av_opt_set_int(c->priv_data, "qp", std::min(std::stoi(value),255), 0);
+							av_opt_set_int(c->priv_data, "speed", 7, 0);
+							av_opt_set_int(c->priv_data, "tile-rows", 2, 0);		// number of rows
+							av_opt_set_int(c->priv_data, "tile-columns", 4, 0);		// number of columns
+						}
+						else if (strstr(info.vcodec.c_str(), "aom") != NULL) {
+							// Set number of tiles to a fixed value
+							// TODO Let user choose number of tiles 
+							// libaom doesn't have qp only crf
+							av_opt_set_int(c->priv_data, "crf", std::min(std::stoi(value),63), 0);
+							av_opt_set_int(c->priv_data, "tile-rows", 1, 0);		// log2 of number of rows
+							av_opt_set_int(c->priv_data, "tile-columns", 2, 0);		// log2 of number of columns
+						}
+						else {
+							av_opt_set_int(c->priv_data, "crf", std::min(std::stoi(value),63), 0);
+						}
+					case AV_CODEC_ID_HEVC :
+						c->bit_rate = 0;
+						if (strstr(info.vcodec.c_str(), "svt_hevc") != NULL) {
+							av_opt_set_int(c->priv_data, "qp", std::min(std::stoi(value),51), 0);
+							av_opt_set_int(c->priv_data, "preset", 7, 0);
+							av_opt_set_int(c->priv_data, "forced-idr",1,0);
+						}
+						break;
+				}
 #endif
 		} else {
 			// Set AVOption
@@ -801,6 +859,9 @@ void FFmpegWriter::flush_encoders() {
 #if (LIBAVFORMAT_VERSION_MAJOR < 58)
 	if (info.has_video && video_codec && AV_GET_CODEC_TYPE(video_st) == AVMEDIA_TYPE_VIDEO && (oc->oformat->flags & AVFMT_RAWPICTURE) && AV_FIND_DECODER_CODEC_ID(video_st) == AV_CODEC_ID_RAWVIDEO)
 		return;
+#else
+	if (info.has_video && video_codec && AV_GET_CODEC_TYPE(video_st) == AVMEDIA_TYPE_VIDEO && AV_FIND_DECODER_CODEC_ID(video_st) == AV_CODEC_ID_RAWVIDEO)
+		return;
 #endif

 	int error_code = 0;
@@ -1222,6 +1283,13 @@ AVStream *FFmpegWriter::add_video_stream() {
 	st->avg_frame_rate = av_inv_q(c->time_base);
 	st->time_base.num = info.video_timebase.num;
 	st->time_base.den = info.video_timebase.den;
+#if (LIBAVFORMAT_VERSION_MAJOR >= 58)
+	#pragma GCC diagnostic push
+	#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	st->codec->time_base.num = info.video_timebase.num;
+	st->codec->time_base.den = info.video_timebase.den;
+	#pragma GCC diagnostic pop
+#endif

 	c->gop_size = 12; /* TODO: add this to "info"... emit one intra frame every twelve frames at most */
 	c->max_b_frames = 10;
@@ -1962,10 +2030,13 @@ void FFmpegWriter::process_video_packet(std::shared_ptr<Frame> frame) {
 bool FFmpegWriter::write_video_packet(std::shared_ptr<Frame> frame, AVFrame *frame_final) {
 #if (LIBAVFORMAT_VERSION_MAJOR >= 58)
 	ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::write_video_packet", "frame->number", frame->number, "oc->oformat->flags", oc->oformat->flags);
+
+	if (AV_GET_CODEC_TYPE(video_st) == AVMEDIA_TYPE_VIDEO && AV_FIND_DECODER_CODEC_ID(video_st) == AV_CODEC_ID_RAWVIDEO) {
 #else
 	ZmqLogger::Instance()->AppendDebugMethod("FFmpegWriter::write_video_packet", "frame->number", frame->number, "oc->oformat->flags & AVFMT_RAWPICTURE", oc->oformat->flags & AVFMT_RAWPICTURE);

 	if (oc->oformat->flags & AVFMT_RAWPICTURE) {
+#endif
 		// Raw video case.
 		AVPacket pkt;
 		av_init_packet(&pkt);
@@ -1990,7 +2061,6 @@ bool FFmpegWriter::write_video_packet(std::shared_ptr<Frame> frame, AVFrame *fra
 		AV_FREE_PACKET(&pkt);

 	} else
-#endif
 	{

 		AVPacket pkt;
--- a/src/Frame.cpp
+++ b/src/Frame.cpp
@@ -480,6 +480,11 @@ const unsigned char* Frame::GetPixels()
 // Get pixel data (for only a single scan-line)
 const unsigned char* Frame::GetPixels(int row)
 {
+	// Check for blank image
+	if (!image)
+		// Fill with black
+		AddColor(width, height, color);
+
 	// Return array of pixel packets
 	return image->constScanLine(row);
 }
@@ -829,7 +834,7 @@ void Frame::AddImage(std::shared_ptr<QImage> new_image, bool only_odd_lines)
 		if (ret) {
 			return;
 		}
-		
+
 		// Get the frame's image
 		const GenericScopedLock<juce::CriticalSection> lock(addingImageSection);
 		#pragma omp critical (AddImage)
@@ -979,7 +984,8 @@ void Frame::Play()
 		return;

 	juce::AudioDeviceManager deviceManager;
-	String error = deviceManager.initialise (0, /* number of input channels */
+	juce::String error = deviceManager.initialise (
+	        0, /* number of input channels */
 	        2, /* number of output channels */
 	        0, /* no XML settings.. */
 	        true  /* select default device on failure */);
@@ -992,8 +998,8 @@ void Frame::Play()
 	juce::AudioSourcePlayer audioSourcePlayer;
 	deviceManager.addAudioCallback (&audioSourcePlayer);

-	ScopedPointer<AudioBufferSource> my_source;
-	my_source = new AudioBufferSource(audio.get());
+	std::unique_ptr<AudioBufferSource> my_source;
+	my_source.reset (new AudioBufferSource (audio.get()));

 	// Create TimeSliceThread for audio buffering
 	juce::TimeSliceThread my_thread("Audio buffer thread");
@@ -1001,8 +1007,8 @@ void Frame::Play()
 	// Start thread
 	my_thread.startThread();

-	AudioTransportSource transport1;
-	transport1.setSource (my_source,
+	juce::AudioTransportSource transport1;
+	transport1.setSource (my_source.get(),
 			5000, // tells it to buffer this many samples ahead
 			&my_thread,
 			(double) sample_rate,
--- a/src/Timeline.cpp
+++ b/src/Timeline.cpp
@@ -674,6 +674,8 @@ void Timeline::add_layer(std::shared_ptr<Frame> new_frame, Clip* source_clip, in
 	y += (Settings::Instance()->MAX_HEIGHT * source_clip->location_y.GetValue(clip_frame_number)); // move in percentage of final height
 	float shear_x = source_clip->shear_x.GetValue(clip_frame_number);
 	float shear_y = source_clip->shear_y.GetValue(clip_frame_number);
+	float origin_x = source_clip->origin_x.GetValue(clip_frame_number);
+	float origin_y = source_clip->origin_y.GetValue(clip_frame_number);

 	bool transformed = false;
 	QTransform transform;
@@ -681,21 +683,22 @@ void Timeline::add_layer(std::shared_ptr<Frame> new_frame, Clip* source_clip, in
 	// Transform source image (if needed)
 	ZmqLogger::Instance()->AppendDebugMethod("Timeline::add_layer (Build QTransform - if needed)", "source_frame->number", source_frame->number, "x", x, "y", y, "r", r, "sx", sx, "sy", sy);

-	if (!isEqual(r, 0)) {
-		// ROTATE CLIP
-		float origin_x = x + (scaled_source_width / 2.0);
-		float origin_y = y + (scaled_source_height / 2.0);
-		transform.translate(origin_x, origin_y);
-		transform.rotate(r);
-		transform.translate(-origin_x,-origin_y);
+	if (!isEqual(x, 0) || !isEqual(y, 0)) {
+		// TRANSLATE/MOVE CLIP
+		transform.translate(x, y);
 		transformed = true;
 	}

-    if (!isEqual(x, 0) || !isEqual(y, 0)) {
-        // TRANSLATE/MOVE CLIP
-        transform.translate(x, y);
-        transformed = true;
-    }
+	if (!isEqual(r, 0) || !isEqual(shear_x, 0) || !isEqual(shear_y, 0)) {
+		// ROTATE CLIP (around origin_x, origin_y)
+		float origin_x_value = (scaled_source_width * origin_x);
+		float origin_y_value = (scaled_source_height * origin_y);
+		transform.translate(origin_x_value, origin_y_value);
+		transform.rotate(r);
+		transform.shear(shear_x, shear_y);
+		transform.translate(-origin_x_value,-origin_y_value);
+		transformed = true;
+	}

 	// SCALE CLIP (if needed)
 	float source_width_scale = (float(source_size.width()) / float(source_image->width())) * sx;
@@ -706,12 +709,6 @@ void Timeline::add_layer(std::shared_ptr<Frame> new_frame, Clip* source_clip, in
 		transformed = true;
 	}

-    if (!isEqual(shear_x, 0) || !isEqual(shear_y, 0)) {
-        // SHEAR HEIGHT/WIDTH
-        transform.shear(shear_x, shear_y);
-        transformed = true;
-    }
-
 	// Debug output
 	ZmqLogger::Instance()->AppendDebugMethod("Timeline::add_layer (Transform: Composite Image Layer: Prepare)", "source_frame->number", source_frame->number, "new_frame->GetImage()->width()", new_frame->GetImage()->width(), "transformed", transformed);

--- a/src/bindings/ruby/CMakeLists.txt
+++ b/src/bindings/ruby/CMakeLists.txt
@@ -48,13 +48,15 @@ option(SILENCE_RUBY_VERSION_WARNING

 if (${RUBY_VERSION} VERSION_GREATER 2.6.9 AND ${SWIG_VERSION} VERSION_LESS 4.0.3)
  if (NOT ${SILENCE_RUBY_VERSION_WARNING})
-    message(WARNING "
+    message(WARNING "\
 Ruby 2.7.0+ detected, building the libopenshot Ruby API bindings \
-requires a pre-release version of SWIG 4.0.3 with this commit: \
-https://github.com/swig/swig/commit/5542cc228ad10bdc5c91107afb77c808c43bf2a4")
-    message(STATUS "
-To disable this warning, add -DSILENCE_RUBY_VERSION_WARNING:BOOL=1 to the cmake \
-command line, or enable the option in the CMake GUI.")
+requires either SWIG 4.0.3 or an older version patched with this commit: \
+https://github.com/swig/swig/commit/5542cc228ad10bdc5c91107afb77c808c43bf2a4 \
+(Recent Fedora and Ubuntu distro packages of SWIG 4.0.1 have already been \
+patched.)")
+    message(STATUS "To disable the previous warning, add \
+-DSILENCE_RUBY_VERSION_WARNING:BOOL=1 to the cmake command line, \
+or enable the option in the CMake GUI.")
  endif()
 endif()

@@ -72,6 +74,9 @@ endif()
 set_property(SOURCE openshot.i PROPERTY CPLUSPLUS ON)
 set_property(SOURCE openshot.i PROPERTY SWIG_MODULE_NAME openshot)

+### Unbreak std::isfinite()
+add_definitions(-DHAVE_ISFINITE=1)
+
 ### Suppress a ton of warnings in the generated SWIG C++ code
 set(SWIG_CXX_FLAGS "-Wno-unused-variable -Wno-unused-function \
  -Wno-deprecated-copy -Wno-class-memaccess -Wno-cast-function-type \
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -109,6 +109,7 @@ set(OPENSHOT_TEST_FILES
  Clip_Tests.cpp
  Color_Tests.cpp
  Coordinate_Tests.cpp
+  DummyReader_Tests.cpp
  ReaderBase_Tests.cpp
  ImageWriter_Tests.cpp
  FFmpegReader_Tests.cpp
--- a/tests/DummyReader_Tests.cpp
+++ b/tests/DummyReader_Tests.cpp
@@ -0,0 +1,149 @@
+/**
+ * @file
+ * @brief Unit tests for openshot::DummyReader
+ * @author Jonathan Thomas <jonathan@openshot.org>
+ *
+ * @ref License
+ */
+
+/* LICENSE
+ *
+ * Copyright (c) 2008-2019 OpenShot Studios, LLC
+ * <http://www.openshotstudios.com/>. This file is part of
+ * OpenShot Library (libopenshot), an open-source project dedicated to
+ * delivering high quality video editing and animation solutions to the
+ * world. For more information visit <http://www.openshot.org/>.
+ *
+ * OpenShot Library (libopenshot) is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * OpenShot Library (libopenshot) 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with OpenShot Library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UnitTest++.h"
+// Prevent name clashes with juce::UnitTest
+#define DONT_SET_USING_JUCE_NAMESPACE 1
+
+#include "../include/OpenShot.h"
+
+using namespace std;
+using namespace openshot;
+
+TEST (DummyReader_Basic_Constructor) {
+	// Create a default fraction (should be 1/1)
+	openshot::DummyReader r;
+	r.Open(); // Open the reader
+
+	// Check values
+			CHECK_EQUAL(1280, r.info.width);
+			CHECK_EQUAL(768, r.info.height);
+			CHECK_EQUAL(24, r.info.fps.num);
+			CHECK_EQUAL(1, r.info.fps.den);
+			CHECK_EQUAL(44100, r.info.sample_rate);
+			CHECK_EQUAL(2, r.info.channels);
+			CHECK_EQUAL(30.0, r.info.duration);
+}
+
+TEST (DummyReader_Constructor) {
+	// Create a default fraction (should be 1/1)
+	openshot::DummyReader r(openshot::Fraction(30, 1), 1920, 1080, 44100, 2, 60.0);
+	r.Open(); // Open the reader
+
+	// Check values
+	CHECK_EQUAL(1920, r.info.width);
+	CHECK_EQUAL(1080, r.info.height);
+	CHECK_EQUAL(30, r.info.fps.num);
+	CHECK_EQUAL(1, r.info.fps.den);
+	CHECK_EQUAL(44100, r.info.sample_rate);
+	CHECK_EQUAL(2, r.info.channels);
+	CHECK_EQUAL(60.0, r.info.duration);
+}
+
+TEST (DummyReader_Blank_Frame) {
+	// Create a default fraction (should be 1/1)
+	openshot::DummyReader r(openshot::Fraction(30, 1), 1920, 1080, 44100, 2, 30.0);
+	r.Open(); // Open the reader
+
+	// Get a blank frame (because we have not passed a Cache object (full of Frame objects) to the constructor
+	// Check values
+	CHECK_EQUAL(1, r.GetFrame(1)->number);
+	CHECK_EQUAL(1, r.GetFrame(1)->GetPixels(700)[700] == 0); // black pixel
+	CHECK_EQUAL(1, r.GetFrame(1)->GetPixels(701)[701] == 0); // black pixel
+}
+
+TEST (DummyReader_Fake_Frame) {
+
+	// Create cache object to hold test frames
+	CacheMemory cache;
+
+	// Let's create some test frames
+	for (int64_t frame_number = 1; frame_number <= 30; frame_number++) {
+		// Create blank frame (with specific frame #, samples, and channels)
+		// Sample count should be 44100 / 30 fps = 1470 samples per frame
+		int sample_count = 1470;
+		std::shared_ptr<openshot::Frame> f(new openshot::Frame(frame_number, sample_count, 2));
+
+		// Create test samples with incrementing value
+		float *audio_buffer = new float[sample_count];
+		for (int64_t sample_number = 0; sample_number < sample_count; sample_number++) {
+			// Generate an incrementing audio sample value (just as an example)
+			audio_buffer[sample_number] = float(frame_number) + (float(sample_number) / float(sample_count));
+		}
+
+		// Add custom audio samples to Frame (bool replaceSamples, int destChannel, int destStartSample, const float* source,
+		f->AddAudio(true, 0, 0, audio_buffer, sample_count, 1.0); // add channel 1
+		f->AddAudio(true, 1, 0, audio_buffer, sample_count, 1.0); // add channel 2
+
+		// Add test frame to dummy reader
+		cache.Add(f);
+	}
+
+	// Create a default fraction (should be 1/1)
+	openshot::DummyReader r(openshot::Fraction(30, 1), 1920, 1080, 44100, 2, 30.0, &cache);
+	r.Open(); // Open the reader
+
+	// Verify our artificial audio sample data is correct
+	CHECK_EQUAL(1, r.GetFrame(1)->number);
+	CHECK_EQUAL(1, r.GetFrame(1)->GetAudioSamples(0)[0]);
+	CHECK_CLOSE(1.00068033, r.GetFrame(1)->GetAudioSamples(0)[1], 0.00001);
+	CHECK_CLOSE(1.00136054, r.GetFrame(1)->GetAudioSamples(0)[2], 0.00001);
+	CHECK_EQUAL(2, r.GetFrame(2)->GetAudioSamples(0)[0]);
+	CHECK_CLOSE(2.00068033, r.GetFrame(2)->GetAudioSamples(0)[1], 0.00001);
+	CHECK_CLOSE(2.00136054, r.GetFrame(2)->GetAudioSamples(0)[2], 0.00001);
+
+	// Clean up
+	cache.Clear();
+	r.Close();
+}
+
+TEST (DummyReader_Invalid_Fake_Frame) {
+	// Create fake frames (with specific frame #, samples, and channels)
+	std::shared_ptr<openshot::Frame> f1(new openshot::Frame(1, 1470, 2));
+	std::shared_ptr<openshot::Frame> f2(new openshot::Frame(2, 1470, 2));
+
+	// Add test frames to cache object
+	CacheMemory cache;
+	cache.Add(f1);
+	cache.Add(f2);
+
+	// Create a default fraction (should be 1/1)
+	openshot::DummyReader r(openshot::Fraction(30, 1), 1920, 1080, 44100, 2, 30.0, &cache);
+	r.Open();
+
+	// Verify exception
+	CHECK_EQUAL(1, r.GetFrame(1)->number);
+	CHECK_EQUAL(2, r.GetFrame(2)->number);
+	CHECK_THROW(r.GetFrame(3)->number, InvalidFile);
+
+	// Clean up
+	cache.Clear();
+	r.Close();
+}
--- a/version.sh
+++ b/version.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+grep 'set.*(.*PROJECT_VERSION_FULL' CMakeLists.txt\
+ |sed -e 's#set(PROJECT_VERSION_FULL.*"\(.*\)\")#\1#;q'
+