/*
 * Copyright (C) 2020 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#import "config.h"
#import "WebMAudioUtilitiesCocoa.h"

#if PLATFORM(COCOA)

#import "CAAudioStreamDescription.h"
#import "Logging.h"
#import "MediaUtilities.h"
#import "PlatformMediaSessionManager.h"
#import <AudioToolbox/AudioCodec.h>
#import <AudioToolbox/AudioComponent.h>
#import <AudioToolbox/AudioFormat.h>
#import <CoreMedia/CMFormatDescription.h>
#import <dlfcn.h>
#import <wtf/FlipBytes.h>
#import <wtf/Seconds.h>
#if ENABLE(OPUS)
#import <libwebrtc/opus_defines.h>
#endif
#import <pal/cf/AudioToolboxSoftLink.h>

namespace WebCore {

#if ENABLE(VORBIS) || ENABLE(OPUS)
static bool registerDecoderFactory(const char* decoderName, OSType decoderType)
{
    AudioComponentDescription desc { kAudioDecoderComponentType, decoderType, 'appl', kAudioComponentFlag_SandboxSafe, 0 };
    AudioComponent comp = PAL::AudioComponentFindNext(0, &desc);
    if (comp)
        return true; // Already registered.

#if PLATFORM(MAC)
    constexpr char audioComponentsDylib[] = "/System/Library/Components/AudioCodecs.component/Contents/MacOS/AudioCodecs";
    void *handle = dlopen(audioComponentsDylib, RTLD_LAZY | RTLD_LOCAL);
    if (!handle)
        return false;

    AudioComponentFactoryFunction decoderFactory = reinterpret_cast<AudioComponentFactoryFunction>(dlsym(handle, decoderName));
    if (!decoderFactory)
        return false;

    if (!AudioComponentRegister(&desc, CFSTR(""), 0, decoderFactory)) {
        dlclose(handle);
        return false;
    }

    return true;
#else
    UNUSED_PARAM(decoderName);
    return false;
#endif
}

static RetainPtr<CMFormatDescriptionRef> createAudioFormatDescriptionForFormat(OSType formatID, Vector<uint8_t>&& magicCookie)
{
    AudioStreamBasicDescription asbd { };
    asbd.mFormatID = formatID;
    uint32_t size = sizeof(asbd);
    auto error = PAL::AudioFormatGetProperty(kAudioFormatProperty_FormatInfo, magicCookie.size(), magicCookie.data(), &size, &asbd);
    if (error) {
        RELEASE_LOG_ERROR(Media, "createAudioFormatDescriptionForFormat failed with error %d (%.4s)", error, (char *)&error);
        return nullptr;
    }

    return createAudioFormatDescription(CAAudioStreamDescription(asbd), magicCookie.size(), magicCookie.data());
}
#endif // ENABLE(VORBIS) || ENABLE(OPUS)

#if ENABLE(OPUS)
constexpr Seconds opusConfigToFrameDuration(uint8_t config)
{
    // Refer to https://tools.ietf.org/html/rfc6716#section-3:
    // Section 3.1. The TOC Byte
    // Table 2: TOC Byte Configuration Parameters
    // Column 4: Frame Sizes
    constexpr Seconds frameSizeArray[] = {
        10_ms,
        20_ms,
        40_ms,
        60_ms,
        10_ms,
        20_ms,
        40_ms,
        60_ms,
        10_ms,
        20_ms,
        40_ms,
        60_ms,
        10_ms,
        20_ms,
        10_ms,
        20_ms,
        2.5_ms,
        5_ms,
        10_ms,
        20_ms,
        2.5_ms,
        5_ms,
        10_ms,
        20_ms,
        2.5_ms,
        5_ms,
        10_ms,
        20_ms,
        2.5_ms,
        5_ms,
        10_ms,
        20_ms,
    };
    if (config < std::size(frameSizeArray))
        return frameSizeArray[config];

    ASSERT_NOT_REACHED();
    return 1_ms;
}

constexpr int32_t opusConfigToBandwidth(uint8_t config)
{
    // Refer to https://tools.ietf.org/html/rfc6716#section-3:
    // Section 3.1. The TOC Byte
    // Table 2: TOC Byte Configuration Parameters
    // Column 3: Bandwidth
    if (config <= 3)
        return OPUS_BANDWIDTH_NARROWBAND;
    if (config <= 7)
        return OPUS_BANDWIDTH_MEDIUMBAND;
    if (config <= 11)
        return OPUS_BANDWIDTH_WIDEBAND;
    if (config <= 13)
        return OPUS_BANDWIDTH_SUPERWIDEBAND;
    if (config <= 15)
        return OPUS_BANDWIDTH_FULLBAND;
    if (config <= 19)
        return OPUS_BANDWIDTH_NARROWBAND;
    if (config <= 23)
        return OPUS_BANDWIDTH_WIDEBAND;
    if (config <= 27)
        return OPUS_BANDWIDTH_SUPERWIDEBAND;
    if (config <= 31)
        return OPUS_BANDWIDTH_FULLBAND;

    ASSERT_NOT_REACHED();
    return 0;
}
#endif

bool parseOpusPrivateData(size_t codecPrivateSize, const void* codecPrivateData, size_t frameSize, const void* frameData, OpusCookieContents& cookie)
{
#if ENABLE(OPUS)
    // https://tools.ietf.org/html/rfc7845
    // 5. Header Packets
    //
    //    An Ogg Opus logical stream contains exactly two mandatory header
    //    packets: an identification header and a comment header.
    //
    // 5.1. Identification Header
    //
    //       0                   1                   2                   3
    //       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //      |      'O'      |      'p'      |      'u'      |      's'      |
    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //      |      'H'      |      'e'      |      'a'      |      'd'      |
    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //      |  Version = 1  | Channel Count |           Pre-skip            |
    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //      |                     Input Sample Rate (Hz)                    |
    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //      |   Output Gain (Q7.8 in dB)    | Mapping Family|               |
    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+               :
    //      |                                                               |
    //      |               Optional Channel Mapping Table                  |
    //      |                                                               |
    //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    auto* privateDataPtr = static_cast<const uint8_t*>(codecPrivateData);

    if (codecPrivateSize < 19)
        return { };

    // 1. Magic Signature:
    //
    //     This is an 8-octet (64-bit) field that allows codec
    //     identification and is human readable.
    if (strncmp("OpusHead", reinterpret_cast<const char*>(privateDataPtr), 8))
        return false;

    // 2. Version (8 bits, unsigned):
    cookie.version = *(privateDataPtr + 8);

    // 3. Output Channel Count 'C' (8 bits, unsigned):
    cookie.channelCount = *(privateDataPtr + 9);

    // 4. Pre-skip (16 bits, unsigned, little endian):
    cookie.preSkip = flipBytesIfLittleEndian(*reinterpret_cast<const uint16_t*>(privateDataPtr + 10), true);

    // 5. Input Sample Rate (32 bits, unsigned, little endian):
    cookie.sampleRate = flipBytesIfLittleEndian(*reinterpret_cast<const uint32_t*>(privateDataPtr + 12), true);

    // 6. Output Gain (16 bits, signed, little endian):
    cookie.outputGain = flipBytesIfLittleEndian(*reinterpret_cast<const int16_t*>(privateDataPtr + 16), true);

    // 7. Channel Mapping Family (8 bits, unsigned):
    cookie.mappingFamily = *(privateDataPtr + 18);

    auto framePtr = static_cast<const uint8_t*>(frameData);

    if (frameSize < 1)
        return false;

    // https://tools.ietf.org/html/rfc6716
    // 3.1. The TOC Byte
    //
    //    A well-formed Opus packet MUST contain at least one byte [R1]. This
    //    byte forms a table-of-contents (TOC) header that signals which of the
    //    various modes and configurations a given packet uses. It is composed
    //    of a configuration number, "config", a stereo flag, "s", and a frame
    //    count code, "c", arranged as illustrated in Figure 1. A description
    //    of each of these fields follows.
    //                          0
    //                          0 1 2 3 4 5 6 7
    //                         +-+-+-+-+-+-+-+-+
    //                         | config  |s| c |
    //                         +-+-+-+-+-+-+-+-+
    //                       Figure 1: The TOC Byte

    uint8_t tocByte = *framePtr;
    uint8_t config = (tocByte & 0b11111000) >> 3;
    cookie.frameDuration = opusConfigToFrameDuration(config);
    cookie.bandwidth = opusConfigToBandwidth(config);

    uint8_t frameCountValue = (tocByte & 0b00000011);

    cookie.framesPerPacket = 0;
    if (!frameCountValue)
        cookie.framesPerPacket = 1;
    else if (frameCountValue == 1 || frameCountValue == 2)
        cookie.framesPerPacket = 2;
    else if (frameCountValue == 3) {
        // 3.2.5. Code 3: A Signaled Number of Frames in the Packet
        //
        //    Code 3 packets signal the number of frames, as well as additional
        //    padding, called "Opus padding" to indicate that this padding is added
        //    at the Opus layer rather than at the transport layer. Code 3 packets
        //    MUST have at least 2 bytes [R6,R7]. The TOC byte is followed by a
        //    byte encoding the number of frames in the packet in bits 2 to 7
        //    (marked "M" in Figure 5), with bit 1 indicating whether or not Opus
        //    padding is inserted (marked "p" in Figure 5), and bit 0 indicating
        //    VBR (marked "v" in Figure 5). M MUST NOT be zero, and the audio
        //    duration contained within a packet MUST NOT exceed 120 ms [R5]. This
        //    limits the maximum frame count for any frame size to 48 (for 2.5 ms
        //    frames), with lower limits for longer frame sizes. Figure 5
        //    illustrates the layout of the frame count byte.
        //
        //                               0
        //                               0 1 2 3 4 5 6 7
        //                              +-+-+-+-+-+-+-+-+
        //                              |v|p|     M     |
        //                              +-+-+-+-+-+-+-+-+
        //
        //                       Figure 5: The frame count byte
        if (frameSize < 2)
            return false;

        uint8_t frameCountByte = *(framePtr + 1);
        cookie.isVBR = ((frameCountByte & 0b10000000) >> 7) == 1;
        cookie.hasPadding = ((frameCountByte & 0b01000000) >> 6) == 1;
        cookie.framesPerPacket = (frameCountByte & 0b00111111);
    }
    return true;
#else
    UNUSED_PARAM(codecPrivateSize);
    UNUSED_PARAM(codecPrivateData);
    UNUSED_PARAM(frameSize);
    UNUSED_PARAM(frameData);
    UNUSED_PARAM(cookie);
    return false;
#endif
}

#if ENABLE(OPUS)
static Vector<uint8_t> cookieFromOpusCookieContents(const OpusCookieContents& cookie)
{
    auto samplesPerPacket = cookie.framesPerPacket * (cookie.frameDuration.seconds() * cookie.sampleRate);

    struct CoreAudioOpusHeader {
        unsigned applicationID;
        unsigned sampleRate;
        unsigned packetFrameSize;
        int packetBandwidth;
        unsigned packetStreamChannels;
        unsigned useInbandFEC;
        unsigned encFinalRange { 0 };
    };

    CoreAudioOpusHeader header = {
        CFSwapInt32HostToBig(OPUS_APPLICATION_AUDIO),
        CFSwapInt32HostToBig(cookie.sampleRate),
        CFSwapInt32HostToBig(samplesPerPacket),
        static_cast<int>(CFSwapInt32HostToBig(cookie.bandwidth)),
        CFSwapInt32HostToBig(cookie.channelCount),
        CFSwapInt32HostToBig(1),
    };

    auto magicCookie = Vector<uint8_t>(sizeof(CoreAudioOpusHeader));
    *reinterpret_cast<CoreAudioOpusHeader*>(magicCookie.data()) = header;

    return magicCookie;
}
#endif

bool isOpusDecoderAvailable()
{
#if ENABLE(OPUS)
    if (!PlatformMediaSessionManager::opusDecoderEnabled())
        return false;

    return registerOpusDecoderIfNeeded();
#else
    return false;
#endif
}

bool registerOpusDecoderIfNeeded()
{
#if ENABLE(OPUS)
    static bool available;

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        available = registerDecoderFactory("ACOpusDecoderFactory", kAudioFormatOpus);
    });

    return available;
#else
    return false;
#endif
}

RetainPtr<CMFormatDescriptionRef> createOpusAudioFormatDescription(const OpusCookieContents& cookieContents)
{
#if ENABLE(OPUS)
    if (!isOpusDecoderAvailable())
        return nullptr;

    auto cookieData = cookieFromOpusCookieContents(cookieContents);
    if (!cookieData.size())
        return nullptr;

    return createAudioFormatDescriptionForFormat('opus', WTFMove(cookieData));
#else
    UNUSED_PARAM(cookieContents);
    return nullptr;
#endif
}

#if ENABLE(VORBIS)
static Vector<uint8_t> cookieFromVorbisCodecPrivate(size_t codecPrivateSize, const void* codecPrivateData)
{
    // https://tools.ietf.org/html/draft-ietf-cellar-codec-03
    // 6.4.15. A_VORBIS
    // Codec ID: A_VORBIS
    // Codec Name: Vorbis
    // Initialization: The "Private Data" contains the first three Vorbis packet in order. The lengths of the
    // packets precedes them. The actual layout is:
    // - Byte 1: number of distinct packets '"#p"' minus one inside the CodecPrivate block.This MUST be '2'
    //   for current (as of 2016-07-08) Vorbis headers.
    // - Bytes 2..n: lengths of the first '"#p"' packets, coded in Xiph-style lacing. The length of the last
    //   packet is the length of the CodecPrivate block minus the lengths coded in these bytes minus one.
    // - Bytes n+1..: The Vorbis identification header, followed by the Vorbis comment header followed by the
    //   codec setup header.

    const unsigned char* privateDataPtr = static_cast<const unsigned char*>(codecPrivateData);

    const int vorbisMinimumCookieSize = 3;
    if (codecPrivateSize < vorbisMinimumCookieSize) {
        RELEASE_LOG_ERROR(Media, "cookieFromVorbisCodecPrivate: codec private data too small (%zu)", codecPrivateSize);
        return { };
    }

    // Despite the "This MUST be '2'" comment in the IETF document, packet count is not always equal to
    // 2 in real-word files, so ignore that field.
    const uint16_t idHeaderSize = privateDataPtr[1];
    const uint16_t commentHeaderSize = privateDataPtr[2];
    const uint16_t calculatedHeaderSize = 1 + idHeaderSize + commentHeaderSize;
    if (1 + idHeaderSize + commentHeaderSize > codecPrivateSize) {
        RELEASE_LOG_ERROR(Media, "cookieFromVorbisCodecPrivate: codec private data too small (%zu) for header sizes (%d)", codecPrivateSize, calculatedHeaderSize);
        return { };
    }

    const unsigned char* idHeader = &privateDataPtr[3];
    const unsigned char* commentHeader = idHeader + idHeaderSize;
    const unsigned char* codecSetupHeader = commentHeader + commentHeaderSize;
    const uint16_t codecSetupHeaderSize = codecPrivateSize - idHeaderSize - commentHeaderSize - 2 - 1;

    if ((idHeaderSize + commentHeaderSize + codecSetupHeaderSize + 3) > codecPrivateSize) {
        RELEASE_LOG_ERROR(Media, "cookieFromVorbisCodecPrivate: codec private header size is invalid - id = %d, comment = %d, header = %d, chunk size = %zu", idHeaderSize, commentHeaderSize, codecSetupHeaderSize, codecPrivateSize);
        return { };
    }

    Vector<uint8_t> cookieData;
    cookieData.append(reinterpret_cast_ptr<const uint8_t*>(&idHeaderSize), sizeof(idHeaderSize));
    cookieData.append(idHeader, idHeaderSize);

    cookieData.append(reinterpret_cast_ptr<const uint8_t*>(&commentHeaderSize), sizeof(commentHeaderSize));
    cookieData.append(commentHeader, commentHeaderSize);

    cookieData.append(reinterpret_cast_ptr<const uint8_t*>(&codecSetupHeaderSize), sizeof(codecSetupHeaderSize));
    cookieData.append(codecSetupHeader, codecSetupHeaderSize);

    return cookieData;
}
#endif // ENABLE(VORBIS)

bool isVorbisDecoderAvailable()
{
#if ENABLE(VORBIS)
    if (!PlatformMediaSessionManager::vorbisDecoderEnabled())
        return false;

    return registerVorbisDecoderIfNeeded();
#else
    return false;
#endif
}

bool registerVorbisDecoderIfNeeded()
{
#if ENABLE(VORBIS)
    static bool available;

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        available = registerDecoderFactory("ACVorbisDecoderFactory", 'vorb');
    });

    return available;
#else
    return false;
#endif
}

RetainPtr<CMFormatDescriptionRef> createVorbisAudioFormatDescription(size_t privateDataSize, const void* privateData)
{
#if ENABLE(VORBIS)
    if (!isVorbisDecoderAvailable())
        return nullptr;

    auto cookieData = cookieFromVorbisCodecPrivate(privateDataSize, privateData);
    if (!cookieData.size())
        return nullptr;

    return createAudioFormatDescriptionForFormat('vorb', WTFMove(cookieData));
#else
    UNUSED_PARAM(privateDataSize);
    UNUSED_PARAM(privateData);
    return nullptr;
#endif
}

}

#endif // PLATFORM(COCOA)