MediaPlayer.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

#ifndef ALEXA_CLIENT_SDK_MEDIAPLAYER_GSTREAMERMEDIAPLAYER_INCLUDE_MEDIAPLAYER_MEDIAPLAYER_H_
#define ALEXA_CLIENT_SDK_MEDIAPLAYER_GSTREAMERMEDIAPLAYER_INCLUDE_MEDIAPLAYER_MEDIAPLAYER_H_

#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
#include <future>
#include <memory>
#include <queue>
#include <string>
#include <thread>
#include <unordered_set>
#include <vector>

#include <gst/gst.h>
#include <gst/app/gstappsrc.h>
#include <gst/base/gstbasesink.h>
#include <gst/controller/gsttimedvaluecontrolsource.h>

#include <acsdkEqualizerInterfaces/EqualizerInterface.h>
#include <AVSCommon/SDKInterfaces/HTTPContentFetcherInterfaceFactoryInterface.h>
#include <AVSCommon/SDKInterfaces/SpeakerInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerObserverInterface.h>
#include <AVSCommon/Utils/MediaType.h>
#include <AVSCommon/Utils/PlaylistParser/PlaylistParserInterface.h>
#include <PlaylistParser/UrlContentToAttachmentConverter.h>

#include "MediaPlayer/OffsetManager.h"
#include "MediaPlayer/PipelineInterface.h"
#include "MediaPlayer/SourceInterface.h"
#include "MediaPlayer/SourceObserverInterface.h"

namespace alexaClientSDK {
namespace mediaPlayer {

typedef std::vector<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface::TagKeyValueType> VectorOfTags;

class MediaPlayer
        : public avsCommon::utils::RequiresShutdown
        , public avsCommon::utils::mediaPlayer::MediaPlayerInterface
        , public avsCommon::sdkInterfaces::SpeakerInterface
        , private PipelineInterface
        , public acsdkEqualizerInterfaces::EqualizerInterface
        , public playlistParser::UrlContentToAttachmentConverter::ErrorObserverInterface
        , public playlistParser::UrlContentToAttachmentConverter::WriteCompleteObserverInterface
        , public SourceObserverInterface
        , public std::enable_shared_from_this<MediaPlayer> {
public:
    static std::shared_ptr<MediaPlayer> create(
        std::shared_ptr<avsCommon::sdkInterfaces::HTTPContentFetcherInterfaceFactoryInterface> contentFetcherFactory =
            nullptr,
        bool enableEqualizer = false,
        std::string name = "",
        bool enableLiveMode = false);
    ~MediaPlayer();

    SourceId setSource(
        std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> attachmentReader,
        const avsCommon::utils::AudioFormat* format = nullptr,
        const avsCommon::utils::mediaPlayer::SourceConfig& config =
            avsCommon::utils::mediaPlayer::emptySourceConfig()) override;

    SourceId setSource(
        std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> attachmentReader,
        std::chrono::milliseconds offsetAdjustment,
        const avsCommon::utils::AudioFormat* format = nullptr,
        const avsCommon::utils::mediaPlayer::SourceConfig& config =
            avsCommon::utils::mediaPlayer::emptySourceConfig()) override;

    SourceId setSource(
        const std::string& url,
        std::chrono::milliseconds offset = std::chrono::milliseconds::zero(),
        const avsCommon::utils::mediaPlayer::SourceConfig& config = avsCommon::utils::mediaPlayer::emptySourceConfig(),
        bool repeat = false,
        const avsCommon::utils::mediaPlayer::PlaybackContext& playbackContext =
            avsCommon::utils::mediaPlayer::PlaybackContext()) override;

    SourceId setSource(
        std::shared_ptr<std::istream> stream,
        bool repeat = false,
        const avsCommon::utils::mediaPlayer::SourceConfig& config = avsCommon::utils::mediaPlayer::emptySourceConfig(),
        avsCommon::utils::MediaType format = avsCommon::utils::MediaType::UNKNOWN) override;

    bool play(SourceId id) override;
    bool stop(SourceId id) override;
    bool pause(SourceId id) override;
    bool resume(SourceId id) override;
    uint64_t getNumBytesBuffered() override;
    std::chrono::milliseconds getOffset(SourceId id) override;
    avsCommon::utils::Optional<avsCommon::utils::mediaPlayer::MediaPlayerState> getMediaPlayerState(
        SourceId id) override;
    void addObserver(std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface> observer) override;
    void removeObserver(std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface> observer) override;

    bool setVolume(int8_t volume) override;
    bool setMute(bool mute) override;
    bool getSpeakerSettings(avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings* settings) override;

    void setAppSrc(GstAppSrc* appSrc) override;
    GstAppSrc* getAppSrc() const override;
    void setDecoder(GstElement* decoder) override;
    GstElement* getDecoder() const override;
    GstElement* getPipeline() const override;
    guint queueCallback(const std::function<gboolean()>* callback) override;
    guint attachSource(GSource* source) override;
    gboolean removeSource(guint tag) override;

    void onError() override;
    void onWriteComplete() override;

    void onFirstByteRead() override;

    void doShutdown() override;

private:
    struct AudioPipeline {
        GstAppSrc* appsrc;

        GstElement* decoder;

        GstElement* decodedQueue;

        GstElement* converter;

        GstElement* volume;

        GstElement* fadeIn;

        GstElement* resample;

        GstElement* caps;

        GstElement* equalizer;

        GstElement* audioSink;

        GstElement* pipeline;

        AudioPipeline() :
                appsrc{nullptr},
                decoder{nullptr},
                decodedQueue{nullptr},
                converter{nullptr},
                volume{nullptr},
                fadeIn{nullptr},
                resample{nullptr},
                caps{nullptr},
                equalizer{nullptr},
                audioSink{nullptr},
                pipeline{nullptr} {};
    };

    MediaPlayer(
        std::shared_ptr<avsCommon::sdkInterfaces::HTTPContentFetcherInterfaceFactoryInterface> contentFetcherFactory,
        bool enableEqualizer,
        std::string name,
        bool enableLiveMode);

    bool configureSource(const avsCommon::utils::mediaPlayer::SourceConfig& config);

    void workerLoop();

    bool init();

    static gboolean onCallback(const std::function<gboolean()>* callback);

    bool setupPipeline();

    void tearDownTransientPipelineElements(bool notifyStop);

    void resetPipeline();

    static void onPadAdded(GstElement* src, GstPad* pad, gpointer mediaPlayer);

    void handlePadAdded(std::promise<void>* promise, GstElement* src, GstPad* pad);

    static gboolean onBusMessage(GstBus* bus, GstMessage* msg, gpointer mediaPlayer);

    gboolean handleBusMessage(GstMessage* message);

    std::unique_ptr<const VectorOfTags> collectTags(GstMessage* message);

    void sendStreamTagsToObserver(std::unique_ptr<const VectorOfTags> vectorOfTags);

    void handleSetAttachmentReaderSource(
        std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> reader,
        const avsCommon::utils::mediaPlayer::SourceConfig& config,
        std::promise<SourceId>* promise,
        const avsCommon::utils::AudioFormat* audioFormat = nullptr,
        bool repeat = false);

    void handleSetUrlSource(
        const std::string& url,
        std::chrono::milliseconds offset,
        const avsCommon::utils::mediaPlayer::SourceConfig& config,
        std::promise<SourceId>* promise,
        bool repeat);

    void handleSetIStreamSource(
        std::shared_ptr<std::istream> stream,
        bool repeat,
        const avsCommon::utils::mediaPlayer::SourceConfig& config,
        std::promise<SourceId>* promise);

    void handleSetVolumeInternal(gdouble gstVolume);

    void handleSetVolume(std::promise<bool>* promise, int8_t volume);

    void handleAdjustVolume(std::promise<bool>* promise, int8_t delta);

    void handleSetMute(std::promise<bool>* promise, bool mute);

    void handleGetSpeakerSettings(
        std::promise<bool>* promise,
        avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings* settings);

    void handlePlay(SourceId id, std::promise<bool>* promise);

    void handleStop(SourceId id, std::promise<bool>* promise);

    void handlePause(SourceId id, std::promise<bool>* promise);

    void handleResume(SourceId id, std::promise<bool>* promise);

    void handleGetOffset(SourceId id, std::promise<std::chrono::milliseconds>* promise);

    std::chrono::milliseconds handleGetOffsetImmediately(SourceId id);

    avsCommon::utils::mediaPlayer::MediaPlayerState getMediaPlayerStateInternal(SourceId id);

    void handleAddObserver(
        std::promise<void>* promise,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface> observer);

    void handleRemoveObserver(
        std::promise<void>* promise,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface> observer);

    void sendPlaybackStarted();

    void sendPlaybackFinished();

    void sendPlaybackPaused();

    void sendPlaybackResumed();

    void sendPlaybackStopped();

    void sendPlaybackError(
        const alexaClientSDK::avsCommon::utils::mediaPlayer::ErrorType& type,
        const std::string& error);

    void sendBufferingComplete();

    void sendBufferUnderrun();

    void sendBufferRefilled();

    bool queryIsSeekable(bool* isSeekable);

    bool queryBufferPercent(gint* percent);

    bool seek();

    bool validateSourceAndId(SourceId id);

    static gboolean onErrorCallback(gpointer pointer);

    static gboolean onWriteCompleteCallback(gpointer pointer);

    std::chrono::milliseconds getCurrentStreamOffset();

    void cleanUpSource();

    void setEqualizerBandLevels(acsdkEqualizerInterfaces::EqualizerBandLevelMap bandLevelMap) override;
    int getMinimumBandLevel() override;
    int getMaximumBandLevel() override;

    int clampEqualizerLevel(int level);

    std::mutex m_operationMutex;

    gdouble m_lastVolume;

    bool m_isMuted;

    std::shared_ptr<playlistParser::UrlContentToAttachmentConverter> m_urlConverter;

    std::shared_ptr<alexaClientSDK::avsCommon::avs::attachment::AttachmentReader> m_parkedReader;

    OffsetManager m_offsetManager;

    std::shared_ptr<avsCommon::sdkInterfaces::HTTPContentFetcherInterfaceFactoryInterface> m_contentFetcherFactory;

    bool m_equalizerEnabled;

    AudioPipeline m_pipeline;

    GMainLoop* m_mainLoop;

    // Main loop thread
    std::thread m_mainLoopThread;

    guint m_busWatchId;

    GMainContext* m_workerContext;

    bool m_playbackStartedSent;

    bool m_playbackFinishedSent;

    bool m_isPaused;

    bool m_isBufferUnderrun;

    std::unordered_set<std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface>> m_playerObservers;

    std::shared_ptr<SourceInterface> m_source;

    SourceId m_currentId;

    bool m_isFakeSink;

    bool m_playPending;

    bool m_pausePending;

    bool m_resumePending;

    bool m_pauseImmediately;

    std::chrono::milliseconds m_offsetBeforeTeardown;

    const bool m_isLiveMode;

    std::chrono::milliseconds m_offsetAdjustment;
};

}  // namespace mediaPlayer
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_MEDIAPLAYER_GSTREAMERMEDIAPLAYER_INCLUDE_MEDIAPLAYER_MEDIAPLAYER_H_