QtPlayer.cpp

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#include "QtPlayer.h"
 
#include "AudioDevices.h"
#include "Clip.h"
#include "FFmpegReader.h"
#include "Timeline.h"
#include "Qt/PlayerPrivate.h"
#include "Qt/VideoRenderer.h"
 
namespace openshot
{
 
    using AudioDeviceList = std::vector<std::pair<std::string, std::string>>;
 
    // Delegating constructor
    QtPlayer::QtPlayer()
    : QtPlayer::QtPlayer(new VideoRenderer())
    { }
 
    // Constructor
    QtPlayer::QtPlayer(openshot::RendererBase *rb)
    : PlayerBase()
    , p(new openshot::PlayerPrivate(rb))
    , threads_started(false)
    {
        reader = NULL;
    }
 
    QtPlayer::~QtPlayer()
    {
        if (mode != PLAYBACK_STOPPED)
            Stop();
 
        delete p;
    }
 
    void QtPlayer::CloseAudioDevice()
    {
        // Close audio device (only do this once, when all audio playback is finished)
        openshot::AudioDeviceManagerSingleton::Instance()->CloseAudioDevice();
    }
 
    // Return any error string during initialization
    std::string QtPlayer::GetError() {
        if (reader && threads_started) {
            return p->audioPlayback->getError();
        } else {
            return "";
        }
    }
 
    // Return the default audio sample rate (from the system)
    double QtPlayer::GetDefaultSampleRate() {
        if (reader && threads_started) {
            return p->audioPlayback->getDefaultSampleRate();
        } else {
            return 0;
        }
    }
 
    AudioDeviceList QtPlayer::GetAudioDeviceNames() {
        AudioDevices devs;
        return devs.getNames();
    }
 
    // Get current audio device or last attempted (if none succeeded)
    AudioDeviceInfo QtPlayer::GetCurrentAudioDevice() {
        return p->audioPlayback->getCurrentAudioDevice();
    }
 
    // Set the source JSON of an openshot::Timelime
    void QtPlayer::SetTimelineSource(const std::string &json) {
        // Create timeline instance (720p, since we have no re-scaling in this player yet)
        reader = new Timeline(1280, 720, openshot::Fraction(30, 1), 44100, 2, openshot::LAYOUT_STEREO);
 
        Timeline* tm = (Timeline*)reader;
        tm->SetJson(json);
        tm->DisplayInfo();
        tm->Open();
 
        // Set the reader
        Reader(reader);
    }
 
    void QtPlayer::SetSource(const std::string &source)
    {
        FFmpegReader *ffreader = new FFmpegReader(source);
        ffreader->DisplayInfo();
 
        // Use default sample rate (or use the FFmpegReader's audio settings if any)
        int sample_rate = 44100;
        if (ffreader->info.sample_rate > 0)
            sample_rate = ffreader->info.sample_rate;
 
        // Use default channels (or use the FFmpegReader's audio settings if any)
        int channels = 2;
        if (ffreader->info.channels > 0)
            channels = ffreader->info.channels;
 
        // Use default channel layout (or use the FFmpegReader's audio settings if any)
        openshot::ChannelLayout channel_layout = openshot::LAYOUT_STEREO;
        if (channels != 2)
            channel_layout = ffreader->info.channel_layout;
 
        // Create timeline instance (720p, since we have no re-scaling in this player yet)
        reader = new Timeline(1280, 720, ffreader->info.fps, sample_rate, channels, channel_layout);
        Clip *c = new Clip(source);
 
        Timeline* tm = (Timeline*)reader;
        tm->AddClip(c);
        tm->Open();
 
        // Set the reader
        Reader(reader);
    }
 
    void QtPlayer::Play()
    {
        // Set mode to playing, and speed to normal
        mode = PLAYBACK_PLAY;
        Speed(1);
 
        if (reader && !threads_started) {
            // Start thread only once
            p->audioPlayback->Play();
            p->startPlayback();
            threads_started = true;
        }
    }
 
    void QtPlayer::Loading()
    {
        mode = PLAYBACK_LOADING;
    }
 
    openshot::PlaybackMode QtPlayer::Mode()
    {
        return mode;
    }
 
    void QtPlayer::Pause()
    {
        mode = PLAYBACK_PAUSED;
        Speed(0);
    }
 
    int64_t QtPlayer::Position()
    {
        return p->video_position;
    }
 
    void QtPlayer::Seek(int64_t new_frame)
    {
        Seek(new_frame, true);
    }
 
    void QtPlayer::Seek(int64_t new_frame, bool start_preroll)
    {
        // Check for seek
        if (reader && threads_started && new_frame > 0) {
            // Notify cache thread that seek has occurred
            p->videoCache->Seek(new_frame, start_preroll);
 
            // Notify audio thread that seek has occurred
            p->audioPlayback->Seek(new_frame);
 
            // Update current position
            p->Seek(new_frame);
        }
    }
 
    void QtPlayer::Stop()
    {
        // Change mode to stopped
        mode = PLAYBACK_STOPPED;
 
        // Notify threads of stopping
        if (reader && threads_started) {
            p->videoCache->Stop();
            p->audioPlayback->Stop();
 
            // Kill all threads
            p->stopPlayback();
        }
 
        p->video_position = 0;
        threads_started = false;
    }
 
    // Set the reader object
    void QtPlayer::Reader(openshot::ReaderBase *new_reader)
    {
        // ReaderBase is caller-owned. Drain every old-reader user before the
        // caller may close/delete it after this method returns.
        const bool restart = threads_started;
        p->stopPlayback();
        threads_started = false;
        // Release every reference/event associated with the old reader before
        // restarting, including a paused same-position preview.
        p->Seek(p->video_position.load());
        p->videoPlayback->SetFrame({});
        p->videoPlayback->render.reset();
        p->videoPlayback->rendered.reset();
        reader = new_reader;
        p->reader = new_reader;
        p->videoCache->Reader(new_reader);
        p->audioPlayback->Reader(new_reader);
        if (restart && new_reader) {
            p->startPlayback();
            threads_started = true;
        }
    }
 
    // Get the current reader, such as a FFmpegReader
    openshot::ReaderBase* QtPlayer::Reader() {
        return reader;
    }
 
    // Set the QWidget pointer to display the video on (as a pointer-sized unsigned id)
    void QtPlayer::SetQWidget(uintptr_t qwidget_address) {
        // Update override QWidget address on the video renderer
        p->renderer->OverrideWidget(qwidget_address);
    }
 
    // Set the QWidget pointer to display the video on (using a real QWidget pointer)
    void QtPlayer::SetQWidget(QWidget *widget) {
        SetQWidget(reinterpret_cast<uintptr_t>(widget));
    }
 
    // Get the Renderer pointer address (for Python to cast back into a VideoRenderer)
    uintptr_t QtPlayer::GetRendererQObject() {
        auto* vr = static_cast<VideoRenderer*>(p->renderer);
        uintptr_t addr = reinterpret_cast<uintptr_t>(vr);
        return addr;
    }
 
    // Get the Playback speed
    float QtPlayer::Speed() {
        return speed;
    }
 
    // Set the Playback speed multiplier (1.0 = normal speed, <1.0 = slower, >1.0 faster)
    void QtPlayer::Speed(float new_speed) {
        speed = new_speed;
        p->speed = new_speed;
        p->videoCache->setSpeed(new_speed);
        if (p->reader && p->reader->info.has_audio) {
            p->audioPlayback->setSpeed(new_speed);
        }
    }
 
    // Get the Volume
    float QtPlayer::Volume() {
        return volume;
    }
 
    // Set the Volume multiplier (1.0 = normal volume, <1.0 = quieter, >1.0 louder)
    void QtPlayer::Volume(float new_volume) {
        volume = new_volume;
    }
}
#ifdef __ANDROID__
#include <android/log.h>
#ifndef ANDROID_LOG_WARN
#define ANDROID_LOG_WARN 5
#endif
#endif