// Copyright (C) 2023  Davis E. King (davis@dlib.net)
// License: Boost Software License   See LICENSE.txt for the full license.

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
/*
    PRIVATE IMPLEMENTATION DETAILS
    USERS, YOU DO NOT NEED TO READ THIS
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
/*
    Notes for developers:

    The file structure for all things ffmpeg is as follows:

        - ffmpeg_details.h  : contains implementations details only and everything must be in the
                              dlib::ffmpeg::details namespace
        
        - ffmpeg_utils.h    : contains common public API. Declarations go at the bottom of the file
                              underneath a block comment saying "DEFINITIONS"
                              Also contains implementation details that depend on the public API.
                              This must still go in the dlib::ffmpeg::details namespace
        
        - ffmpeg_demuxer.h  : contains public API for all things decoding. Similarly, declarations go 
                              at the bottom of the file underneath a block comment saying "DEFINITIONS".

        - ffmpeg_muxer.h  :   contains public API for all things encoding. Similarly, declarations go 
                              at the bottom of the file underneath a block comment saying "DEFINITIONS".
                            
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef DLIB_FFMPEG_DETAILS
#define DLIB_FFMPEG_DETAILS

#include "../test_for_odr_violations.h"

#ifndef DLIB_USE_FFMPEG
static_assert(false, "This version of dlib isn't built with the FFMPEG wrappers");
#endif

extern "C" {
#include <libavutil/dict.h>
#include <libavutil/opt.h>
#include <libavutil/pixdesc.h>
#include <libavutil/frame.h>
#include <libavutil/channel_layout.h>
#include <libavutil/audio_fifo.h>
#include <libavutil/imgutils.h>
#include <libavutil/log.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
#include <libavformat/avformat.h>
#include <libavdevice/avdevice.h>
#include <libavcodec/avcodec.h>
}

#include <string>
#include <memory>
#include "../logger.h"

namespace dlib { namespace ffmpeg { namespace details
{

// ---------------------------------------------------------------------------------------------------

    inline dlib::logger& logger_ffmpeg_private()
    {
        static dlib::logger GLOBAL("ffmpeg.internal");
        return GLOBAL;
    }
// ---------------------------------------------------------------------------------------------------

    inline void register_ffmpeg()
    {
        static const bool REGISTERED = []
        {
            avdevice_register_all();
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 10, 100)
            // See https://github.com/FFmpeg/FFmpeg/blob/70d25268c21cbee5f08304da95be1f647c630c15/doc/APIchanges#L91
            avcodec_register_all();
#endif
#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(58, 9, 100) 
            // See https://github.com/FFmpeg/FFmpeg/blob/70d25268c21cbee5f08304da95be1f647c630c15/doc/APIchanges#L86
            av_register_all();
#endif

            av_log_set_callback([](void* ptr, int level, const char *fmt, va_list vl) 
            {
                auto& logger = logger_ffmpeg_private();

                char line[256] = {0};
                static int print_prefix = 1;

                // Not sure if copying to vl2 is required by internal ffmpeg functions do this...
                va_list vl2;
                va_copy(vl2, vl);
                int size = av_log_format_line2(ptr, level, fmt, vl2, &line[0], sizeof(line), &print_prefix);
                va_end(vl2);

                // Remove all '\n' since dlib's logger already adds one
                size = std::min<int>(size, sizeof(line) - 1);
                line[size] = '\0';
                for (int i = size - 1 ; i >= 0 ; --i)
                    if (line[i] == '\n')
                        line[i] = ' ';

                switch(level)
                {
                    case AV_LOG_PANIC:
                    case AV_LOG_FATAL:      logger << LFATAL << line; break;
                    case AV_LOG_ERROR:      logger << LERROR << line; break;
                    case AV_LOG_WARNING:    logger << LWARN  << line; break;
                    case AV_LOG_INFO:       
                    case AV_LOG_VERBOSE:    logger << LINFO  << line; break;
                    case AV_LOG_DEBUG:      logger << LDEBUG << line; break;
                    case AV_LOG_TRACE:      logger << LTRACE << line; break;
                    default: break;
                }
            });

            return true;
        }();
        (void)REGISTERED;
    }        

// ---------------------------------------------------------------------------------------------------

    inline std::string get_av_error(int ret)
    {
        char buf[128] = {0};
        int suc = av_strerror(ret, buf, sizeof(buf));
        return suc == 0 ? buf : "couldn't set error";
    }

// ---------------------------------------------------------------------------------------------------

    ///////////////////////////
    // Channel layout stuff 
    ///////////////////////////

    inline uint64_t get_layout_from_channels(const std::size_t nchannels)
    {
        // This function is a bit ambiguous but good enough for dlib.
        // Multiple layouts can have the same number of channels
        switch(nchannels)
        {
            case 1: return AV_CH_LAYOUT_MONO;
            case 2: return AV_CH_LAYOUT_STEREO;
            default: DLIB_CASSERT(false, "Don't support " << nchannels << " yet"); return 0;
        }
    }

#if FF_API_OLD_CHANNEL_LAYOUT

    inline AVChannelLayout convert_layout(const uint64_t channel_layout)
    {
        AVChannelLayout ch_layout;
        ch_layout.order         = AV_CHANNEL_ORDER_NATIVE;
        ch_layout.u.mask        = channel_layout;
        ch_layout.nb_channels   = [=] 
        {
            switch(channel_layout)
            {
                case AV_CH_LAYOUT_MONO:                 return 1;
                case AV_CH_LAYOUT_STEREO:               return 2;
                case AV_CH_LAYOUT_2POINT1:              return 3;
                case AV_CH_LAYOUT_2_1:                  return 3;
                case AV_CH_LAYOUT_SURROUND:             return 3;
                case AV_CH_LAYOUT_3POINT1:              return 4;
                case AV_CH_LAYOUT_4POINT0:              return 4;
                case AV_CH_LAYOUT_4POINT1:              return 5;
                case AV_CH_LAYOUT_2_2:                  return 4;
                case AV_CH_LAYOUT_QUAD:                 return 4;
                case AV_CH_LAYOUT_5POINT0:              return 5;
                case AV_CH_LAYOUT_5POINT1:              return 6;
                case AV_CH_LAYOUT_5POINT0_BACK:         return 5;
                case AV_CH_LAYOUT_5POINT1_BACK:         return 6;
                case AV_CH_LAYOUT_6POINT0:              return 6;
                case AV_CH_LAYOUT_6POINT0_FRONT:        return 6;
                case AV_CH_LAYOUT_HEXAGONAL:            return 6;
                case AV_CH_LAYOUT_6POINT1:              return 7;
                case AV_CH_LAYOUT_6POINT1_BACK:         return 7;
                case AV_CH_LAYOUT_6POINT1_FRONT:        return 7;
                case AV_CH_LAYOUT_7POINT0:              return 7;
                case AV_CH_LAYOUT_7POINT0_FRONT:        return 7;
                case AV_CH_LAYOUT_7POINT1:              return 8;
                case AV_CH_LAYOUT_7POINT1_WIDE:         return 8;
                case AV_CH_LAYOUT_7POINT1_WIDE_BACK:    return 8;
                case AV_CH_LAYOUT_OCTAGONAL:            return 8;
                case AV_CH_LAYOUT_HEXADECAGONAL:        return 16;
                case AV_CH_LAYOUT_STEREO_DOWNMIX:       return 2;
#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(56, 58, 100)
                case AV_CH_LAYOUT_22POINT2:             return 24;
#endif
                default: break;
            }
            return 0;
        }();

        return ch_layout;
    }

    inline std::string get_channel_layout_str(const AVChannelLayout& ch_layout)
    {
        std::string str(32, '\0');
        const int ret = av_channel_layout_describe(&ch_layout, &str[0], str.size());
        if (ret > 0)
            str.resize(ret);
        else
            str.clear();
        return str;
    }

    inline std::string get_channel_layout_str(uint64_t channel_layout)
    {
        return get_channel_layout_str(convert_layout(channel_layout));
    }

    inline std::string get_channel_layout_str(const AVCodecContext* pCodecCtx)
    {
        return get_channel_layout_str(pCodecCtx->ch_layout);
    }

    inline bool channel_layout_empty(const AVCodecContext* pCodecCtx)
    {
        return av_channel_layout_check(&pCodecCtx->ch_layout) == 0;
    }

    inline bool channel_layout_empty(const AVFrame* frame)
    {
        return frame && av_channel_layout_check(&frame->ch_layout) == 0;
    }

    inline uint64_t get_layout(const AVCodecContext* pCodecCtx)
    {
        return pCodecCtx->ch_layout.u.mask;
    }

    inline uint64_t get_layout(const AVFrame* frame)
    {
        return frame->ch_layout.u.mask;
    }

    inline void set_layout(AVCodecContext* pCodecCtx, const uint64_t channel_layout)
    {
        pCodecCtx->ch_layout = convert_layout(channel_layout);
    }

    inline void set_layout(AVFrame* frame, const uint64_t channel_layout)
    {
        frame->ch_layout = convert_layout(channel_layout);
    }

    inline int get_nchannels(const AVCodecContext* pCodecCtx)
    {
        return pCodecCtx->ch_layout.nb_channels;
    }

    inline int get_nchannels(const AVFrame* frame)
    {
        return frame->ch_layout.nb_channels;
    }

    inline int get_nchannels(const uint64_t channel_layout)
    {
        return convert_layout(channel_layout).nb_channels;
    }

    inline void check_layout(AVCodecContext* pCodecCtx)
    {
        if (get_layout(pCodecCtx) == 0 && pCodecCtx->ch_layout.nb_channels > 0)
            av_channel_layout_default(&pCodecCtx->ch_layout, pCodecCtx->ch_layout.nb_channels);
    }

#else

    inline std::string get_channel_layout_str(uint64_t channel_layout)
    {
        std::string str(32, '\0');
        av_get_channel_layout_string(&str[0], str.size(), 0, channel_layout);
        str.resize(strlen(str.data()));
        return str;
    }

    inline std::string get_channel_layout_str(const AVCodecContext* pCodecCtx)
    {
        return get_channel_layout_str(pCodecCtx->channel_layout);
    }

    inline bool channel_layout_empty(const AVCodecContext* pCodecCtx)
    {
        return pCodecCtx->channel_layout == 0;
    }

    inline bool channel_layout_empty(const AVFrame* frame)
    {
        return frame->channel_layout == 0;
    }

    inline uint64_t get_layout(const AVCodecContext* pCodecCtx)
    {
        return pCodecCtx->channel_layout;
    }

    inline uint64_t get_layout(const AVFrame* frame)
    {
        return frame->channel_layout;
    }

    inline void set_layout(AVCodecContext* pCodecCtx, const uint64_t channel_layout)
    {
        pCodecCtx->channel_layout = channel_layout;
    }

    inline void set_layout(AVFrame* frame, const uint64_t channel_layout)
    {
        frame->channel_layout = channel_layout;
    }

    inline int get_nchannels(const uint64_t channel_layout)
    {
        return av_get_channel_layout_nb_channels(channel_layout);
    }

    inline int get_nchannels(const AVCodecContext* pCodecCtx)
    {
        return get_nchannels(pCodecCtx->channel_layout);
    }

    inline int get_nchannels(const AVFrame* frame)
    {
        return get_nchannels(frame->channel_layout);
    }    

    inline void check_layout(AVCodecContext* pCodecCtx) 
    {
        if (pCodecCtx->channel_layout == 0 && pCodecCtx->channels > 0)
            pCodecCtx->channel_layout = av_get_default_channel_layout(pCodecCtx->channels);
    }       
#endif

// ---------------------------------------------------------------------------------------------------

    struct av_deleter
    {
        void operator()(AVFrame* ptr)               const;
        void operator()(AVPacket* ptr)              const;
        void operator()(AVAudioFifo* ptr)           const;
        void operator()(SwsContext* ptr)            const;
        void operator()(SwrContext* ptr)            const;
        void operator()(AVCodecContext* ptr)        const;
        void operator()(AVCodecParserContext* ptr)  const;
        void operator()(AVFormatContext* ptr)       const;
        void operator()(AVDeviceInfoList* ptr)      const;
    };

    inline void av_deleter::operator()(AVFrame *ptr)               const { if (ptr) av_frame_free(&ptr); }
    inline void av_deleter::operator()(AVPacket *ptr)              const { if (ptr) av_packet_free(&ptr); }
    inline void av_deleter::operator()(AVAudioFifo *ptr)           const { if (ptr) av_audio_fifo_free(ptr); }
    inline void av_deleter::operator()(SwsContext *ptr)            const { if (ptr) sws_freeContext(ptr); }
    inline void av_deleter::operator()(SwrContext *ptr)            const { if (ptr) swr_free(&ptr); }
    inline void av_deleter::operator()(AVCodecContext *ptr)        const { if (ptr) avcodec_free_context(&ptr); }
    inline void av_deleter::operator()(AVCodecParserContext *ptr)  const { if (ptr) av_parser_close(ptr); }
    inline void av_deleter::operator()(AVDeviceInfoList* ptr)      const { if (ptr) avdevice_free_list_devices(&ptr); }
    inline void av_deleter::operator()(AVFormatContext *ptr)       const 
    { 
        if (ptr) 
        {
            if (ptr->iformat)
                avformat_close_input(&ptr); 
            else if (ptr->oformat)
                avformat_free_context(ptr);
        }
    }

    template<class AVObject>
    using av_ptr = std::unique_ptr<AVObject, details::av_deleter>;


// ---------------------------------------------------------------------------------------------------

    inline av_ptr<AVFrame> make_avframe()
    {
        av_ptr<AVFrame> obj(av_frame_alloc());
        if (!obj)
            throw std::runtime_error("Failed to allocate AVframe");
        return obj;
    }

    inline av_ptr<AVPacket> make_avpacket()
    {
        av_ptr<AVPacket> obj(av_packet_alloc());
        if (!obj)
            throw std::runtime_error("Failed to allocate AVPacket");
        return obj;
    }

// ---------------------------------------------------------------------------------------------------

    struct av_dict
    {
        av_dict() = default;
        av_dict(const std::unordered_map<std::string, std::string> &options);
        av_dict(const av_dict &ori);
        av_dict &operator=(const av_dict &ori);
        av_dict(av_dict &&ori) noexcept;
        av_dict &operator=(av_dict &&ori) noexcept;
        ~av_dict();
        size_t size() const;
        void print() const;
        AVDictionary** get();

        AVDictionary *avdic = nullptr;
    };

    inline av_dict::av_dict(const std::unordered_map<std::string, std::string>& options)
    {
        int ret = 0;

        for (const auto& opt : options) {
            if ((ret = av_dict_set(&avdic, opt.first.c_str(), opt.second.c_str(), 0)) < 0) {
                printf("av_dict_set() failed : %s\n", get_av_error(ret).c_str());
                break;
            }
        }
    }

    inline av_dict::av_dict(const av_dict& ori)
    {
        av_dict_copy(&avdic, ori.avdic, 0);
    }

    inline av_dict& av_dict::operator=(const av_dict& ori)
    {
        *this = std::move(av_dict{ori});
        return *this;
    }

    inline av_dict::av_dict(av_dict &&ori) noexcept
    : avdic{std::exchange(ori.avdic, nullptr)}
    {
    }

    inline av_dict &av_dict::operator=(av_dict &&ori) noexcept
    {
        if (this != &ori)
            avdic = std::exchange(ori.avdic, nullptr);
        return *this;
    }

    inline av_dict::~av_dict()
    {
        if (avdic)
            av_dict_free(&avdic);
    }

    inline AVDictionary** av_dict::get()
    {
        return avdic ? &avdic: nullptr;
    }

    inline std::size_t av_dict::size() const
    {
        return avdic ? av_dict_count(avdic) : 0;
    }

    inline void av_dict::print() const
    {
        if (avdic)
        {
            AVDictionaryEntry *tag = nullptr;
            while ((tag = av_dict_get(avdic, "", tag, AV_DICT_IGNORE_SUFFIX)))
                printf("%s : %s\n", tag->key, tag->value);
        }
    }    

// ---------------------------------------------------------------------------------------------------

}}}

#endif //DLIB_FFMPEG_DETAILS