WIP: Release of 0.5.0 libopenshot (for OpenShot 3.4)

CMakeLists.txt

@@ -24,8 +24,8 @@ For more information, please visit <http://www.openshot.org/>.
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
 
 ################ PROJECT VERSION ####################
-set(PROJECT_VERSION_FULL "0.4.0")
-set(PROJECT_SO_VERSION 27)
+set(PROJECT_VERSION_FULL "0.5.0")
+set(PROJECT_SO_VERSION 28)
 
 # Remove the dash and anything following, to get the #.#.# version for project()
 STRING(REGEX REPLACE "\-.*$" "" VERSION_NUM "${PROJECT_VERSION_FULL}")

src/AudioWaveformer.cpp

@@ -12,6 +12,13 @@
 
 #include "AudioWaveformer.h"
 
+#include <cmath>
+
+#include <algorithm>
+#include <vector>
+
+#include "Clip.h"
+
 
 using namespace std;
 using namespace openshot;
@@ -31,104 +38,154 @@ AudioWaveformer::~AudioWaveformer()
 
 // Extract audio samples from any ReaderBase class
 AudioWaveformData AudioWaveformer::ExtractSamples(int channel, int num_per_second, bool normalize) {
-    AudioWaveformData data;
-
-    if (reader) {
-        // Open reader (if needed)
-        bool does_reader_have_video = reader->info.has_video;
-        if (!reader->IsOpen()) {
-            reader->Open();
-        }
-        // Disable video for faster processing
-        reader->info.has_video = false;
-
-        int sample_rate = reader->info.sample_rate;
-        int sample_divisor = sample_rate / num_per_second;
-        int total_samples = num_per_second * (reader->info.duration + 1.0);
-        int extracted_index = 0;
-
-        // Force output to zero elements for non-audio readers
-        if (!reader->info.has_audio) {
-            total_samples = 0;
-        }
-
-        // Resize and clear audio buffers
-        data.resize(total_samples);
-        data.zero(total_samples);
-
-        // Bail out, if no samples needed
-        if (total_samples == 0 || reader->info.channels == 0) {
-            return data;
-        }
-
-        // Loop through all frames
-        int sample_index = 0;
-        float samples_max = 0.0;
-        float chunk_max = 0.0;
-        float chunk_squared_sum = 0.0;
-
-        // How many channels are we using
-        int channel_count = 1;
-        if (channel == -1) {
-            channel_count = reader->info.channels;
-        }
-
-        for (auto f = 1; f <= reader->info.video_length; f++) {
-            // Get next frame
-            shared_ptr<openshot::Frame> frame = reader->GetFrame(f);
-
-            // Cache channels for this frame, to reduce # of calls to frame->GetAudioSamples
-            float* channels[channel_count];
-            for (auto channel_index = 0; channel_index < reader->info.channels; channel_index++) {
-                if (channel == channel_index || channel == -1) {
-                    channels[channel_index] = frame->GetAudioSamples(channel_index);
-                }
-            }
-
-            // Get sample value from a specific channel (or all channels)
-            for (auto s = 0; s < frame->GetAudioSamplesCount(); s++) {
-                for (auto channel_index = 0; channel_index < reader->info.channels; channel_index++) {
-                    if (channel == channel_index || channel == -1) {
-                        float *samples = channels[channel_index];
-                        float rms_sample_value = std::sqrt(samples[s] * samples[s]);
-
-                        // Accumulate sample averages
-                        chunk_squared_sum += rms_sample_value;
-                        chunk_max = std::max(chunk_max, rms_sample_value);
-                    }
-                }
-
-                sample_index += 1;
-
-                // Cut-off reached
-                if (sample_index % sample_divisor == 0) {
-                    float avg_squared_sum = chunk_squared_sum / (sample_divisor * channel_count);
-                    data.max_samples[extracted_index] = chunk_max;
-                    data.rms_samples[extracted_index] = avg_squared_sum;
-                    extracted_index++;
-
-                    // Track max/min values
-                    samples_max = std::max(samples_max, chunk_max);
-
-                    // reset sample total and index
-                    sample_index = 0;
-                    chunk_max = 0.0;
-                    chunk_squared_sum = 0.0;
-                }
-            }
-        }
-
-        // Scale all values to the -1 to +1 range (regardless of how small or how large the
-        // original audio sample values are)
-        if (normalize && samples_max > 0.0) {
-            float scale = 1.0f / samples_max;
-            data.scale(total_samples, scale);
-        }
-
-        // Resume previous has_video value
-        reader->info.has_video = does_reader_have_video;
-    }
-
-
-    return data;
+	AudioWaveformData data;
+
+	if (!reader || num_per_second <= 0) {
+		return data;
+	}
+
+	// Open reader (if needed)
+	bool does_reader_have_video = reader->info.has_video;
+	if (!reader->IsOpen()) {
+		reader->Open();
+	}
+	// Disable video for faster processing
+	reader->info.has_video = false;
+
+	int sample_rate = reader->info.sample_rate;
+	if (sample_rate <= 0) {
+		sample_rate = num_per_second;
+	}
+	int sample_divisor = sample_rate / num_per_second;
+	if (sample_divisor <= 0) {
+		sample_divisor = 1;
+	}
+
+	// Determine length of video frames (for waveform)
+	int64_t reader_video_length = reader->info.video_length;
+	if (const auto *clip = dynamic_cast<Clip*>(reader)) {
+		// If Clip-based reader, and time keyframes present
+		if (clip->time.GetCount() > 1) {
+			reader_video_length = clip->time.GetLength();
+		}
+	}
+	if (reader_video_length < 0) {
+		reader_video_length = 0;
+	}
+	float reader_duration = reader->info.duration;
+	double fps_value = reader->info.fps.ToDouble();
+	float frames_duration = 0.0f;
+	if (reader_video_length > 0 && fps_value > 0.0) {
+		frames_duration = static_cast<float>(reader_video_length / fps_value);
+	}
+	const bool has_source_length = reader->info.video_length > 0;
+	const bool frames_extended = has_source_length && reader_video_length > reader->info.video_length;
+	if (reader_duration <= 0.0f) {
+		reader_duration = frames_duration;
+	} else if ((frames_extended || !has_source_length) && frames_duration > reader_duration + 1e-4f) {
+		reader_duration = frames_duration;
+	}
+	if (reader_duration < 0.0f) {
+		reader_duration = 0.0f;
+	}
+
+	if (!reader->info.has_audio) {
+		reader->info.has_video = does_reader_have_video;
+		return data;
+	}
+
+	int total_samples = static_cast<int>(std::ceil(reader_duration * num_per_second));
+	if (total_samples <= 0 || reader->info.channels == 0) {
+		reader->info.has_video = does_reader_have_video;
+		return data;
+	}
+
+	if (channel != -1 && (channel < 0 || channel >= reader->info.channels)) {
+		reader->info.has_video = does_reader_have_video;
+		return data;
+	}
+
+	// Resize and clear audio buffers
+	data.resize(total_samples);
+	data.zero(total_samples);
+
+	int extracted_index = 0;
+	int sample_index = 0;
+	float samples_max = 0.0f;
+	float chunk_max = 0.0f;
+	float chunk_squared_sum = 0.0f;
+
+	int channel_count = (channel == -1) ? reader->info.channels : 1;
+	std::vector<float*> channels(reader->info.channels, nullptr);
+
+	for (int64_t f = 1; f <= reader_video_length && extracted_index < total_samples; f++) {
+		std::shared_ptr<openshot::Frame> frame = reader->GetFrame(f);
+
+		for (int channel_index = 0; channel_index < reader->info.channels; channel_index++) {
+			if (channel == channel_index || channel == -1) {
+				channels[channel_index] = frame->GetAudioSamples(channel_index);
+			}
+		}
+
+		for (int s = 0; s < frame->GetAudioSamplesCount(); s++) {
+			for (int channel_index = 0; channel_index < reader->info.channels; channel_index++) {
+				if (channel == channel_index || channel == -1) {
+					float *samples = channels[channel_index];
+					if (!samples) {
+						continue;
+					}
+					float rms_sample_value = std::sqrt(samples[s] * samples[s]);
+
+					chunk_squared_sum += rms_sample_value;
+					chunk_max = std::max(chunk_max, rms_sample_value);
+				}
+			}
+
+			sample_index += 1;
+
+			if (sample_index % sample_divisor == 0) {
+				float avg_squared_sum = 0.0f;
+				if (channel_count > 0) {
+					avg_squared_sum = chunk_squared_sum / static_cast<float>(sample_divisor * channel_count);
+				}
+
+				if (extracted_index < total_samples) {
+					data.max_samples[extracted_index] = chunk_max;
+					data.rms_samples[extracted_index] = avg_squared_sum;
+					samples_max = std::max(samples_max, chunk_max);
+					extracted_index++;
+				}
+
+				sample_index = 0;
+				chunk_max = 0.0f;
+				chunk_squared_sum = 0.0f;
+
+				if (extracted_index >= total_samples) {
+					break;
+				}
+			}
+		}
+	}
+
+	if (sample_index > 0 && extracted_index < total_samples) {
+		float avg_squared_sum = 0.0f;
+		if (channel_count > 0) {
+			avg_squared_sum = chunk_squared_sum / static_cast<float>(sample_index * channel_count);
+		}
+
+		data.max_samples[extracted_index] = chunk_max;
+		data.rms_samples[extracted_index] = avg_squared_sum;
+		samples_max = std::max(samples_max, chunk_max);
+		extracted_index++;
+	}
+
+	if (normalize && samples_max > 0.0f) {
+		float scale = 1.0f / samples_max;
+		data.scale(total_samples, scale);
+	}
+
+	reader->info.has_video = does_reader_have_video;
+
+	return data;
 }
+

src/CMakeLists.txt

@@ -117,6 +117,7 @@ set(EFFECTS_SOURCES
   effects/Deinterlace.cpp
   effects/Hue.cpp
   effects/LensFlare.cpp
+  effects/AnalogTape.cpp
   effects/Mask.cpp
   effects/Negate.cpp
   effects/Pixelate.cpp