Implemented Initial audio effects

- Compressor
- Equalizer 
- Distortion
- Noise

src/CMakeLists.txt

@@ -130,7 +130,11 @@ set(EFFECTS_SOURCES
   effects/Pixelate.cpp
   effects/Saturation.cpp
   effects/Shift.cpp
-  effects/Wave.cpp)
+  effects/Wave.cpp
+  audio_effects/Noise.cpp
+  audio_effects/Distortion.cpp
+  audio_effects/ParametricEQ.cpp
+  audio_effects/Compressor.cpp)
 
 # Qt video player components
 set(QT_PLAYER_SOURCES

src/EffectInfo.cpp

@@ -88,6 +88,18 @@ EffectBase* EffectInfo::CreateEffect(std::string effect_type) {
 	else if (effect_type == "Wave")
 		return new Wave();
 
+	else if(effect_type == "Noise")
+		return new Noise();
+
+	else if(effect_type == "Distortion")
+		return new Distortion();
+
+	else if(effect_type == "ParametricEQ")
+		return new ParametricEQ();
+
+	else if(effect_type == "Compressor")
+		return new Compressor();
+
 	#ifdef USE_OPENCV
 	else if(effect_type == "Stabilizer")
 		return new Stabilizer();
@@ -124,6 +136,11 @@ Json::Value EffectInfo::JsonValue() {
 	root.append(Saturation().JsonInfo());
 	root.append(Shift().JsonInfo());
 	root.append(Wave().JsonInfo());
+	/* Audio */
+	root.append(Noise().JsonInfo());
+	root.append(Distortion().JsonInfo());
+	root.append(ParametricEQ().JsonInfo());
+	root.append(Compressor().JsonInfo());
 
 	#ifdef USE_OPENCV
 	root.append(Stabilizer().JsonInfo());

src/Effects.h

@@ -48,6 +48,13 @@
 #include "effects/Shift.h"
 #include "effects/Wave.h"
 
+/* Audio Effects */
+#include "audio_effects/Noise.h"
+#include "audio_effects/Distortion.h"
+#include "audio_effects/ParametricEQ.h"
+#include "audio_effects/Compressor.h"
+
+/* OpenCV Effects */
 #ifdef USE_OPENCV
 #include "effects/ObjectDetection.h"
 #include "effects/Tracker.h"

src/Enums.h

@@ -80,5 +80,37 @@ namespace openshot
 		VOLUME_MIX_AVERAGE,	///< Evenly divide the overlapping clips volume keyframes, so that the sum does not exceed 100%
 		VOLUME_MIX_REDUCE 	///< Reduce volume by about %25, and then mix (louder, but could cause pops if the sum exceeds 100%)
 	};
+
+
+	/// This enumeration determines the distortion type of Distortion Effect.
+	enum DistortionType
+	{
+		HARD_CLIPPING,
+		SOFT_CLIPPING,
+		EXPONENTIAL,
+		FULL_WAVE_RECTIFIER,
+		HALF_WAVE_RECTIFIER,
+	};
+
+	/// This enumeration determines the filter type of ParametricEQ Effect.
+	enum FilterType
+	{
+		LOW_PASS,
+		HIGH_PASS,
+		LOW_SHELF,
+		HIGH_SHELF,
+		BAND_PASS,
+		BAND_STOP,
+		PEAKING_NOTCH,
+	};
+
+	/// This enumeration determines the compressor mode of compressor Effect.
+	enum CompressorMode
+	{
+		COMPRESSOR,
+		LIMITER,
+		EXPANDER,
+		NOISE_GATE,
+	};
 }
 #endif

src/Frame.h

@@ -109,7 +109,7 @@ namespace openshot
 	private:
 		std::shared_ptr<QImage> image;
 		std::shared_ptr<QImage> wave_image;
-		std::shared_ptr<juce::AudioSampleBuffer> audio;
+
 		std::shared_ptr<QApplication> previewApp;
 		juce::CriticalSection addingImageSection;
         juce::CriticalSection addingAudioSection;
@@ -131,6 +131,7 @@ namespace openshot
 		int constrain(int color_value);
 
 	public:
+		std::shared_ptr<juce::AudioSampleBuffer> audio;
 		int64_t number;	 ///< This is the frame number (starting at 1)
 		bool has_audio_data; ///< This frame has been loaded with audio data
 		bool has_image_data; ///< This frame has been loaded with pixel data

src/audio_effects/Compressor.cpp

@@ -0,0 +1,260 @@
+/**
+ * @file
+ * @brief Source file for Compressor audio effect class
+ * @author 
+ *
+ * @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 "Compressor.h"
+#include "Exceptions.h"
+
+using namespace openshot;
+
+/// Blank constructor, useful when using Json to load the effect properties
+Compressor::Compressor() : mode(COMPRESSOR), threshold(1), ratio(1), attack(1), release(1), makeup_gain(1), bypass(false) {
+	// Init effect properties
+	init_effect_details();
+}
+
+// Default constructor
+Compressor::Compressor(openshot::CompressorMode new_mode, Keyframe new_threshold, Keyframe new_ratio, Keyframe new_attack, Keyframe new_release, Keyframe new_makeup_gain, Keyframe new_bypass) : 
+					   mode(new_mode), threshold(new_threshold), ratio(new_ratio), attack(new_attack), release(new_release), makeup_gain(new_makeup_gain), bypass(new_bypass)
+{
+	// Init effect properties
+	init_effect_details();
+}
+
+// Init effect settings
+void Compressor::init_effect_details()
+{
+	/// Initialize the values of the EffectInfo struct.
+	InitEffectInfo();
+
+	/// Set the effect info
+	info.class_name = "Compressor";
+	info.name = "Compressor";
+	info.description = "Add compressor on the frame's sound.";
+	info.has_audio = true;
+	info.has_video = false;
+
+    input_level = 0.0f;
+    yl_prev = 0.0f;
+
+
+}
+
+// This method is required for all derived classes of EffectBase, and returns a
+// modified openshot::Frame object
+std::shared_ptr<openshot::Frame> Compressor::GetFrame(std::shared_ptr<openshot::Frame> frame, int64_t frame_number)
+{
+	// Adding Compressor
+    const int num_input_channels = frame->audio->getNumChannels();
+    const int num_output_channels = frame->audio->getNumChannels();
+    const int num_samples = frame->audio->getNumSamples();
+
+    mixed_down_input.setSize(1, num_samples);
+	inverse_sample_rate = 1.0f / frame->SampleRate(); //(float)getSampleRate();
+    inverseE = 1.0f / M_E;
+
+	if ((bool)bypass.GetValue(frame_number))
+        return frame;
+
+	mixed_down_input.clear();
+
+	for (int channel = 0; channel < num_input_channels; ++channel)
+        mixed_down_input.addFrom(0, 0, *frame->audio, channel, 0, num_samples, 1.0f / num_input_channels);
+
+    for (int sample = 0; sample < num_samples; ++sample) {
+		bool expander = (bool)mode;
+        float T = threshold.GetValue(frame_number);
+        float R = ratio.GetValue(frame_number);
+        float alphaA = calculateAttackOrRelease(attack.GetValue(frame_number));
+        float alphaR = calculateAttackOrRelease(release.GetValue(frame_number));
+        float gain = makeup_gain.GetValue(frame_number);
+		float input_squared = powf(mixed_down_input.getSample(0, sample), 2.0f);
+
+		if (expander) {
+            const float average_factor = 0.9999f;
+            input_level = average_factor * input_level + (1.0f - average_factor) * input_squared;
+        } else {
+            input_level = input_squared;
+        }
+        xg = (input_level <= 1e-6f) ? -60.0f : 10.0f * log10f(input_level);
+
+
+        // Expander
+        if (expander) {
+            if (xg > T)
+                yg = xg;
+            else
+                yg = T + (xg - T) * R;
+
+            xl = xg - yg;
+
+            if (xl < yl_prev)
+                yl = alphaA * yl_prev + (1.0f - alphaA) * xl;
+            else
+                yl = alphaR * yl_prev + (1.0f - alphaR) * xl;
+
+        // Compressor
+        } else {
+            if (xg < T)
+                yg = xg;
+            else
+                yg = T + (xg - T) / R;
+
+            xl = xg - yg;
+
+            if (xl > yl_prev)
+                yl = alphaA * yl_prev + (1.0f - alphaA) * xl;
+            else
+                yl = alphaR * yl_prev + (1.0f - alphaR) * xl;
+        }
+
+        control = powf (10.0f, (gain - yl) * 0.05f);
+        yl_prev = yl;
+
+        for (int channel = 0; channel < num_input_channels; ++channel) {
+            float new_value = frame->audio->getSample(channel, sample)*control;
+            frame->audio->setSample(channel, sample, new_value);
+        }
+	}
+
+    for (int channel = num_input_channels; channel < num_output_channels; ++channel)
+        frame->audio->clear(channel, 0, num_samples);
+
+	// return the modified frame
+	return frame;
+}
+
+float Compressor::calculateAttackOrRelease(float value)
+{
+    if (value == 0.0f)
+        return 0.0f;
+    else
+        return pow (inverseE, inverse_sample_rate / value);
+}
+
+// Generate JSON string of this object
+std::string Compressor::Json() const {
+
+	// Return formatted string
+	return JsonValue().toStyledString();
+}
+
+// Generate Json::Value for this object
+Json::Value Compressor::JsonValue() const {
+
+	// Create root json object
+	Json::Value root = EffectBase::JsonValue(); // get parent properties
+	root["type"] = info.class_name;
+	root["mode"] = mode;
+	root["threshold"] = threshold.JsonValue();
+	root["ratio"] = ratio.JsonValue();
+	root["attack"] = attack.JsonValue();
+	root["release"] = release.JsonValue();
+	root["makeup_gain"] = makeup_gain.JsonValue();
+	root["bypass"] = bypass.JsonValue();
+
+	// return JsonValue
+	return root;
+}
+
+// Load JSON string into this object
+void Compressor::SetJson(const std::string value) {
+
+	// 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 Compressor::SetJsonValue(const Json::Value root) {
+
+	// Set parent data
+	EffectBase::SetJsonValue(root);
+
+	// Set data from Json (if key is found)
+	if (!root["mode"].isNull())
+		mode = (CompressorMode)root["mode"].asInt();
+
+	if (!root["threshold"].isNull())
+		threshold.SetJsonValue(root["threshold"]);
+
+	if (!root["ratio"].isNull())
+		ratio.SetJsonValue(root["ratio"]);
+
+	if (!root["attack"].isNull())
+		attack.SetJsonValue(root["attack"]);
+
+	if (!root["release"].isNull())
+		release.SetJsonValue(root["release"]);
+
+	if (!root["makeup_gain"].isNull())
+		makeup_gain.SetJsonValue(root["makeup_gain"]);
+
+	if (!root["bypass"].isNull())
+		bypass.SetJsonValue(root["bypass"]);
+}
+
+// Get all properties for a specific frame
+std::string Compressor::PropertiesJSON(int64_t requested_frame) const {
+
+	// Generate JSON properties list
+	Json::Value root;
+	root["id"] = add_property_json("ID", 0.0, "string", Id(), NULL, -1, -1, true, requested_frame);
+	root["layer"] = add_property_json("Track", Layer(), "int", "", NULL, 0, 20, false, requested_frame);
+	root["start"] = add_property_json("Start", Start(), "float", "", NULL, 0, 1000 * 60 * 30, false, requested_frame);
+	root["end"] = add_property_json("End", End(), "float", "", NULL, 0, 1000 * 60 * 30, false, requested_frame);
+	root["duration"] = add_property_json("Duration", Duration(), "float", "", NULL, 0, 1000 * 60 * 30, true, requested_frame);
+
+	// Keyframes
+	root["mode"] = add_property_json("Mode", mode, "int", "", NULL, 0, 3, false, requested_frame);
+	root["threshold"] = add_property_json("Threshold (dB)", threshold.GetValue(requested_frame), "float", "", &threshold, -60, 60, false, requested_frame);
+	root["ratio"] = add_property_json("Ratio", ratio.GetValue(requested_frame), "float", "", &ratio, 1, 100, false, requested_frame);
+	root["attack"] = add_property_json("Attack", attack.GetValue(requested_frame), "float", "", &attack, 0.1, 100, false, requested_frame);
+	root["release"] = add_property_json("Release", release.GetValue(requested_frame), "float", "", &release, 10, 1000, false, requested_frame);
+	root["makeup_gain"] = add_property_json("Makeup gain", makeup_gain.GetValue(requested_frame), "float", "", &makeup_gain, -12, 12, false, requested_frame);
+	root["bypass"] = add_property_json("Bypass", bypass.GetValue(requested_frame), "bool", "", &bypass, 0, 1, false, requested_frame);
+
+	// Add mode choices (dropdown style)
+	root["mode"]["choices"].append(add_property_choice_json("Compressor", COMPRESSOR, mode));
+	root["mode"]["choices"].append(add_property_choice_json("Limiter", LIMITER, mode));
+	root["mode"]["choices"].append(add_property_choice_json("Expander", EXPANDER, mode));
+	root["mode"]["choices"].append(add_property_choice_json("Noise Gate", NOISE_GATE, mode));
+
+	// Return formatted string
+	return root.toStyledString();
+}