AudioWaveformer.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2022 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_WAVEFORMER_H
#define OPENSHOT_WAVEFORMER_H
 
#include "ReaderBase.h"
#include "Frame.h"
#include "KeyFrame.h"
#include "Fraction.h"
#include <memory>
#include <vector>
#include <string>
 
 
namespace openshot {
 
    struct AudioWaveformData
    {
        std::vector<float> max_samples;
        std::vector<float> rms_samples;
 
        void resize(int total_samples) {
            max_samples.resize(total_samples);
            rms_samples.resize(total_samples);
        }
 
        void zero(int total_samples) {
            std::fill(max_samples.begin(), max_samples.end(), 0);
            std::fill(rms_samples.begin(), rms_samples.end(), 0);
        }
 
        void scale(int total_samples, float factor) {
            for (auto s = 0; s < total_samples; s++) {
                max_samples[s] *= factor;
                rms_samples[s] *= factor;
            }
        }
 
        void clear() {
            max_samples.clear();
            max_samples.shrink_to_fit();
            rms_samples.clear();
            rms_samples.shrink_to_fit();
        }
 
        std::vector<std::vector<float>> vectors() {
            std::vector<std::vector<float>> output;
            output.push_back(max_samples);
            output.push_back(rms_samples);
            return output;
        }
    };
 
    class AudioWaveformer {
    private:
        ReaderBase* reader;
        std::unique_ptr<ReaderBase> detached_reader; 
        ReaderBase* resolved_reader = nullptr;       
        bool source_initialized = false;
 
    public:
        AudioWaveformer(ReaderBase* reader);
 
        AudioWaveformData ExtractSamples(int channel, int num_per_second, bool normalize);
 
        AudioWaveformData ExtractSamples(const std::string& path, int channel, int num_per_second, bool normalize);
 
        AudioWaveformData ApplyKeyframes(const AudioWaveformData& base,
                                         const openshot::Keyframe* time_keyframe,
                                         const openshot::Keyframe* volume_keyframe,
                                         const openshot::Fraction& project_fps,
                                         const openshot::Fraction& source_fps,
                                         int source_channels,
                                         int num_per_second,
                                         int channel,
                                         bool normalize);
 
        AudioWaveformData ExtractSamples(const std::string& path,
                                         const openshot::Keyframe* time_keyframe,
                                         const openshot::Keyframe* volume_keyframe,
                                         const openshot::Fraction& project_fps,
                                         int channel,
                                         int num_per_second,
                                         bool normalize);
 
        ~AudioWaveformer();
 
    private:
        AudioWaveformData ExtractSamplesFromReader(openshot::ReaderBase* source_reader, int channel, int num_per_second, bool normalize);
        openshot::ReaderBase* ResolveSourceReader(openshot::ReaderBase* source_reader);
        openshot::Fraction ResolveSourceFPS(openshot::ReaderBase* source_reader);
        openshot::ReaderBase* ResolveWaveformReader();
    };
 
}
 
#endif