/*
 * Copyright 2009, Stephan Aßmus <superstippi@gmx.de>
 * Copyright 2014, Colin Günther <coling@gmx.de>
 * Copyright 2018, Dario Casalinuovo
 * All rights reserved. Distributed under the terms of the GNU L-GPL license.
 */
#ifndef UTILITIES_H
#define UTILITIES_H


/*! \brief This file contains functions to convert and calculate values from
                FFmpeg to Media Kit and vice versa.
*/


#include <assert.h>
#include <stdio.h>

#include <GraphicsDefs.h>

extern "C" {
        #include "avcodec.h"
}


/*! \brief Structure used for passing AVPacket metadata through media_header::user_data. */
struct avpacket_user_data {
    int64_t pts;
    int64_t dts;
    int stream_index;
    int flags;
    int64_t duration;
    int64_t pos;
};

#define AVPACKET_USER_DATA_TYPE 'ffav'


/*! \brief Converts FFmpeg notation of video aspect ratio into the Media Kits
                notation.

        \see ConvertVideoAspectWidthAndHeightToAVCodecContext() for converting in
                the other direction.

        \param contextIn An AVCodeContext structure of FFmpeg containing the values
                needed to calculate the Media Kit video aspect ratio.
                The following fields are used for the calculation:
                        - AVCodecContext.sample_aspect_ratio.num (optional)
                        - AVCodecContext.sample_aspect_ratio.den (optional)
                        - AVCodecContext.width (must)
                        - AVCodecContext.height (must)
        \param pixelWidthAspectOut On return contains Media Kits notation of the
                video aspect ratio width. E.g. 16:9 -> 16 is returned here
        \param pixelHeightAspectOut On return contains Media Kits notation of the
                video aspect ratio height. E.g. 16:9 -> 9 is returned here
*/
inline void
ConvertAVCodecContextToVideoAspectWidthAndHeight(AVCodecContext& contextIn,
        uint16& pixelWidthAspectOut, uint16& pixelHeightAspectOut)
{
        if (contextIn.width <= 0 || contextIn.height <= 0) {
                fprintf(stderr, "Cannot compute video aspect ratio correctly\n");
                pixelWidthAspectOut = 1;
                pixelHeightAspectOut = 1;
                return;
        }

        assert(contextIn.sample_aspect_ratio.num >= 0);

        AVRational pixelAspectRatio;

        if (contextIn.sample_aspect_ratio.num == 0
                || contextIn.sample_aspect_ratio.den == 0) {
                // AVCodecContext doesn't contain a video aspect ratio, so calculate it
                // ourselve based solely on the video dimensions
                av_reduce(&pixelAspectRatio.num, &pixelAspectRatio.den, contextIn.width,
                        contextIn.height, 1024 * 1024);

                pixelWidthAspectOut = static_cast<int16>(pixelAspectRatio.num);
                pixelHeightAspectOut = static_cast<int16>(pixelAspectRatio.den);
                return;
        }

        // AVCodecContext contains a video aspect ratio, so use it
        av_reduce(&pixelAspectRatio.num, &pixelAspectRatio.den,
                contextIn.width * contextIn.sample_aspect_ratio.num,
                contextIn.height * contextIn.sample_aspect_ratio.den,
                1024 * 1024);

        pixelWidthAspectOut = static_cast<int16>(pixelAspectRatio.num);
        pixelHeightAspectOut = static_cast<int16>(pixelAspectRatio.den);
}


inline void
ConvertAVCodecParametersToVideoAspectWidthAndHeight(AVCodecParameters& parametersIn,
        uint16& pixelWidthAspectOut, uint16& pixelHeightAspectOut)
{
        if (parametersIn.width <= 0 || parametersIn.height <= 0) {
                fprintf(stderr, "Cannot compute video aspect ratio correctly\n");
                pixelWidthAspectOut = 1;
                pixelHeightAspectOut = 1;
                return;
        }

        assert(parametersIn.sample_aspect_ratio.num >= 0);

        AVRational pixelAspectRatio;

        if (parametersIn.sample_aspect_ratio.num == 0
                || parametersIn.sample_aspect_ratio.den == 0) {
                // AVCodecContext doesn't contain a video aspect ratio, so calculate it
                // ourselve based solely on the video dimensions
                av_reduce(&pixelAspectRatio.num, &pixelAspectRatio.den, parametersIn.width,
                        parametersIn.height, 1024 * 1024);

                pixelWidthAspectOut = static_cast<int16>(pixelAspectRatio.num);
                pixelHeightAspectOut = static_cast<int16>(pixelAspectRatio.den);
                return;
        }

        // AVCodecContext contains a video aspect ratio, so use it
        av_reduce(&pixelAspectRatio.num, &pixelAspectRatio.den,
                parametersIn.width * parametersIn.sample_aspect_ratio.num,
                parametersIn.height * parametersIn.sample_aspect_ratio.den,
                1024 * 1024);

        pixelWidthAspectOut = static_cast<int16>(pixelAspectRatio.num);
        pixelHeightAspectOut = static_cast<int16>(pixelAspectRatio.den);
}


/*!     \brief Converts the Media Kits notation of video aspect ratio into FFmpegs
                notation.

        \see ConvertAVCodecContextToVideoAspectWidthAndHeight() for converting in
                the other direction.

        \param pixelWidthAspectIn Contains Media Kits notation of the video aspect
                ratio width. E.g. 16:9 -> 16 is passed here.
        \param pixelHeightAspectIn Contains Media Kits notation of the video aspect
                ratio height. E.g. 16:9 -> 9 is passed here.
        \param contextInOut     An AVCodecContext structure of FFmpeg.
                On input must contain the following fields already initialized
                otherwise the behaviour is undefined:
                        - AVCodecContext.width (must)
                        - AVCodecContext.height (must)
                On output contains converted values in the following fields (other
                fields stay as they were on input):
                        - AVCodecContext.sample_aspect_ratio.num
                        - AVCodecContext.sample_aspect_ratio.den
*/
inline void
ConvertVideoAspectWidthAndHeightToAVCodecContext(uint16 pixelWidthAspectIn,
        uint16 pixelHeightAspectIn, AVCodecContext& contextInOut)
{
        if (contextInOut.width <= 0 || contextInOut.height <= 0) {
                fprintf(stderr, "Cannot compute video aspect ratio correctly\n");
                // We can't do anything, set the aspect ratio to 'ignore'.
                contextInOut.sample_aspect_ratio.num = 0;
                contextInOut.sample_aspect_ratio.den = 1;
                return;
        }

        assert(pixelWidthAspectIn > 0);
        assert(pixelHeightAspectIn > 0);

        AVRational pureVideoDimensionAspectRatio;
        av_reduce(&pureVideoDimensionAspectRatio.num,
                &pureVideoDimensionAspectRatio.den, contextInOut.width,
                contextInOut.height, 1024 * 1024);

        if (pureVideoDimensionAspectRatio.num == pixelWidthAspectIn
                && pureVideoDimensionAspectRatio.den == pixelHeightAspectIn) {
                // The passed Media Kit pixel aspect ratio equals the video dimension
                // aspect ratio. Set sample_aspect_ratio to "ignore".
                contextInOut.sample_aspect_ratio.num = 0;
                contextInOut.sample_aspect_ratio.den = 1;
                return;
        }

        av_reduce(&contextInOut.sample_aspect_ratio.num,
                &contextInOut.sample_aspect_ratio.den,
                contextInOut.height * pixelWidthAspectIn,
                contextInOut.width * pixelHeightAspectIn,
                1024 * 1024);
}


/*! \brief Calculates bytes per row for a video frame.

        \param colorSpace The Media Kit color space the video frame uses.
        \param videoWidth The width of the video frame.

        \returns bytes per video frame row
        \returns Zero, when bytes per video frame cannot be calculated.
*/
inline uint32
CalculateBytesPerRowWithColorSpaceAndVideoWidth(color_space colorSpace, int videoWidth)
{
        assert(videoWidth >= 0);

        const uint32 kBytesPerRowUnknown = 0;
        size_t pixelChunk;
        size_t rowAlignment;
        size_t pixelsPerChunk;

        if (get_pixel_size_for(colorSpace, &pixelChunk, &rowAlignment, &pixelsPerChunk) != B_OK)
                return kBytesPerRowUnknown;

        uint32 bytesPerRow = pixelChunk * videoWidth / pixelsPerChunk;
        uint32 numberOfUnalignedBytes = bytesPerRow % rowAlignment;

        if (numberOfUnalignedBytes == 0)
                return bytesPerRow;

        uint32 numberOfBytesNeededForAlignment = rowAlignment - numberOfUnalignedBytes;
        bytesPerRow += numberOfBytesNeededForAlignment;

        return bytesPerRow;
}


/*!     \brief Converts the Media Kits notation of video frame rate to FFmpegs
        notation.

        \see ConvertAVCodecContextToVideoFrameRate() for converting in the other
                direction.

        \param frameRateIn Contains Media Kits notation of the video frame rate
                that will be converted into FFmpegs notation. Must be greater than
                zero.
        \param contextOut An AVCodecContext structure of FFmpeg.
                On output contains converted values in the following fields (other
                fields stay as they were on input):
                        - AVCodecContext.time_base.num
                        - AVCodecContext.time_base.den
                        - AVCodecContext.framerate.num
                        - AVCodecContext.framerate.den
*/
inline void
ConvertVideoFrameRateToAVCodecContext(float frameRateIn,
        AVCodecContext& contextOut)
{
        assert(frameRateIn > 0);

        contextOut.framerate = av_d2q(frameRateIn, 1024);
        contextOut.time_base = av_d2q(1.0 / frameRateIn, 1024);
}


/*!     \brief Converts the Media Kits notation of an audio sample format to
                FFmpegs notation.

        \see ConvertAVSampleFormatToRawAudioFormat() for converting in the other
                direction.

        \param rawAudioFormatIn Contains Media Kits notation of an audio sample
                format that will be converted into FFmpegs notation.
        \param sampleFormatOut On output contains FFmpegs notation of the passed
                audio sample format. Might return AV_SAMPLE_FMT_NONE if there is no
                conversion path.
*/
inline void
ConvertRawAudioFormatToAVSampleFormat(uint32 rawAudioFormatIn,
        AVSampleFormat& sampleFormatOut)
{
        switch (rawAudioFormatIn) {
                case media_raw_audio_format::B_AUDIO_FLOAT:
                        sampleFormatOut = AV_SAMPLE_FMT_FLT;
                        return;

                case media_raw_audio_format::B_AUDIO_DOUBLE:
                        sampleFormatOut = AV_SAMPLE_FMT_DBL;
                        return;

                case media_raw_audio_format::B_AUDIO_INT:
                        sampleFormatOut = AV_SAMPLE_FMT_S32;
                        return;

                case media_raw_audio_format::B_AUDIO_SHORT:
                        sampleFormatOut = AV_SAMPLE_FMT_S16;
                        return;

                case media_raw_audio_format::B_AUDIO_UCHAR:
                        sampleFormatOut = AV_SAMPLE_FMT_U8;
                        return;

                default:
                        // Silence compiler warnings about unhandled enumeration values.
                        break;
        }

        sampleFormatOut = AV_SAMPLE_FMT_NONE;
}


/*!     \brief Converts FFmpegs notation of an audio sample format to the Media
                Kits notation.

        \see ConvertAVSampleFormatToRawAudioFormat() for converting in the other
                direction.

        \param sampleFormatIn Contains FFmpegs notation of an audio sample format
                that will be converted into the Media Kits notation.
        \param rawAudioFormatOut On output contains Media Kits notation of the
                passed audio sample format. Might return 0 if there is no conversion
                path.
*/
inline void
ConvertAVSampleFormatToRawAudioFormat(AVSampleFormat sampleFormatIn,
        uint32& rawAudioFormatOut)
{
        switch (sampleFormatIn) {
                case AV_SAMPLE_FMT_FLT:
                case AV_SAMPLE_FMT_FLTP:
                        rawAudioFormatOut = media_raw_audio_format::B_AUDIO_FLOAT;
                        return;

                case AV_SAMPLE_FMT_DBL:
                case AV_SAMPLE_FMT_DBLP:
                        rawAudioFormatOut = media_raw_audio_format::B_AUDIO_DOUBLE;
                        return;

                case AV_SAMPLE_FMT_S32:
                case AV_SAMPLE_FMT_S32P:
                        rawAudioFormatOut = media_raw_audio_format::B_AUDIO_INT;
                        return;

                case AV_SAMPLE_FMT_S16:
                case AV_SAMPLE_FMT_S16P:
                        rawAudioFormatOut = media_raw_audio_format::B_AUDIO_SHORT;
                        return;

                case AV_SAMPLE_FMT_U8:
                case AV_SAMPLE_FMT_U8P:
                        rawAudioFormatOut = media_raw_audio_format::B_AUDIO_UCHAR;
                        return;

                default:
                        // Silence compiler warnings about unhandled enumeration values.
                        break;
        }

        const uint32 kBAudioNone = 0;
        rawAudioFormatOut = kBAudioNone;
}


#endif // UTILITIES_H