// Copyright (c) Wojciech Figat. All rights reserved.

#if VIDEO_API_ANDROID

#include "VideoBackendAndroid.h"
#include "Engine/Profiler/ProfilerCPU.h"
#include "Engine/Serialization/FileReadStream.h"
#include "Engine/Threading/TaskGraph.h"
#include "Engine/Core/Log.h"
#include "Engine/Engine/Time.h"
#include "Engine/Engine/Globals.h"
#include "Engine/Audio/Types.h"
#include "Engine/Utilities/StringConverter.h"
#include <media/NdkMediaExtractor.h>
#include <media/NdkMediaCodec.h>
#include <media/NdkMediaFormat.h>

#define VIDEO_API_ANDROID_DEBUG (0)
#define VIDEO_API_ANDROID_ERROR(api, err) LOG(Warning, "[VideoBackendAndroid] {} failed with error {}", TEXT(#api), (int64)err)

struct VideoPlayerAndroid
{
    AMediaExtractor* Extractor;
    AMediaCodec* VideoCodec;
    AMediaCodec* AudioCodec;
    AMediaFormat* VideoFormat;
    AMediaFormat* AudioFormat;
    uint8 Loop : 1;
    uint8 Playing : 1;
    uint8 InputEnded : 1;
    uint8 OutputEnded : 1;
    uint16 VideoStride;
    uint16 VideoTrackIndex;
    uint16 AudioTrackIndex;
};

namespace Android
{
    Array<VideoBackendPlayer*> Players;

    // Reference: http://developer.android.com/reference/android/media/MediaCodecInfo.CodecCapabilities.html
    enum ColourFormat
    {
        COLOR_Format12bitRGB444 = 3,
        COLOR_Format16bitARGB1555 = 5,
        COLOR_Format16bitARGB4444 = 4,
        COLOR_Format16bitBGR565 = 7,
        COLOR_Format16bitRGB565 = 6,
        COLOR_Format18BitBGR666 = 41,
        COLOR_Format18bitARGB1665 = 9,
        COLOR_Format18bitRGB666 = 8,
        COLOR_Format19bitARGB1666 = 10,
        COLOR_Format24BitABGR6666 = 43,
        COLOR_Format24BitARGB6666 = 42,
        COLOR_Format24bitARGB1887 = 13,
        COLOR_Format24bitBGR888 = 12,
        COLOR_Format24bitRGB888 = 11,
        COLOR_Format32bitABGR8888 = 0x7f00a000,
        COLOR_Format32bitARGB8888 = 16,
        COLOR_Format32bitBGRA8888 = 15,
        COLOR_Format8bitRGB332 = 2,
        COLOR_FormatCbYCrY = 27,
        COLOR_FormatCrYCbY = 28,
        COLOR_FormatL16 = 36,
        COLOR_FormatL2 = 33,
        COLOR_FormatL32 = 38,
        COLOR_FormatL4 = 34,
        COLOR_FormatL8 = 35,
        COLOR_FormatMonochrome = 1,
        COLOR_FormatRGBAFlexible = 0x7f36a888,
        COLOR_FormatRGBFlexible = 0x7f36b888,
        COLOR_FormatRawBayer10bit = 31,
        COLOR_FormatRawBayer8bit = 30,
        COLOR_FormatRawBayer8bitcompressed = 32,
        COLOR_FormatSurface = 0x7f000789,
        COLOR_FormatYCbYCr = 25,
        COLOR_FormatYCrYCb = 26,
        COLOR_FormatYUV411PackedPlanar = 18,
        COLOR_FormatYUV411Planar = 17,
        COLOR_FormatYUV420Flexible = 0x7f420888,
        COLOR_FormatYUV420PackedPlanar = 20,
        COLOR_FormatYUV420PackedSemiPlanar = 39,
        COLOR_FormatYUV420Planar = 19,
        COLOR_FormatYUV420SemiPlanar = 21,
        COLOR_FormatYUV422Flexible = 0x7f422888,
        COLOR_FormatYUV422PackedPlanar = 23,
        COLOR_FormatYUV422PackedSemiPlanar = 40,
        COLOR_FormatYUV422Planar = 22,
        COLOR_FormatYUV422SemiPlanar = 24,
        COLOR_FormatYUV444Flexible = 0x7f444888,
        COLOR_FormatYUV444Interleaved = 29,
        COLOR_QCOM_FormatYUV420SemiPlanar = 0x7fa30c00,
        COLOR_TI_FormatYUV420PackedSemiPlanar = 0x7f000100,
    };

    ssize_t AMediaDataSourceReadAt(void* userdata, off64_t offset, void* buffer, size_t size)
    {
        if (size == 0)
            return 0;
        auto* stream = (FileReadStream*)userdata;
        stream->SetPosition((uint32)offset);
        stream->ReadBytes(buffer, size);
        return (ssize_t)size;
    }

    ssize_t AMediaDataSourceGetSize(void* userdata)
    {
        auto* stream = (FileReadStream*)userdata;
        return (ssize_t)stream->GetLength();
    }

    void AMediaDataSourceClose(void* userdata)
    {
        auto* stream = (FileReadStream*)userdata;
        Delete(stream);
    }

    void UpdateFormat(VideoBackendPlayer& player, VideoPlayerAndroid& playerAndroid, AMediaCodec* codec, AMediaFormat* format)
    {
        const bool isVideo = codec == playerAndroid.VideoCodec;
        const bool isAudio = codec == playerAndroid.AudioCodec;
        if (isVideo)
        {
            int32_t frameWidth = 0, frameHeight = 0, frameRate = 0, colorFormat = 0, stride = 0;
            float frameRateF = 0.0f;
            AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &frameWidth);
            AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, &frameHeight);
            if (AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_FRAME_RATE, &frameRate) && frameRate > 0)
                player.FrameRate = (float)frameRate;
            else if (AMediaFormat_getFloat(format, AMEDIAFORMAT_KEY_FRAME_RATE, &frameRateF) && frameRateF > 0)
                player.FrameRate = frameRateF;
            else
                player.FrameRate = 60;
            AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_STRIDE, &stride);
            playerAndroid.VideoStride = stride;
            player.Width = player.VideoFrameWidth = frameWidth;
            player.Height = player.VideoFrameHeight = frameHeight;
            AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_COLOR_FORMAT, &colorFormat);
            switch (colorFormat)
            {
            case COLOR_Format32bitABGR8888:
                player.Format = PixelFormat::R8G8B8A8_UNorm;
                break;
            case COLOR_Format32bitBGRA8888:
                player.Format = PixelFormat::B8G8R8A8_UNorm;
                break;
            case COLOR_FormatYUV420SemiPlanar:
                player.Format = PixelFormat::NV12;
                break;
            case COLOR_FormatYUV422SemiPlanar:
                player.Format = PixelFormat::YUY2;
                break;
            default:
                player.Format = PixelFormat::Unknown;
                LOG(Error, "[VideoBackendAndroid] Unsupported video color format {}", colorFormat);
                break;
            }
#if VIDEO_API_ANDROID_DEBUG
            LOG(Info, "[VideoBackendAndroid] Video track: {}x{}, {}fps", player.Width, player.Height, player.FrameRate);
#endif
        }
        else if (isAudio)
        {
            int32_t sampleRate = 0, channelCount = 0, bitsPerSample = 0;
            AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &sampleRate);
            AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &channelCount);
            player.AudioInfo.SampleRate = sampleRate;
            player.AudioInfo.NumChannels = channelCount;
            if (AMediaFormat_getInt32(format, "bits-per-sample", &bitsPerSample) && bitsPerSample > 0)
                player.AudioInfo.BitDepth = bitsPerSample;
            else
                player.AudioInfo.BitDepth = 16;
#if VIDEO_API_ANDROID_DEBUG
            LOG(Info, "[VideoBackendAndroid] Audio track: {} channels, {} bits, {} kHz sample rate", player.AudioInfo.NumChannels, player.AudioInfo.BitDepth, player.AudioInfo.SampleRate / 1000);
#endif
        }
    }

    void ReadCodecOutput(VideoBackendPlayer& player, VideoPlayerAndroid& playerAndroid, AMediaCodec* codec, AMediaFormat* format)
    {
        if (!codec)
            return;
        PROFILE_CPU();
        AMediaCodecBufferInfo bufferInfo;
        ssize_t bufferIndex = AMediaCodec_dequeueOutputBuffer(codec, &bufferInfo, 0);
        if (bufferIndex >= 0)
        {
            if (bufferInfo.size > 0)
            {
                TimeSpan frameTime(bufferInfo.presentationTimeUs * 10), frameDuration = TimeSpan::FromSeconds(1.0f / player.FrameRate);
                size_t bufferSize = 0;
                uint8_t* buffer = AMediaCodec_getOutputBuffer(codec, bufferIndex, &bufferSize);
                ASSERT(buffer && bufferSize);
                if (codec == playerAndroid.VideoCodec)
                {
                    // Depending on the format vide frame might have different dimensions (eg. h264 block padding) so deduct this from buffer size (Android doesn't report correct frame cropping)
                    switch (player.Format)
                    {
                    case PixelFormat::YUY2:
                    case PixelFormat::NV12:
                        //player.VideoFrameHeight = bufferSize / playerAndroid.VideoStride / 3 * 2;
                        bufferSize = player.VideoFrameHeight * playerAndroid.VideoStride * 3 / 2;
                        break;
                    }

                    // TODO: use VideoStride and repack texture if stride is different from RenderTools::ComputePitch (UpdateVideoFrame can handle pitch convert directly into frame buffer)
                    player.UpdateVideoFrame(Span<byte>(buffer, bufferSize), frameTime, frameDuration);
                }
                else if (codec == playerAndroid.AudioCodec)
                {
                    player.UpdateAudioBuffer(Span<byte>(buffer + bufferInfo.offset, bufferInfo.size), frameTime, frameDuration);
                }
            }
            media_status_t status = AMediaCodec_releaseOutputBuffer(codec, bufferIndex, false);
            if (status != AMEDIA_OK)
            {
                VIDEO_API_ANDROID_ERROR(AMediaCodec_releaseOutputBuffer, status);
            }
        }
        else if (bufferIndex == AMEDIACODEC_INFO_TRY_AGAIN_LATER)
        {
            // Skip
        }
        else if (bufferIndex == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED)
        {
            // Ignore
        }
        else if (bufferIndex == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED)
        {
            if (format)
            {
                AMediaFormat_delete(format);
                format = nullptr;
            }
            format = AMediaCodec_getOutputFormat(codec);
            ASSERT_LOW_LAYER(format);
            UpdateFormat(player, playerAndroid, codec, format);
        }
        else
        {
            VIDEO_API_ANDROID_ERROR(AMediaCodec_dequeueOutputBuffer, bufferIndex);
        }
    }

    void UpdatePlayer(int32 index)
    {
        PROFILE_CPU();
        auto& player = *Players[index];
        ZoneText(player.DebugUrl, player.DebugUrlLen);
        auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();

        // Skip paused player
        if (!playerAndroid.Playing || (playerAndroid.InputEnded && playerAndroid.OutputEnded))
            return;
        media_status_t status;
        ssize_t bufferIndex;

        // Get current sample info
        int64_t presentationTimeUs = AMediaExtractor_getSampleTime(playerAndroid.Extractor);
        int trackIndex = AMediaExtractor_getSampleTrackIndex(playerAndroid.Extractor);
        if (trackIndex < 0)
        {
#if VIDEO_API_ANDROID_DEBUG
            LOG(Info, "[VideoBackendAndroid] Samples track ended");
#endif
            if (playerAndroid.Loop)
            {
                // Loop
                status = AMediaExtractor_seekTo(playerAndroid.Extractor, 0, AMEDIAEXTRACTOR_SEEK_CLOSEST_SYNC);
                if (status != AMEDIA_OK)
                {
                    VIDEO_API_ANDROID_ERROR(AMediaExtractor_seekTo, status);
                }
                if (playerAndroid.VideoCodec)
                    AMediaCodec_flush(playerAndroid.VideoCodec);
                if (playerAndroid.AudioCodec)
                    AMediaCodec_flush(playerAndroid.VideoCodec);
            }
            else
            {
                // Emd
                playerAndroid.InputEnded = playerAndroid.OutputEnded = 1;
            }
        }
        else if (trackIndex == playerAndroid.VideoTrackIndex || trackIndex == playerAndroid.AudioTrackIndex)
        {
            auto codec = trackIndex == playerAndroid.VideoTrackIndex ? playerAndroid.VideoCodec : playerAndroid.AudioCodec;

            // Process input buffer
            bufferIndex = AMediaCodec_dequeueInputBuffer(codec, 2000);
            if (bufferIndex >= 0)
            {
                size_t bufferSize;
                uint8_t* buffer = AMediaCodec_getInputBuffer(codec, bufferIndex, &bufferSize);
                ssize_t sampleSize = AMediaExtractor_readSampleData(playerAndroid.Extractor, buffer, bufferSize);
                uint32_t queueInputFlags = 0;
                if (sampleSize < 0)
                {
                    queueInputFlags |= AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM;
                    sampleSize = 0;
                }
                status = AMediaCodec_queueInputBuffer(codec, bufferIndex, 0, sampleSize, presentationTimeUs, queueInputFlags);
                if (status != AMEDIA_OK)
                {
                    VIDEO_API_ANDROID_ERROR(AMediaCodec_queueInputBuffer, status);
                }
                AMediaExtractor_advance(playerAndroid.Extractor);
            }
            else if (bufferIndex == AMEDIACODEC_INFO_TRY_AGAIN_LATER)
            {
                // Skip
            }
            else
            {
                VIDEO_API_ANDROID_ERROR(AMediaCodec_dequeueInputBuffer, bufferIndex);
            }
        }

        if (!playerAndroid.OutputEnded)
        {
            // Process output buffers
            ReadCodecOutput(player, playerAndroid, playerAndroid.VideoCodec, playerAndroid.VideoFormat);
            ReadCodecOutput(player, playerAndroid, playerAndroid.AudioCodec, playerAndroid.AudioFormat);
        }

        player.Tick();
    }
}

bool VideoBackendAndroid::Player_Create(const VideoBackendPlayerInfo& info, VideoBackendPlayer& player)
{
    PROFILE_CPU();
    player = VideoBackendPlayer();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    media_status_t status;

    // Load media
    playerAndroid.Extractor = AMediaExtractor_new();
    if (!playerAndroid.Extractor)
    {
        VIDEO_API_ANDROID_ERROR(AMediaExtractor_new, 0);
        return true;
    }
    FileReadStream* fileStream = nullptr;
    if (!info.Url.StartsWith(TEXT("http"), StringSearchCase::IgnoreCase))
    {
        if (info.Url.StartsWith(TEXT("Content/"), StringSearchCase::CaseSensitive))
            fileStream = FileReadStream::Open(Globals::ProjectFolder / info.Url);
        else
            fileStream = FileReadStream::Open(info.Url);
    }
    if (fileStream)
    {
        // File (AAsset* or Unix handle)
#if VIDEO_API_ANDROID_DEBUG
        LOG(Info, "[VideoBackendAndroid] Loading local file '{}'", info.Url);
#endif
        auto* mediaSource = AMediaDataSource_new();
        AMediaDataSource_setUserdata(mediaSource, fileStream);
        AMediaDataSource_setReadAt(mediaSource, Android::AMediaDataSourceReadAt);
        AMediaDataSource_setGetSize(mediaSource, Android::AMediaDataSourceGetSize);
        AMediaDataSource_setClose(mediaSource, Android::AMediaDataSourceClose);
        status = AMediaExtractor_setDataSourceCustom(playerAndroid.Extractor, mediaSource);
    }
    else
    {
        // Url
#if VIDEO_API_ANDROID_DEBUG
        LOG(Info, "[VideoBackendAndroid] Loading url '{}'", info.Url);
#endif
        const StringAsANSI<> url(info.Url.Get(), info.Url.Length());
        status = AMediaExtractor_setDataSource(playerAndroid.Extractor, url.Get());
    }
    if (status != AMEDIA_OK)
    {
        VIDEO_API_ANDROID_ERROR(AMediaExtractor_setDataSource, status);
        AMediaExtractor_delete(playerAndroid.Extractor);
        return true;
    }

    // Load tracks
    playerAndroid.VideoTrackIndex = playerAndroid.AudioTrackIndex = MAX_uint16;
    player.FrameRate = 24;
    size_t tracks = AMediaExtractor_getTrackCount(playerAndroid.Extractor);
    for (size_t trackIndex = 0; trackIndex < tracks; trackIndex++)
    {
        AMediaFormat* trackFormat = AMediaExtractor_getTrackFormat(playerAndroid.Extractor, trackIndex);
#if VIDEO_API_ANDROID_DEBUG
        const char* trackFormatName = AMediaFormat_toString(trackFormat);
        LOG(Info, "[VideoBackendAndroid] Track [{}]: {}", trackIndex, String(trackFormatName));
#endif
        const char* mime;
        if (AMediaFormat_getString(trackFormat, AMEDIAFORMAT_KEY_MIME, &mime))
        {
            if (playerAndroid.VideoCodec == nullptr && !strncmp(mime, "video/", 6))
            {
                // Video track
                playerAndroid.VideoCodec = AMediaCodec_createDecoderByType(mime);
                status = AMediaCodec_configure(playerAndroid.VideoCodec, trackFormat, nullptr, nullptr, 0);
                if (status != AMEDIA_OK)
                {
                    VIDEO_API_ANDROID_ERROR(AMediaCodec_configure, status);
                    AMediaCodec_delete(playerAndroid.VideoCodec);
                    playerAndroid.VideoCodec = nullptr;
                }
                else
                {
                    status = AMediaExtractor_selectTrack(playerAndroid.Extractor, trackIndex);
                    if (status != AMEDIA_OK)
                    {
                        VIDEO_API_ANDROID_ERROR(AMediaExtractor_selectTrack, status);
                        AMediaCodec_delete(playerAndroid.VideoCodec);
                        playerAndroid.VideoCodec = nullptr;
                    }
                    else
                    {
                        playerAndroid.VideoTrackIndex = trackIndex;
                        Android::UpdateFormat(player, playerAndroid, playerAndroid.VideoCodec, trackFormat);
                    }
                }
            }
            else if (playerAndroid.AudioCodec == nullptr && !strncmp(mime, "audio/", 6))
            {
                // Audio track
                playerAndroid.AudioCodec = AMediaCodec_createDecoderByType(mime);
                status = AMediaCodec_configure(playerAndroid.AudioCodec, trackFormat, nullptr, nullptr, 0);
                if (status != AMEDIA_OK)
                {
                    VIDEO_API_ANDROID_ERROR(AMediaCodec_configure, status);
                    AMediaCodec_delete(playerAndroid.AudioCodec);
                    playerAndroid.AudioCodec = nullptr;
                }
                else
                {
                    status = AMediaExtractor_selectTrack(playerAndroid.Extractor, trackIndex);
                    if (status != AMEDIA_OK)
                    {
                        VIDEO_API_ANDROID_ERROR(AMediaExtractor_selectTrack, status);
                        AMediaCodec_delete(playerAndroid.AudioCodec);
                        playerAndroid.AudioCodec = nullptr;
                    }
                    else
                    {
                        playerAndroid.AudioTrackIndex = trackIndex;
                        Android::UpdateFormat(player, playerAndroid, playerAndroid.AudioCodec, trackFormat);
                    }
                }
            }
        }
        AMediaFormat_delete(trackFormat);
    }

    // Setup player data
    player.Backend = this;
    playerAndroid.Loop = info.Loop;
    player.Created(info);
    Android::Players.Add(&player);

    return false;
}

void VideoBackendAndroid::Player_Destroy(VideoBackendPlayer& player)
{
    PROFILE_CPU();
    player.ReleaseResources();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    if (playerAndroid.VideoFormat)
        AMediaFormat_delete(playerAndroid.VideoFormat);
    if (playerAndroid.VideoCodec)
        AMediaCodec_delete(playerAndroid.VideoCodec);
    if (playerAndroid.AudioFormat)
        AMediaFormat_delete(playerAndroid.AudioFormat);
    if (playerAndroid.AudioCodec)
        AMediaCodec_delete(playerAndroid.AudioCodec);
    AMediaExtractor_delete(playerAndroid.Extractor);
    Android::Players.Remove(&player);
    player = VideoBackendPlayer();
}

void VideoBackendAndroid::Player_UpdateInfo(VideoBackendPlayer& player, const VideoBackendPlayerInfo& info)
{
    PROFILE_CPU();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    playerAndroid.Loop = info.Loop;
    player.Updated(info);
}

void VideoBackendAndroid::Player_Play(VideoBackendPlayer& player)
{
    PROFILE_CPU();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    playerAndroid.Playing = 1;
    playerAndroid.InputEnded = playerAndroid.OutputEnded = 0;
    if (playerAndroid.VideoCodec)
        AMediaCodec_start(playerAndroid.VideoCodec);
    if (playerAndroid.AudioCodec)
        AMediaCodec_start(playerAndroid.AudioCodec);
    player.PlayAudio();
}

void VideoBackendAndroid::Player_Pause(VideoBackendPlayer& player)
{
    PROFILE_CPU();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    playerAndroid.Playing = 0;
    if (playerAndroid.VideoCodec)
        AMediaCodec_stop(playerAndroid.VideoCodec);
    if (playerAndroid.AudioCodec)
        AMediaCodec_stop(playerAndroid.AudioCodec);
    player.PauseAudio();
}

void VideoBackendAndroid::Player_Stop(VideoBackendPlayer& player)
{
    PROFILE_CPU();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    player.VideoFrameDuration = player.AudioBufferDuration = TimeSpan::Zero();
    playerAndroid.Playing = 0;
    playerAndroid.InputEnded = playerAndroid.OutputEnded = 0;
    media_status_t status = AMediaExtractor_seekTo(playerAndroid.Extractor, 0, AMEDIAEXTRACTOR_SEEK_CLOSEST_SYNC);
    if (status != AMEDIA_OK)
    {
        VIDEO_API_ANDROID_ERROR(AMediaExtractor_seekTo, status);
    }
    if (playerAndroid.VideoCodec)
    {
        AMediaCodec_stop(playerAndroid.VideoCodec);
        AMediaCodec_flush(playerAndroid.VideoCodec);
    }
    if (playerAndroid.AudioCodec)
    {
        AMediaCodec_stop(playerAndroid.VideoCodec);
        AMediaCodec_flush(playerAndroid.VideoCodec);
    }
    player.StopAudio();
}

void VideoBackendAndroid::Player_Seek(VideoBackendPlayer& player, TimeSpan time)
{
    PROFILE_CPU();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    player.VideoFrameDuration = player.AudioBufferDuration = TimeSpan::Zero();
    media_status_t status = AMediaExtractor_seekTo(playerAndroid.Extractor, time.Ticks / 10, AMEDIAEXTRACTOR_SEEK_PREVIOUS_SYNC);
    if (status != AMEDIA_OK)
    {
        VIDEO_API_ANDROID_ERROR(AMediaExtractor_seekTo, status);
    }
    if (playerAndroid.VideoCodec)
        AMediaCodec_flush(playerAndroid.VideoCodec);
    if (playerAndroid.AudioCodec)
        AMediaCodec_flush(playerAndroid.AudioCodec);
    player.StopAudio();
}

TimeSpan VideoBackendAndroid::Player_GetTime(const VideoBackendPlayer& player)
{
    PROFILE_CPU();
    auto& playerAndroid = player.GetBackendState<VideoPlayerAndroid>();
    int64 time = AMediaExtractor_getSampleTime(playerAndroid.Extractor);
    if (time < 0)
        return TimeSpan::Zero();
    return TimeSpan(time * 10);
}

const Char* VideoBackendAndroid::Base_Name()
{
    return TEXT("Android NDK Media");
}

bool VideoBackendAndroid::Base_Init()
{
    return false;
}

void VideoBackendAndroid::Base_Update(TaskGraph* graph)
{
    // Schedule work to update all videos in async
    Function<void(int32)> job;
    job.Bind(Android::UpdatePlayer);
    graph->DispatchJob(job, Android::Players.Count());
}

void VideoBackendAndroid::Base_Dispose()
{
}

#endif
