Frame.cpp

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#include <thread>   // for std::this_thread::sleep_for
#include <chrono>   // for std::chrono::milliseconds
#include <iomanip>
 
#include "Frame.h"
#include "AudioBufferSource.h"
#include "AudioResampler.h"
#include "QtUtilities.h"
 
#include <AppConfig.h>
#include <juce_audio_basics/juce_audio_basics.h>
#include <juce_audio_devices/juce_audio_devices.h>
 
#include <QApplication>
#include <QImage>
#include <QPixmap>
#include <QBitmap>
#include <QColor>
#include <QString>
#include <QVector>
#include <QPainter>
#include <QHBoxLayout>
#include <QWidget>
#include <QLabel>
#include <QPointF>
#include <QWidget>
 
using namespace std;
using namespace openshot;
 
// Constructor - image & audio
Frame::Frame(int64_t number, int width, int height, std::string color, int samples, int channels)
    : audio(std::make_shared<juce::AudioBuffer<float>>(channels, samples)),
      number(number), width(width), height(height),
      pixel_ratio(1,1), color(color),
      channels(channels), channel_layout(LAYOUT_STEREO),
      sample_rate(44100),
      has_audio_data(false), has_image_data(false),
      max_audio_sample(0), audio_is_increasing(true)
{
    // zero (fill with silence) the audio buffer
    audio->clear();
}
 
// Delegating Constructor - blank frame
Frame::Frame() : Frame::Frame(1, 1, 1, "#000000", 0, 2) {}
 
// Delegating Constructor - image only
Frame::Frame(int64_t number, int width, int height, std::string color)
    : Frame::Frame(number, width, height, color, 0, 2) {}
 
// Delegating Constructor - audio only
Frame::Frame(int64_t number, int samples, int channels)
    : Frame::Frame(number, 1, 1, "#000000", samples, channels) {}
 
 
// Copy constructor
Frame::Frame ( const Frame &other )
{
    // copy pointers and data
    DeepCopy(other);
}
 
// Assignment operator
Frame& Frame::operator= (const Frame& other)
{
    // copy pointers and data
    DeepCopy(other);
 
    return *this;
}
 
// Copy data and pointers from another Frame instance
void Frame::DeepCopy(const Frame& other)
{
    number = other.number;
    channels = other.channels;
    width = other.width;
    height = other.height;
    channel_layout = other.channel_layout;
    has_audio_data = other.has_audio_data;
    has_image_data = other.has_image_data;
    sample_rate = other.sample_rate;
    pixel_ratio = Fraction(other.pixel_ratio.num, other.pixel_ratio.den);
    color = other.color;
    max_audio_sample = other.max_audio_sample;
    audio_is_increasing = other.audio_is_increasing;
 
    if (other.image)
        image = std::make_shared<QImage>(*(other.image));
    if (other.audio)
        audio = std::make_shared<juce::AudioBuffer<float>>(*(other.audio));
    if (other.wave_image)
        wave_image = std::make_shared<QImage>(*(other.wave_image));
}
 
// Destructor
Frame::~Frame() {
    // Clear all pointers
    image.reset();
    audio.reset();
    #ifdef USE_OPENCV
    imagecv.release();
    #endif
}
 
// Display the frame image to the screen (primarily used for debugging reasons)
void Frame::Display()
{
    if (!QApplication::instance()) {
        // Only create the QApplication once
        static int argc = 1;
        static char* argv[1] = {NULL};
        previewApp = std::make_shared<QApplication>(argc, argv);
    }
 
    // Get preview image
    std::shared_ptr<QImage> previewImage = GetImage();
 
    // Update the image to reflect the correct pixel aspect ration (i.e. to fix non-square pixels)
    if (pixel_ratio.num != 1 || pixel_ratio.den != 1)
    {
        // Resize to fix DAR
        previewImage = std::make_shared<QImage>(previewImage->scaled(
                previewImage->size().width(), previewImage->size().height() * pixel_ratio.Reciprocal().ToDouble(),
                Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
    }
 
    // Create window
    QWidget previewWindow;
    previewWindow.setStyleSheet("background-color: #000000;");
    QHBoxLayout layout;
 
    // Create label with current frame's image
    QLabel previewLabel;
    previewLabel.setPixmap(QPixmap::fromImage(*previewImage));
    previewLabel.setMask(QPixmap::fromImage(*previewImage).mask());
    layout.addWidget(&previewLabel);
 
    // Show the window
    previewWindow.setLayout(&layout);
    previewWindow.show();
    previewApp->exec();
}
 
// Get an audio waveform image
std::shared_ptr<QImage> Frame::GetWaveform(int width, int height, int Red, int Green, int Blue, int Alpha)
{
    // Clear any existing waveform image
    ClearWaveform();
 
    // Init a list of lines
    QVector<QPointF> lines;
    QVector<QPointF> labels;
 
    // Calculate width of an image based on the # of samples
    int total_samples = GetAudioSamplesCount();
    if (total_samples > 0)
    {
        // If samples are present...
        int new_height = 200 * audio->getNumChannels();
        int height_padding = 20 * (audio->getNumChannels() - 1);
        int total_height = new_height + height_padding;
        int total_width = 0;
        float zero_height = 1.0; // Used to clamp near-zero vales to this value to prevent gaps
 
        // Loop through each audio channel
        float Y = 100.0;
        for (int channel = 0; channel < audio->getNumChannels(); channel++)
        {
            float X = 0.0;
 
            // Get audio for this channel
            const float *samples = audio->getReadPointer(channel);
 
            for (int sample = 0; sample < GetAudioSamplesCount(); sample++, X++)
            {
                // Sample value (scaled to -100 to 100)
                float value = samples[sample] * 100.0;
 
                // Set threshold near zero (so we don't allow near-zero values)
                // This prevents empty gaps from appearing in the waveform
                if (value > -zero_height && value < 0.0) {
                    value = -zero_height;
                } else if (value > 0.0 && value < zero_height) {
                    value = zero_height;
                }
 
                // Append a line segment for each sample
                lines.push_back(QPointF(X, Y));
                lines.push_back(QPointF(X, Y - value));
            }
 
            // Add Channel Label Coordinate
            labels.push_back(QPointF(5.0, Y - 5.0));
 
            // Increment Y
            Y += (200 + height_padding);
            total_width = X;
        }
 
        // Create blank image
        wave_image = std::make_shared<QImage>(
            total_width, total_height, QImage::Format_RGBA8888_Premultiplied);
        wave_image->fill(QColor(0,0,0,0));
 
        // Load QPainter with wave_image device
        QPainter painter(wave_image.get());
 
        // Set pen color
        QPen pen;
        pen.setColor(QColor(Red, Green, Blue, Alpha));
        pen.setWidthF(1.0);
        pen.setStyle(Qt::SolidLine);
        painter.setPen(pen);
 
        // Draw the waveform
        painter.drawLines(lines);
        painter.end();
    }
    else
    {
        // No audio samples present
        wave_image = std::make_shared<QImage>(width, height, QImage::Format_RGBA8888_Premultiplied);
        wave_image->fill(QColor(QString::fromStdString("#000000")));
    }
 
    // Resize Image (if needed)
    if (wave_image->width() != width || wave_image->height() != height) {
        QImage scaled_wave_image = wave_image->scaled(width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
        wave_image = std::make_shared<QImage>(scaled_wave_image);
    }
 
    // Return new image
    return wave_image;
}
 
// Clear the waveform image (and deallocate its memory)
void Frame::ClearWaveform()
{
    if (wave_image)
        wave_image.reset();
}
 
// Get an audio waveform image pixels
const unsigned char* Frame::GetWaveformPixels(int width, int height, int Red, int Green, int Blue, int Alpha)
{
    // Get audio wave form image
    wave_image = GetWaveform(width, height, Red, Green, Blue, Alpha);
 
    // Return array of pixel packets
    return wave_image->constBits();
}
 
// Display the wave form
void Frame::DisplayWaveform()
{
    // Get audio wave form image
    GetWaveform(720, 480, 0, 123, 255, 255);
 
    if (!QApplication::instance()) {
        // Only create the QApplication once
        static int argc = 1;
        static char* argv[1] = {NULL};
        previewApp = std::make_shared<QApplication>(argc, argv);
    }