FFmpegDecoder.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_ANDROIDSLESMEDIAPLAYER_INCLUDE_ANDROIDSLESMEDIAPLAYER_FFMPEGDECODER_H_
#define ALEXA_CLIENT_SDK_MEDIAPLAYER_ANDROIDSLESMEDIAPLAYER_INCLUDE_ANDROIDSLESMEDIAPLAYER_FFMPEGDECODER_H_

#include <atomic>
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
#include <utility>

extern "C" {
#include <libavutil/samplefmt.h>
}

#include "AndroidSLESMediaPlayer/DecoderInterface.h"
#include "AndroidSLESMediaPlayer/FFmpegInputControllerInterface.h"
#include "AndroidSLESMediaPlayer/PlaybackConfiguration.h"
#include "AVSCommon/Utils/MediaPlayer/SourceConfig.h"

struct AVCodec;
struct AVCodecContext;
struct AVDictionary;
struct AVFormatContext;
struct AVFrame;
struct AVInputFormat;
struct AVIOContext;
struct SwrContext;
struct AVFilterGraph;
struct AVFilterContext;

namespace alexaClientSDK {
namespace mediaPlayer {
namespace android {

using LayoutMask = int64_t;

class FFmpegDecoder : public DecoderInterface {
public:
    static std::unique_ptr<FFmpegDecoder> create(
        std::unique_ptr<FFmpegInputControllerInterface> inputController,
        const PlaybackConfiguration& outputConfig,
        const avsCommon::utils::mediaPlayer::SourceConfig& config = avsCommon::utils::mediaPlayer::emptySourceConfig());

    std::pair<Status, size_t> read(Byte* buffer, size_t size) override;
    void abort() override;

    bool shouldInterruptFFmpeg();

private:
    FFmpegDecoder(
        std::unique_ptr<FFmpegInputControllerInterface> inputController,
        AVSampleFormat format,
        LayoutMask layout,
        int sampleRate,
        const avsCommon::utils::mediaPlayer::SourceConfig& config);

    enum class DecodingState {
        DECODING,
        FLUSHING_DECODER,
        FLUSHING_RESAMPLER,
        INITIALIZING,
        FINISHED,
        INVALID
    };

    friend std::ostream& operator<<(std::ostream& stream, const DecodingState state);

    void setState(DecodingState nextState);

    class UnreadData {
    public:
        UnreadData(AVSampleFormat format, LayoutMask layout, int sampleRate);

        AVFrame& getFrame();

        int getOffset() const;

        void resize(size_t minimumCapacity);

        bool isEmpty() const;

        void setOffset(int offset);

    private:
        size_t m_capacity;

        int m_offset;

        std::shared_ptr<AVFrame> m_frame;
    };

    size_t readData(Byte* buffer, size_t size, size_t bytesRead);

    void resample(std::shared_ptr<AVFrame> inputFrame);

    void decode();

    void next();

    void sleep();

    void readDecodedFrame(std::shared_ptr<AVFrame>& decodedFrame);

    void initialize();

    bool initializeFilters();

    bool transitionStateUsingStatus(int status, DecodingState nextState, const std::string& functionName);

    std::atomic<DecodingState> m_state;

    std::unique_ptr<FFmpegInputControllerInterface> m_inputController;

    const AVSampleFormat m_outputFormat;

    const LayoutMask m_outputLayout;

    const int m_outputRate;

    std::shared_ptr<AVFormatContext> m_formatContext;

    std::shared_ptr<AVCodecContext> m_codecContext;

    std::shared_ptr<SwrContext> m_swrContext;

    std::shared_ptr<AVFilterGraph> m_filterGraph;

    std::shared_ptr<AVFilterContext> m_filterInput;
    std::shared_ptr<AVFilterContext> m_filterOutput;

    UnreadData m_unreadData;

    size_t m_retryCount;

    std::condition_variable m_abortCondition;

    std::chrono::time_point<std::chrono::steady_clock> m_initializeStartTime;

    avsCommon::utils::mediaPlayer::SourceConfig m_sourceConfig;

    long long m_decodedSampleTime = 0;
};

}  // namespace android
}  // namespace mediaPlayer
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_MEDIAPLAYER_ANDROIDSLESMEDIAPLAYER_INCLUDE_ANDROIDSLESMEDIAPLAYER_FFMPEGDECODER_H_