/*
 * Copyright (c) 2020 Amlogic, Inc. All rights reserved.
 *
 * This source code is subject to the terms and conditions defined in the
 * file 'LICENSE' which is part of this source code package.
 *
 * Description:
 */

#define LOG_TAG "AmlMpUtils"
#include <utils/AmlMpLog.h>
#include "AmlMpUtils.h"
#include <unistd.h>
#include <sstream>
#include "utils/Amlsysfsutils.h"
#ifdef HAVE_SUBTITLE
#include <SubtitleNativeAPI.h>
#endif

#ifdef ANDROID
#ifndef __ANDROID_RECOVERY__
#include <amlogic/am_gralloc_ext.h>
#include <system/window.h>
#include <video_tunnel.h>
#include <hardware/gralloc1.h>

#ifndef __ANDROID_VNDK__
#include <gui/Surface.h>
#endif
#endif
#endif

static const char* mName = LOG_TAG;

namespace aml_mp {
#define ENUM_TO_STR(e) case e: return TO_STR(e); break
#define TO_STR(v) #v

void Aml_MP_PrintAssert(const char*fmt, ...)
{
    char buf[1024];

    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, sizeof(buf), fmt, ap);
    va_end(ap);

#ifdef __linux__
#ifndef ANDROID
    fprintf(stderr, "%s\n", buf);
#endif
#endif
    __android_log_print(ANDROID_LOG_FATAL, AML_MP_LOG_TAG, "%s", buf);

    __builtin_trap(); /* trap so we have a chance to debug the situation */
}

const char* mpCodecId2Str(Aml_MP_CodecID codecId)
{
    switch (codecId) {
        ENUM_TO_STR(AML_MP_CODEC_UNKNOWN);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_BASE);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_MPEG12);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_MPEG4);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_H264);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_VC1);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_AVS);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_HEVC);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_VP9);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_AVS2);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_MJPEG);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_AV1);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_DVES_AVC);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_DVES_HEVC);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_VVC);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_AVS3);
        ENUM_TO_STR(AML_MP_VIDEO_CODEC_MAX);

        ENUM_TO_STR(AML_MP_AUDIO_CODEC_BASE);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_MP2);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_MP3);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_AC3);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_EAC3);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_DTS);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_AAC);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_LATM);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_PCM);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_AC4);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_FLAC);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_VORBIS);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_OPUS);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_PCM_ADPCM_IMA_WAV);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_HEAAC_V1);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_HEAAC_V2);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_MPEGH);
        ENUM_TO_STR(AML_MP_AUDIO_CODEC_MAX);

        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_BASE);
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_CC);
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_SCTE27);
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_DVB);
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_TELETEXT);
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_TTML);//TTML Subtitle Support
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_ASS);
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_SUBRIP);
        ENUM_TO_STR(AML_MP_SUBTITLE_CODEC_MAX);
        default: return "unknown codec Id";
    }
}

const char* mpStreamType2Str(Aml_MP_StreamType streamType)
{
    switch (streamType) {
        case AML_MP_STREAM_TYPE_VIDEO: return "VIDEO";
        case AML_MP_STREAM_TYPE_AUDIO: return "AUDIO";
        case AML_MP_STREAM_TYPE_AD: return "AD";
        case AML_MP_STREAM_TYPE_SUBTITLE: return "SUBTITLE";
        case AML_MP_STREAM_TYPE_TELETEXT: return "TELETEXT";
        case AML_MP_STREAM_TYPE_ECM: return "ECM";
        case AML_MP_STREAM_TYPE_EMM: return "EMM";
        case AML_MP_STREAM_TYPE_SECTION: return "SECTION";
        case AML_MP_STREAM_TYPE_UNKNOWN:
        default:
            return "UNKNOWN";
    }
}

const char* mpDemuxId2Str(Aml_MP_DemuxId demuxId) {
    switch (demuxId) {
        ENUM_TO_STR(AML_MP_DEMUX_ID_DEFAULT);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_0);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_1);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_2);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_3);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_4);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_5);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_6);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_7);
        ENUM_TO_STR(AML_MP_HW_DEMUX_ID_MAX);
        default:
            return "unknown demux Id";
    }
}

const char* mpPlayerParameterKey2Str(Aml_MP_PlayerParameterKey playerParamKey) {
    switch (playerParamKey) {
        //set/get
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_SET_BASE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_DISPLAY_MODE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_BLACK_OUT);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_DECODE_MODE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_PTS_OFFSET);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_OUTPUT_MODE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_OUTPUT_DEVICE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_PTS_OFFSET);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_BALANCE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_MUTE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_CREATE_PARAMS);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_NETWORK_JITTER);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AD_STATE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AD_MIX_LEVEL);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_WORK_MODE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_WINDOW_ZORDER);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_TELETEXT_CONTROL);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VENDOR_ID);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_TUNNEL_ID);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_SURFACE_HANDLE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_PRESENTATION_ID);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_USE_TIF);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_SPDIF_PROTECTION);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_CROP);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_ERROR_RECOVERY_MODE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_AFD_ASPECT_MODE);
        //get only
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_GET_BASE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_INFO);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_DECODE_STAT);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_INFO);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AUDIO_DECODE_STAT);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_SUBTITLE_INFO);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_SUBTITLE_DECODE_STAT);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AD_INFO);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AD_DECODE_STAT);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_INSTANCE_ID);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_SYNC_ID);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_VIDEO_SHOW_STATE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AV_INFO_JSON);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_TSPLAYER_HANDLE);
        ENUM_TO_STR(AML_MP_PLAYER_PARAMETER_AV_STAT_JSON);
        default:
            return "unknown player parameter key";
    }
}

const char* mpAVSyncSource2Str(Aml_MP_AVSyncSource syncSource) {
    switch (syncSource) {
        ENUM_TO_STR(AML_MP_AVSYNC_SOURCE_DEFAULT);
        ENUM_TO_STR(AML_MP_AVSYNC_SOURCE_VIDEO);
        ENUM_TO_STR(AML_MP_AVSYNC_SOURCE_AUDIO);
        ENUM_TO_STR(AML_MP_AVSYNC_SOURCE_PCR);
        default:
            return "unknown av sync source";
    }
}

const char* mpPlayerEventType2Str(Aml_MP_PlayerEventType eventType) {
    switch (eventType) {
        ENUM_TO_STR(AML_MP_EVENT_UNKNOWN);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_FIRST_FRAME);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AV_SYNC_DONE);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_DATA_LOSS);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_DATA_RESUME);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SCRAMBLING);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_USERDATA_AFD);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_USERDATA_CC);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_PID_CHANGED);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_DECODER_DATA_LOSS);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_DECODER_DATA_RESUME);
        // DVR player
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_ERROR);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_TRANSITION_OK);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_TRANSITION_FAILED);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_KEY_FAILURE);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_NO_KEY);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_REACHED_BEGIN);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_REACHED_END);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_NOTIFY_PLAYTIME);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_TIMESHIFT_FR_REACHED_BEGIN);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_TIMESHIFT_FF_REACHED_END);
        ENUM_TO_STR(AML_MP_DVRPLAYER_EVENT_AUTO_RESUMED);
        // Video event
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_BASE);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_CHANGED);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_DECODE_FIRST_FRAME);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_OVERFLOW);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_UNDERFLOW);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_INVALID_TIMESTAMP);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_INVALID_DATA);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_ERROR_FRAME_COUNT);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_UNSUPPORT);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_VIDEO_INPUT_BUFFER_DONE);

        // Audio event
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_BASE);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_CHANGED);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_DECODE_FIRST_FRAME);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_OVERFLOW);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_UNDERFLOW);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_INVALID_TIMESTAMP);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_INVALID_DATA);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_AUDIO_INPUT_BUFFER_DONE);

        // Subtitle event
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_BASE);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_DATA);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_AVAIL);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_DIMENSION);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_AFD_EVENT);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_CHANNEL_UPDATE);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_LANGUAGE);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_INFO);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_LOSEDATA);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_TIMEOUT);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_INVALID_TIMESTAMP);
        ENUM_TO_STR(AML_MP_PLAYER_EVENT_SUBTITLE_INVALID_DATA);

        //mediaplayer
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_BASE);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_PLAYBACK_COMPLETE);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_PLAYBACK_SOF);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_PREPARED);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_STOPPED);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_MEDIA_ERROR);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_FIRST_FRAME_TOGGLED);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_BUFFERING_START);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_BUFFERING_END);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_VIDEO_UNSUPPORT);
        ENUM_TO_STR(AML_MP_MEDIAPLAYER_EVENT_AUDIO_UNSUPPORT);

        default:
            return "unknown player event type";
    }

}

const char* mpPlayerWorkMode2Str(Aml_MP_PlayerWorkMode workmode) {
    switch (workmode) {
        ENUM_TO_STR(AML_MP_PLAYER_MODE_NORMAL);
        ENUM_TO_STR(AML_MP_PLAYER_MODE_CACHING_ONLY);
        ENUM_TO_STR(AML_MP_PLAYER_MODE_DECODE_ONLY);
        default:
            return "unknown player work mode";
    }
}

const char* mpInputStreamType2Str(Aml_MP_InputStreamType inputStreamType) {
    switch (inputStreamType) {
        ENUM_TO_STR(AML_MP_INPUT_STREAM_NORMAL);
        ENUM_TO_STR(AML_MP_INPUT_STREAM_ENCRYPTED);
        ENUM_TO_STR(AML_MP_INPUT_STREAM_SECURE_MEMORY);
        default:
            return "unknown input stream type";
    }
}

const char* mpInputSourceType2Str(Aml_MP_InputSourceType inputSourceType) {
    switch (inputSourceType) {
        ENUM_TO_STR(AML_MP_INPUT_SOURCE_TS_DEMOD);
        ENUM_TO_STR(AML_MP_INPUT_SOURCE_TS_MEMORY);
        ENUM_TO_STR(AML_MP_INPUT_SOURCE_ES_MEMORY);
        ENUM_TO_STR(AML_MP_INPUT_SOURCE_USBCAM);
        default:
            return "unknown input source type";
    }
}

const char* mpCASType2Str(Aml_MP_CASType casType) {
    switch (casType) {
        ENUM_TO_STR(AML_MP_CAS_UNKNOWN);
        ENUM_TO_STR(AML_MP_CAS_VERIMATRIX_IPTV);
        ENUM_TO_STR(AML_MP_CAS_WIDEVINE);
        ENUM_TO_STR(AML_MP_CAS_VERIMATRIX_WEB);
        default:
            return "unknown CAS type";
    }
}

const char* mpVideoDecodeMode2Str(Aml_MP_VideoDecodeMode decodeMode) {
    switch (decodeMode) {
        ENUM_TO_STR(AML_MP_VIDEO_DECODE_MODE_NONE);
        ENUM_TO_STR(AML_MP_VIDEO_DECODE_MODE_IONLY);
        ENUM_TO_STR(AML_MP_VIDEO_DECODE_MODE_PAUSE);
        ENUM_TO_STR(AML_MP_VIDEO_DECODE_MODE_PAUSE_NEXT);
        ENUM_TO_STR(AML_MP_VIDEO_DECODE_MODE_IONLY_SYNC);
        default:
            return "unknown video decode mode";
    }
}

const char* mpCASServiceType2Str(Aml_MP_CASServiceType serviceType)
{
    switch (serviceType) {
    case AML_MP_CAS_SERVICE_LIVE_PLAY: return "live play";
    case AML_MP_CAS_SERVICE_PVR_RECORDING: return "pvr recording";
    case AML_MP_CAS_SERVICE_PVR_PLAY: return "pvr playback";
    case AML_MP_CAS_SERVICE_PVR_TIMESHIFT_RECORDING: return "pvr recording for timeshift";
    case AML_MP_CAS_SERVICE_PVR_TIMESHIFT_PLAY: return "pvr playback for timeshift";
    case AML_MP_CAS_SERVICE_VERIMATRIX_IPTV: return "verimatrix IPTV";
    case AML_MP_CAS_SERVICE_VERIMATRIX_WEB: return "verimatrix WEB";
    case AML_MP_CAS_SERVICE_NAGRA_WEB: return "nagra WEB";
    case AML_MP_CAS_SERVICE_WIDEVINE: return "widevine";
    default: break;
    }

    return TO_STR(AML_MP_CAS_SERVICE_TYPE_INVALID);
}

const char* mpVideoErrorRecoveryMode2Str(Aml_MP_VideoErrorRecoveryMode errorRecoveryMode) {
    switch (errorRecoveryMode) {
        ENUM_TO_STR(AML_MP_VIDEO_ERROR_RECOVERY_DROP);
        ENUM_TO_STR(AML_MP_VIDEO_ERROR_RECOVERY_NONE);
        ENUM_TO_STR(AML_MP_VIDEO_ERROR_RECOVERY_DEFAULT);
        default:
            return "Unknown video error recovery mode";
    }
}

const char* mpVideoAFDAspectMode2Str(Aml_MP_VideoAFDAspectMode afdAspectMode) {
    switch (afdAspectMode) {
        ENUM_TO_STR(AML_MP_VIDEO_AFD_ASPECT_MODE_NONE);
        ENUM_TO_STR(AML_MP_VIDEO_AFD_ASPECT_MODE_AUTO);
        ENUM_TO_STR(AML_MP_VIDEO_AFD_ASPECT_MODE_4_3);
        ENUM_TO_STR(AML_MP_VIDEO_AFD_ASPECT_MODE_16_9);
        ENUM_TO_STR(AML_MP_VIDEO_AFD_ASPECT_MODE_14_9);
        ENUM_TO_STR(AML_MP_VIDEO_AFD_ASPECT_MODE_ZOOM);
        ENUM_TO_STR(AML_MP_VIDEO_AFD_ASPECT_MODE_CUSTOM);
        default:
            return "Unknown video afd aspect mode";
    }
}

void convertToTsPlayerAudioLanguage(am_tsplayer_audio_lang* tsPlayerAudioLang, Aml_MP_AudioLanguage* audioLanguage)
{
    tsPlayerAudioLang->first_lang = audioLanguage->firstLanguage;
    tsPlayerAudioLang->second_lang = audioLanguage->secondLanguage;
}

////////////////////////////////////////////////////////////////////////
#ifdef ANDROID
#ifndef __ANDROID_RECOVERY__
vformat_t convertToVFormat(Aml_MP_CodecID videoCodec)
{
    vformat_t vFormat = VFORMAT_UNKNOWN;

    switch (videoCodec) {
    case AML_MP_VIDEO_CODEC_MPEG12:
        vFormat = VFORMAT_MPEG12;
        break;

    case AML_MP_VIDEO_CODEC_MPEG4:
        vFormat = VFORMAT_MPEG4;
        break;

    case AML_MP_VIDEO_CODEC_H264:
        vFormat = VFORMAT_H264;
        break;

    case AML_MP_VIDEO_CODEC_VC1:
        vFormat = VFORMAT_VC1;
        break;

    case AML_MP_VIDEO_CODEC_AVS:
        vFormat = VFORMAT_AVS;
        break;

    case AML_MP_VIDEO_CODEC_HEVC:
        vFormat = VFORMAT_HEVC;
        break;

    case AML_MP_VIDEO_CODEC_VP9:
        vFormat = VFORMAT_VP9;
        break;

#if ANDROID_PLATFORM_SDK_VERSION <= 29
    case AML_MP_VIDEO_CODEC_AVS2:
        vFormat = VFORMAT_AVS2;
        break;
#endif

    default:
        MLOGE("unknown videoCodec:%d", videoCodec);
        break;
    }

    return vFormat;

}

aformat_t convertToAForamt(Aml_MP_CodecID audioCodec)
{
    aformat_t aFormat = AFORMAT_UNKNOWN;

    switch (audioCodec) {
    case AML_MP_AUDIO_CODEC_MP2:
        aFormat = AFORMAT_MPEG2;
        break;

    case AML_MP_AUDIO_CODEC_MP3:
        aFormat = AFORMAT_MPEG;
        break;

    case AML_MP_AUDIO_CODEC_AC3:
        aFormat = AFORMAT_AC3;
        break;

    case AML_MP_AUDIO_CODEC_EAC3:
        aFormat = AFORMAT_EAC3;
        break;

    case AML_MP_AUDIO_CODEC_DTS:
        aFormat = AFORMAT_DTS;
        break;

    case AML_MP_AUDIO_CODEC_AAC:
        aFormat = AFORMAT_AAC;
        break;

    case AML_MP_AUDIO_CODEC_LATM:
        aFormat = AFORMAT_AAC_LATM;
        break;

    case AML_MP_AUDIO_CODEC_PCM:
        aFormat = AFORMAT_PCM_S16LE;
        break;

    default:
        MLOGE("unknown audioCodec:%d", audioCodec);
        break;
    }

    return aFormat;
}
#endif
#endif

am_tsplayer_video_codec convertToVideoCodec(Aml_MP_CodecID aml_MP_VideoCodec) {
    switch (aml_MP_VideoCodec) {
        case AML_MP_VIDEO_CODEC_MPEG12:
            return AV_VIDEO_CODEC_MPEG2;
        case AML_MP_VIDEO_CODEC_MPEG4:
            return AV_VIDEO_CODEC_MPEG4;
        case AML_MP_VIDEO_CODEC_H264:
            return AV_VIDEO_CODEC_H264;
        case AML_MP_VIDEO_CODEC_AVS:
            return AV_VIDEO_CODEC_AVS;
        case AML_MP_VIDEO_CODEC_AVS2:
            return AV_VIDEO_CODEC_AVS2;
        case AML_MP_VIDEO_CODEC_VP9:
            return AV_VIDEO_CODEC_VP9;
        case AML_MP_VIDEO_CODEC_HEVC:
            return AV_VIDEO_CODEC_H265;
        case AML_MP_VIDEO_CODEC_MJPEG:
            return AV_VIDEO_CODEC_MJPEG;
#ifdef __linux__
#ifndef ANDROID
            //TODO: android does not merge mediahal, currently only used on Yocto
        case AML_MP_VIDEO_CODEC_AV1:
            return AV_VIDEO_CODEC_AV1;
        case AML_MP_VIDEO_CODEC_VC1:
            return AV_VIDEO_CODEC_VC1;
#endif
#endif

        case AML_MP_VIDEO_CODEC_DVES_AVC:
            return AV_VIDEO_CODEC_DVES_AVC;
        case AML_MP_VIDEO_CODEC_DVES_HEVC:
            return AV_VIDEO_CODEC_DVES_HEVC;
        case AML_MP_VIDEO_CODEC_VVC:
            return AV_VIDEO_CODEC_H266;
        case AML_MP_VIDEO_CODEC_AVS3:
            return AV_VIDEO_CODEC_AVS3;
        default:
            return AV_VIDEO_CODEC_AUTO;
    }
}

am_tsplayer_audio_codec convertToAudioCodec(Aml_MP_CodecID aml_MP_AudioCodec) {
    switch (aml_MP_AudioCodec) {
        case AML_MP_AUDIO_CODEC_MP2:
            return AV_AUDIO_CODEC_MP2;
        case AML_MP_AUDIO_CODEC_MP3:
            return AV_AUDIO_CODEC_MP3;
        case AML_MP_AUDIO_CODEC_AC3:
            return AV_AUDIO_CODEC_AC3;
        case AML_MP_AUDIO_CODEC_EAC3:
            return AV_AUDIO_CODEC_EAC3;
        case AML_MP_AUDIO_CODEC_DTS:
            return AV_AUDIO_CODEC_DTS;
        case AML_MP_AUDIO_CODEC_AAC:
            return AV_AUDIO_CODEC_AAC;
        case AML_MP_AUDIO_CODEC_LATM:
            return AV_AUDIO_CODEC_LATM;
        case AML_MP_AUDIO_CODEC_PCM:
            return AV_AUDIO_CODEC_PCM;
        case AML_MP_AUDIO_CODEC_AC4:
            return AV_AUDIO_CODEC_AC4;
        case AML_MP_AUDIO_CODEC_FLAC:
            return AV_AUDIO_CODEC_FLAC;
        case AML_MP_AUDIO_CODEC_VORBIS:
            return AV_AUDIO_CODEC_VORBIS;
        case AML_MP_AUDIO_CODEC_OPUS:
            return AV_AUDIO_CODEC_OPUS;
        case AML_MP_AUDIO_CODEC_PCM_ADPCM_IMA_WAV:
            return AV_AUDIO_CODEC_PCM_ADPCM_IMA_WAV;
#ifdef ANDROID
        case AML_MP_AUDIO_CODEC_HEAAC_V1:
            return AV_AUDIO_CODEC_HE_AAC_V1;
        case AML_MP_AUDIO_CODEC_HEAAC_V2:
            return AV_AUDIO_CODEC_HE_AAC_V2;
#endif
        case AML_MP_AUDIO_CODEC_MPEGH:
            return AV_AUDIO_CODEC_MPEGH;

        default:
            return AV_AUDIO_CODEC_AUTO;
    }
}

am_tsplayer_input_source_type convertToInputSourceType(Aml_MP_InputSourceType sourceType) {
    switch (sourceType) {
    case AML_MP_INPUT_SOURCE_TS_MEMORY:
        return TS_MEMORY;

    case AML_MP_INPUT_SOURCE_TS_DEMOD:
        return TS_DEMOD;

    case AML_MP_INPUT_SOURCE_ES_MEMORY:
        return ES_MEMORY;

    case AML_MP_INPUT_SOURCE_USBCAM:
        return TS_USB_CAMCARD;

    default:
        return TS_MEMORY;
    }
}

am_tsplayer_avsync_mode convertToAVSyncSourceType(Aml_MP_AVSyncSource avSyncSource) {
    switch (avSyncSource) {
        case AML_MP_AVSYNC_SOURCE_VIDEO:
            return TS_SYNC_VMASTER;
        case AML_MP_AVSYNC_SOURCE_AUDIO:
            return TS_SYNC_AMASTER;
        case AML_MP_AVSYNC_SOURCE_NOSYNC:
            return TS_SYNC_NOSYNC;
        default:
            return TS_SYNC_PCRMASTER;
    }
}

#ifdef HAVE_LIBDVR
Aml_MP_StreamType convertToMpStreamType(DVR_StreamType_t streamType)
{
    switch (streamType) {
        case DVR_STREAM_TYPE_VIDEO:
            return AML_MP_STREAM_TYPE_VIDEO;
        case DVR_STREAM_TYPE_AUDIO:
            return AML_MP_STREAM_TYPE_AUDIO;
        case DVR_STREAM_TYPE_AD:
            return AML_MP_STREAM_TYPE_AD;
        case DVR_STREAM_TYPE_SUBTITLE:
            return AML_MP_STREAM_TYPE_SUBTITLE;
        case DVR_STREAM_TYPE_TELETEXT:
            return AML_MP_STREAM_TYPE_TELETEXT;
        case DVR_STREAM_TYPE_ECM:
            return AML_MP_STREAM_TYPE_ECM;
        case DVR_STREAM_TYPE_EMM:
            return AML_MP_STREAM_TYPE_EMM;
        default:
            return AML_MP_STREAM_TYPE_UNKNOWN;
    }
}

DVR_StreamType_t convertToDVRStreamType(Aml_MP_StreamType streamType)
{
    switch (streamType) {
        case AML_MP_STREAM_TYPE_VIDEO:
            return DVR_STREAM_TYPE_VIDEO;
        case AML_MP_STREAM_TYPE_AUDIO:
            return DVR_STREAM_TYPE_AUDIO;
        case AML_MP_STREAM_TYPE_AD:
            return DVR_STREAM_TYPE_AD;
        case AML_MP_STREAM_TYPE_SUBTITLE:
            return DVR_STREAM_TYPE_SUBTITLE;
        case AML_MP_STREAM_TYPE_TELETEXT:
            return DVR_STREAM_TYPE_TELETEXT;
        case AML_MP_STREAM_TYPE_ECM:
            return DVR_STREAM_TYPE_ECM;
        case AML_MP_STREAM_TYPE_EMM:
            return DVR_STREAM_TYPE_EMM;
        default:
            return DVR_STREAM_TYPE_OTHER;
    }
}

Aml_MP_CodecID convertToMpCodecId(DVR_VideoFormat_t fmt)
{
    Aml_MP_CodecID codecId = AML_MP_CODEC_UNKNOWN;

    switch (fmt) {
    case DVR_VIDEO_FORMAT_MPEG1:
    case DVR_VIDEO_FORMAT_MPEG2:
        codecId = AML_MP_VIDEO_CODEC_MPEG12;
        break;

    case DVR_VIDEO_FORMAT_H264:
        codecId = AML_MP_VIDEO_CODEC_H264;
        break;

    case DVR_VIDEO_FORMAT_HEVC:
        codecId = AML_MP_VIDEO_CODEC_HEVC;
        break;

    case DVR_VIDEO_FORMAT_VP9:
        codecId = AML_MP_VIDEO_CODEC_VP9;
        break;

//libdvr_release doesn't contain the following type definitions
#if !defined (ANDROID) || ANDROID_PLATFORM_SDK_VERSION >= 30
    case DVR_VIDEO_FORMAT_DVES_AVC:
        codecId = AML_MP_VIDEO_CODEC_DVES_AVC;
        break;

    case DVR_VIDEO_FORMAT_DVES_HEVC:
        codecId = AML_MP_VIDEO_CODEC_DVES_HEVC;
        break;

    case DVR_VIDEO_FORMAT_H266:
        codecId = AML_MP_VIDEO_CODEC_VVC;
        break;

    case DVR_VIDEO_FORMAT_AVS3:
        codecId = AML_MP_VIDEO_CODEC_AVS3;
        break;

    case DVR_VIDEO_FORMAT_AVS2:
        codecId = AML_MP_VIDEO_CODEC_AVS2;
        break;

    case DVR_VIDEO_FORMAT_AVS:
        codecId = AML_MP_VIDEO_CODEC_AVS;
        break;
#endif

    default:
        MLOGW("unknown video codec:%d", fmt);
        break;
    }

    return codecId;
}

Aml_MP_CodecID convertToMpCodecId(DVR_AudioFormat_t fmt)
{
    Aml_MP_CodecID codecId = AML_MP_CODEC_UNKNOWN;

    switch (fmt) {
    case DVR_AUDIO_FORMAT_MPEG:
        codecId = AML_MP_AUDIO_CODEC_MP3;
        break;

    case DVR_AUDIO_FORMAT_AC3:
        codecId = AML_MP_AUDIO_CODEC_AC3;
        break;

    case DVR_AUDIO_FORMAT_EAC3:
        codecId = AML_MP_AUDIO_CODEC_EAC3;
        break;

    case DVR_AUDIO_FORMAT_DTS:
        codecId = AML_MP_AUDIO_CODEC_DTS;
        break;

    case DVR_AUDIO_FORMAT_AAC:
        codecId = AML_MP_AUDIO_CODEC_AAC;
        break;

    case DVR_AUDIO_FORMAT_HEAAC:
    case DVR_AUDIO_FORMAT_LATM:
        codecId = AML_MP_AUDIO_CODEC_LATM;
        break;

    case DVR_AUDIO_FORMAT_PCM:
        codecId = AML_MP_AUDIO_CODEC_PCM;
        break;

    case DVR_AUDIO_FORMAT_AC4:
        codecId = AML_MP_AUDIO_CODEC_AC4;
        break;

//libdvr_release doesn't contain the following type definitions
#if !defined (ANDROID) || ANDROID_PLATFORM_SDK_VERSION >= 30
    case DVR_AUDIO_FORMAT_MPEGH:
        codecId = AML_MP_AUDIO_CODEC_MPEGH;
#endif
        break;

    default:
        MLOG("unknown audio codec:%d", fmt);
        break;
    }

    return codecId;
}

DVR_VideoFormat_t convertToDVRVideoFormat(Aml_MP_CodecID codecId)
{
    switch (codecId) {
        case AML_MP_VIDEO_CODEC_MPEG12:
            return DVR_VIDEO_FORMAT_MPEG2;
        case AML_MP_VIDEO_CODEC_H264:
            return DVR_VIDEO_FORMAT_H264;
        case AML_MP_VIDEO_CODEC_HEVC:
            return DVR_VIDEO_FORMAT_HEVC;
        case AML_MP_VIDEO_CODEC_VP9:
            return DVR_VIDEO_FORMAT_VP9;
//libdvr_release doesn't contain the following type definitions
#if !defined (ANDROID) || ANDROID_PLATFORM_SDK_VERSION >= 30
        case AML_MP_VIDEO_CODEC_DVES_AVC:
            return DVR_VIDEO_FORMAT_DVES_AVC;
        case AML_MP_VIDEO_CODEC_DVES_HEVC:
            return DVR_VIDEO_FORMAT_DVES_HEVC;
        case AML_MP_VIDEO_CODEC_VVC:
            return DVR_VIDEO_FORMAT_H266;
        case AML_MP_VIDEO_CODEC_AVS3:
            return DVR_VIDEO_FORMAT_AVS3;
        case AML_MP_VIDEO_CODEC_AVS2:
            return DVR_VIDEO_FORMAT_AVS2;
        case AML_MP_VIDEO_CODEC_AVS:
            return DVR_VIDEO_FORMAT_AVS;
#endif
        default:
            MLOGE("unknown video codecId:%d", codecId);
            return DVR_VIDEO_FORMAT_MPEG2;
    }
}

DVR_AudioFormat_t convertToDVRAudioFormat(Aml_MP_CodecID codecId)
{
    switch (codecId) {
        case AML_MP_AUDIO_CODEC_MP2:
        case AML_MP_AUDIO_CODEC_MP3:
            return DVR_AUDIO_FORMAT_MPEG;
        case AML_MP_AUDIO_CODEC_AC3:
            return DVR_AUDIO_FORMAT_AC3;
        case AML_MP_AUDIO_CODEC_EAC3:
            return DVR_AUDIO_FORMAT_EAC3;
        case AML_MP_AUDIO_CODEC_DTS:
            return DVR_AUDIO_FORMAT_DTS;
        case AML_MP_AUDIO_CODEC_AAC:
            return DVR_AUDIO_FORMAT_AAC;
        case AML_MP_AUDIO_CODEC_LATM:
            return DVR_AUDIO_FORMAT_LATM;
        case AML_MP_AUDIO_CODEC_PCM:
            return DVR_AUDIO_FORMAT_PCM;
        case AML_MP_AUDIO_CODEC_AC4:
            return DVR_AUDIO_FORMAT_AC4;
        case AML_MP_AUDIO_CODEC_HEAAC_V1:
        case AML_MP_AUDIO_CODEC_HEAAC_V2:
            return DVR_AUDIO_FORMAT_HEAAC;
//libdvr_release doesn't contain the following type definitions
#if !defined (ANDROID) || ANDROID_PLATFORM_SDK_VERSION >= 30
        case AML_MP_AUDIO_CODEC_MPEGH:
            return DVR_AUDIO_FORMAT_MPEGH;
#endif
        default:
            MLOGE("unknown audio codecId:%d", codecId);
            return DVR_AUDIO_FORMAT_MPEG;
    }
}
#endif

Aml_MP_CodecID convertToMpCodecId(am_tsplayer_audio_codec audioCodec)
{
    Aml_MP_CodecID codecId = AML_MP_CODEC_UNKNOWN;

    switch (audioCodec) {
    case AV_AUDIO_CODEC_MP2:
        codecId = AML_MP_AUDIO_CODEC_MP2;
        break;

    case AV_AUDIO_CODEC_MP3:
        codecId = AML_MP_AUDIO_CODEC_MP3;
        break;

    case AV_AUDIO_CODEC_AC3:
        codecId = AML_MP_AUDIO_CODEC_AC3;
        break;

    case AV_AUDIO_CODEC_EAC3:
        codecId = AML_MP_AUDIO_CODEC_EAC3;
        break;

    case AV_AUDIO_CODEC_DTS:
        codecId = AML_MP_AUDIO_CODEC_DTS;
        break;

    case AV_AUDIO_CODEC_AAC:
        codecId = AML_MP_AUDIO_CODEC_AAC;
        break;

    case AV_AUDIO_CODEC_LATM:
        codecId = AML_MP_AUDIO_CODEC_LATM;
        break;

    case AV_AUDIO_CODEC_PCM:
        codecId = AML_MP_AUDIO_CODEC_PCM;
        break;

    case AV_AUDIO_CODEC_AC4:
        codecId = AML_MP_AUDIO_CODEC_AC4;
        break;

    case AV_AUDIO_CODEC_FLAC:
        codecId = AML_MP_AUDIO_CODEC_FLAC;
        break;

    case AV_AUDIO_CODEC_VORBIS:
        codecId = AML_MP_AUDIO_CODEC_VORBIS;
        break;

    case AV_AUDIO_CODEC_OPUS:
        codecId = AML_MP_AUDIO_CODEC_OPUS;
        break;

    case AV_AUDIO_CODEC_PCM_ADPCM_IMA_WAV:
        codecId = AML_MP_AUDIO_CODEC_PCM_ADPCM_IMA_WAV;
        break;

#ifdef ANDROID
    case AV_AUDIO_CODEC_HE_AAC_V1:
        codecId = AML_MP_AUDIO_CODEC_HEAAC_V1;
        break;

    case AV_AUDIO_CODEC_HE_AAC_V2:
        codecId = AML_MP_AUDIO_CODEC_HEAAC_V2;
        break;
#endif

    case AV_AUDIO_CODEC_MPEGH:
        codecId = AML_MP_AUDIO_CODEC_MPEGH;
        break;

    default:
        MLOG("unknown audio codec:%d", audioCodec);
        break;
    }

    return codecId;
}

#ifdef HAVE_LIBDVR
void convertToMpDVRStream(Aml_MP_DVRStream* mpDvrStream, DVR_StreamPid_t* dvrStream)
{
    DVR_StreamType_t streamType = (DVR_StreamType_t)(dvrStream->type>>24 & 0xFF);
    int format = dvrStream->type & 0x7FFFFF;

    mpDvrStream->pid = dvrStream->pid;
    mpDvrStream->type = convertToMpStreamType(streamType);

    switch (streamType) {
    case DVR_STREAM_TYPE_VIDEO:
        mpDvrStream->codecId = convertToMpCodecId((DVR_VideoFormat_t)format);
        break;

    case DVR_STREAM_TYPE_AUDIO:
    case DVR_STREAM_TYPE_AD:
        mpDvrStream->codecId = convertToMpCodecId((DVR_AudioFormat_t)format);
        break;

    case DVR_STREAM_TYPE_SUBTITLE:
    case DVR_STREAM_TYPE_TELETEXT:
        mpDvrStream->codecId = (Aml_MP_CodecID)format;
        break;

    default:
        break;
    }
}

void convertToMpDVRStream(Aml_MP_DVRStream* mpDvrStream, DVR_StreamInfo_t* dvrStreamInfo)
{
    mpDvrStream->type = convertToMpStreamType(dvrStreamInfo->type);
    mpDvrStream->pid = dvrStreamInfo->pid;
    switch (mpDvrStream->type) {
    case AML_MP_STREAM_TYPE_VIDEO:
        mpDvrStream->codecId = convertToMpCodecId((DVR_VideoFormat_t)dvrStreamInfo->format);
        break;

    case AML_MP_STREAM_TYPE_AUDIO:
    case AML_MP_STREAM_TYPE_AD:
        mpDvrStream->codecId = convertToMpCodecId((DVR_AudioFormat_t)dvrStreamInfo->format);
        break;

    case AML_MP_STREAM_TYPE_SUBTITLE:
    case AML_MP_STREAM_TYPE_TELETEXT:
        //mpDvrStream->codecId = (Aml_MP_CodecID)(dvrStreamInfo->format);
        break;

    default:
        break;
    }
}

void convertToMpDVRSourceInfo(Aml_MP_DVRSourceInfo* dest, DVR_WrapperInfo_t* source)
{
    dest->time = source->time;
    dest->size = source->size;
    dest->pkts = source->pkts;
}
#endif

am_tsplayer_video_match_mode convertToTsPlayerVideoMatchMode(Aml_MP_VideoDisplayMode videoDisplayMode)
{
    switch (videoDisplayMode) {
    case AML_MP_VIDEO_DISPLAY_MODE_NORMAL:
        return AV_VIDEO_MATCH_MODE_NONE;
    case AML_MP_VIDEO_DISPLAY_MODE_FULLSCREEN:
        return AV_VIDEO_MATCH_MODE_FULLSCREEN;
    case AML_MP_VIDEO_DISPLAY_MODE_LETTER_BOX:
        return AV_VIDEO_MATCH_MODE_LETTER_BOX;
    case AML_MP_VIDEO_DISPLAY_MODE_PAN_SCAN:
        return AV_VIDEO_MATCH_MODE_PAN_SCAN;
    case AML_MP_VIDEO_DISPLAY_MODE_COMBINED:
        return AV_VIDEO_MATCH_MODE_COMBINED;
    case AML_MP_VIDEO_DISPLAY_MODE_WIDTHFULL:
        return AV_VIDEO_MATCH_MODE_WIDTHFULL;
    case AML_MP_VIDEO_DISPLAY_MODE_HEIGHTFULL:
        return AV_VIDEO_MATCH_MODE_HEIGHTFULL;
    case AML_MP_VIDEO_DISPLAY_MODE_4_3_LETTER_BOX:
        return AV_VIDEO_WIDEOPTION_4_3_LETTER_BOX;
    case AML_MP_VIDEO_DISPLAY_MODE_4_3_PAN_SCAN:
        return AV_VIDEO_WIDEOPTION_4_3_PAN_SCAN;
    case AML_MP_VIDEO_DISPLAY_MODE_4_3_COMBINED:
        return AV_VIDEO_WIDEOPTION_4_3_COMBINED;
    case AML_MP_VIDEO_DISPLAY_MODE_16_9_IGNORE:
        return AV_VIDEO_WIDEOPTION_16_9_IGNORE;
    case AML_MP_VIDEO_DISPLAY_MODE_16_9_LETTER_BOX:
        return AV_VIDEO_WIDEOPTION_16_9_LETTER_BOX;
    case AML_MP_VIDEO_DISPLAY_MODE_16_9_PAN_SCAN:
        return AV_VIDEO_WIDEOPTION_16_9_PAN_SCAN;
    case AML_MP_VIDEO_DISPLAY_MODE_16_9_COMBINED:
        return AV_VIDEO_WIDEOPTION_16_9_COMBINED;
    case AML_MP_VIDEO_DISPLAY_MODE_CUSTOM:
        return AV_VIDEO_WIDEOPTION_CUSTOM;
    default:
        return AV_VIDEO_MATCH_MODE_NONE;
    }
}

am_tsplayer_video_trick_mode convertToTsplayerVideoTrickMode(Aml_MP_VideoDecodeMode videoDecodeMode)
{
    switch (videoDecodeMode) {
    case AML_MP_VIDEO_DECODE_MODE_NONE:
        return AV_VIDEO_TRICK_MODE_NONE;
    case AML_MP_VIDEO_DECODE_MODE_IONLY:
    case AML_MP_VIDEO_DECODE_MODE_IONLY_SYNC:
        return AV_VIDEO_TRICK_MODE_IONLY;
    case AML_MP_VIDEO_DECODE_MODE_PAUSE:
        return AV_VIDEO_TRICK_MODE_PAUSE;
    case AML_MP_VIDEO_DECODE_MODE_PAUSE_NEXT:
        return AV_VIDEO_TRICK_MODE_PAUSE_NEXT;
    default:
        break;
    }

    return AV_VIDEO_TRICK_MODE_NONE;
}

am_tsplayer_audio_out_mode convertToTsPlayerAudioOutMode(Aml_MP_AudioOutputMode audioOutputMode)
{
    switch (audioOutputMode) {
    case AML_MP_AUDIO_OUTPUT_PCM:
        return AV_AUDIO_OUT_PCM;
    case AML_MP_AUDIO_OUTPUT_PASSTHROUGH:
        return AV_AUDIO_OUT_PASSTHROUGH;
    default:
        return AV_AUDIO_OUT_AUTO;
    }
}

long gcd(long a, long b) {
    return (b == 0) ? a : gcd(b, a % b);
}

void simplify(Aml_MP_Rational *ratio) {
    long common = gcd(ratio->numerator, ratio->denominator);
    if (common != 0) {
        ratio->numerator /= common;
        ratio->denominator /= common;
    }
}

void convertToMpVideoInfo(Aml_MP_VideoInfo* mpVideoInfo, am_tsplayer_video_info* tsVideoInfo, am_tsplayer_aspect_ratio_info* tsVideoRatio)
{
    if (mpVideoInfo == nullptr) {
        return;
    }

    if (tsVideoInfo != nullptr) {
        mpVideoInfo->width      = tsVideoInfo->width;
        mpVideoInfo->height     = tsVideoInfo->height;
        mpVideoInfo->frameRate  = tsVideoInfo->framerate;
        mpVideoInfo->bitrate    = tsVideoInfo->bitrate;
        mpVideoInfo->ratio64    = (Aml_MP_VideoRatio)tsVideoInfo->ratio64;
    }

    if ((tsVideoRatio != nullptr) && (tsVideoInfo != nullptr)) {
        if ((tsVideoRatio->sar_width > 0) && (tsVideoRatio->sar_height > 0)) {
            mpVideoInfo->dar.numerator = tsVideoInfo->width * tsVideoRatio->sar_width;
            mpVideoInfo->dar.denominator = tsVideoInfo->height * tsVideoRatio->sar_height;
            simplify(&mpVideoInfo->dar);
        } else {
            mpVideoInfo->dar.numerator = tsVideoRatio->dar_width;
            mpVideoInfo->dar.denominator = tsVideoRatio->dar_height;
        }
    }
}

am_tsplayer_audio_stereo_mode convertToTsPlayerAudioStereoMode(Aml_MP_AudioBalance audioBalance)
{
    switch (audioBalance) {
    case AML_MP_AUDIO_BALANCE_STEREO:
        return AV_AUDIO_STEREO;

    case AML_MP_AUDIO_BALANCE_LEFT:
        return AV_AUDIO_LEFT;

    case AML_MP_AUDIO_BALANCE_RIGHT:
        return AV_AUDIO_RIGHT;

    case AML_MP_AUDIO_BALANCE_SWAP:
        return AV_AUDIO_SWAP;

    case AML_MP_AUDIO_BALANCE_LRMIX:
        return AV_AUDIO_LRMIX;
    default:
        break;
    }

    return AV_AUDIO_STEREO;
}

void convertToMpPlayerEventAudioFormat(Aml_MP_PlayerEventAudioFormat* dest, am_tsplayer_audio_format_t* source)
{
    memset(dest, 0, sizeof(*dest));
    dest->audio_codec = AML_MP_CODEC_UNKNOWN;

    dest->sample_rate = source->sample_rate;
    dest->channels = source->channels;
#ifdef ANDROID //yocto mediahal hasn't define channel_mask.
    dest->channel_mask = source->channel_mask;
#endif
}

#ifdef ANDROID
void convertToMpPlayerEventAudioFormat(Aml_MP_PlayerEventAudioFormat* dest, am_tsplayer_audio_decinfo_t* source)
{
    memset(dest, 0, sizeof(*dest));

    dest->audio_codec = convertToMpCodecId((am_tsplayer_audio_codec)source->format);
    dest->sample_rate = source->sample_rate;
    dest->channels = source->channels;
    dest->channel_mask = source->channel_mask;
}
#endif


#ifdef HAVE_LIBDVR
static struct DemuxSourceConvertMap {
    DVB_DemuxSource_t dvbDemuxSource;
    Aml_MP_DemuxSource mpDemuxSource;
}sDemuxSourceConvertMap[] = {
    {DVB_DEMUX_SOURCE_TS0, AML_MP_DEMUX_SOURCE_TS0},
    {DVB_DEMUX_SOURCE_TS1, AML_MP_DEMUX_SOURCE_TS1},
    {DVB_DEMUX_SOURCE_TS2, AML_MP_DEMUX_SOURCE_TS2},
    {DVB_DEMUX_SOURCE_TS3, AML_MP_DEMUX_SOURCE_TS3},
    {DVB_DEMUX_SOURCE_TS4, AML_MP_DEMUX_SOURCE_TS4},
    {DVB_DEMUX_SOURCE_TS5, AML_MP_DEMUX_SOURCE_TS5},
    {DVB_DEMUX_SOURCE_TS6, AML_MP_DEMUX_SOURCE_TS6},
    {DVB_DEMUX_SOURCE_TS7, AML_MP_DEMUX_SOURCE_TS7},
    {DVB_DEMUX_SOURCE_DMA0, AML_MP_DEMUX_SOURCE_DMA0},
    {DVB_DEMUX_SOURCE_DMA1, AML_MP_DEMUX_SOURCE_DMA1},
    {DVB_DEMUX_SOURCE_DMA2, AML_MP_DEMUX_SOURCE_DMA2},
    {DVB_DEMUX_SOURCE_DMA3, AML_MP_DEMUX_SOURCE_DMA3},
    {DVB_DEMUX_SOURCE_DMA4, AML_MP_DEMUX_SOURCE_DMA4},
    {DVB_DEMUX_SOURCE_DMA5, AML_MP_DEMUX_SOURCE_DMA5},
    {DVB_DEMUX_SOURCE_DMA6, AML_MP_DEMUX_SOURCE_DMA6},
    {DVB_DEMUX_SOURCE_DMA7, AML_MP_DEMUX_SOURCE_DMA7},
    {DVB_DEMUX_SECSOURCE_DMA0, AML_MP_DEMUX_SECSOURCE_DMA0},
    {DVB_DEMUX_SECSOURCE_DMA1, AML_MP_DEMUX_SECSOURCE_DMA1},
    {DVB_DEMUX_SECSOURCE_DMA2, AML_MP_DEMUX_SECSOURCE_DMA2},
    {DVB_DEMUX_SECSOURCE_DMA3, AML_MP_DEMUX_SECSOURCE_DMA3},
    {DVB_DEMUX_SECSOURCE_DMA4, AML_MP_DEMUX_SECSOURCE_DMA4},
    {DVB_DEMUX_SECSOURCE_DMA5, AML_MP_DEMUX_SECSOURCE_DMA5},
    {DVB_DEMUX_SECSOURCE_DMA6, AML_MP_DEMUX_SECSOURCE_DMA6},
    {DVB_DEMUX_SECSOURCE_DMA7, AML_MP_DEMUX_SECSOURCE_DMA7},
    {DVB_DEMUX_SOURCE_DMA0_1, AML_MP_DEMUX_SOURCE_DMA0_1},
    {DVB_DEMUX_SOURCE_DMA1_1, AML_MP_DEMUX_SOURCE_DMA1_1},
    {DVB_DEMUX_SOURCE_DMA2_1, AML_MP_DEMUX_SOURCE_DMA2_1},
    {DVB_DEMUX_SOURCE_DMA3_1, AML_MP_DEMUX_SOURCE_DMA3_1},
    {DVB_DEMUX_SOURCE_DMA4_1, AML_MP_DEMUX_SOURCE_DMA4_1},
    {DVB_DEMUX_SOURCE_DMA5_1, AML_MP_DEMUX_SOURCE_DMA5_1},
    {DVB_DEMUX_SOURCE_DMA6_1, AML_MP_DEMUX_SOURCE_DMA6_1},
    {DVB_DEMUX_SOURCE_DMA7_1, AML_MP_DEMUX_SOURCE_DMA7_1},
    {DVB_DEMUX_SECSOURCE_DMA0_1,AML_MP_DEMUX_SECSOURCE_DMA0_1},
    {DVB_DEMUX_SECSOURCE_DMA1_1,AML_MP_DEMUX_SECSOURCE_DMA1_1},
    {DVB_DEMUX_SECSOURCE_DMA2_1,AML_MP_DEMUX_SECSOURCE_DMA2_1},
    {DVB_DEMUX_SECSOURCE_DMA3_1,AML_MP_DEMUX_SECSOURCE_DMA3_1},
    {DVB_DEMUX_SECSOURCE_DMA4_1,AML_MP_DEMUX_SECSOURCE_DMA4_1},
    {DVB_DEMUX_SECSOURCE_DMA5_1,AML_MP_DEMUX_SECSOURCE_DMA5_1},
    {DVB_DEMUX_SECSOURCE_DMA6_1,AML_MP_DEMUX_SECSOURCE_DMA6_1},
    {DVB_DEMUX_SECSOURCE_DMA7_1,AML_MP_DEMUX_SECSOURCE_DMA7_1},
    {DVB_DEMUX_SOURCE_TS0_1, AML_MP_DEMUX_SOURCE_TS0_1},
    {DVB_DEMUX_SOURCE_TS1_1, AML_MP_DEMUX_SOURCE_TS1_1},
    {DVB_DEMUX_SOURCE_TS2_1, AML_MP_DEMUX_SOURCE_TS2_1},
    {DVB_DEMUX_SOURCE_TS3_1, AML_MP_DEMUX_SOURCE_TS3_1},
    {DVB_DEMUX_SOURCE_TS4_1, AML_MP_DEMUX_SOURCE_TS4_1},
    {DVB_DEMUX_SOURCE_TS5_1, AML_MP_DEMUX_SOURCE_TS5_1},
    {DVB_DEMUX_SOURCE_TS6_1, AML_MP_DEMUX_SOURCE_TS6_1},
    {DVB_DEMUX_SOURCE_TS7_1, AML_MP_DEMUX_SOURCE_TS7_1},
};

DVB_DemuxSource_t convertToDVBDemuxSource(Aml_MP_DemuxSource source)
{
    for (size_t i = 0; i < sizeof(sDemuxSourceConvertMap)/sizeof(sDemuxSourceConvertMap[0]); ++i) {
        if (source == sDemuxSourceConvertMap[i].mpDemuxSource) {
            return sDemuxSourceConvertMap[i].dvbDemuxSource;
        }
    }

    return DVB_DEMUX_SOURCE_TS0;
}

Aml_MP_DemuxSource convertToMpDemuxSource(DVB_DemuxSource_t source)
{
    for (size_t i = 0; i < sizeof(sDemuxSourceConvertMap)/sizeof(sDemuxSourceConvertMap[0]); ++i) {
        if (source == sDemuxSourceConvertMap[i].dvbDemuxSource) {
            return sDemuxSourceConvertMap[i].mpDemuxSource;
        }
    }

    return AML_MP_DEMUX_SOURCE_TS0;
}
#endif

am_tsplayer_stream_type convertToTsplayerStreamType(Aml_MP_StreamType streamType) {
    switch (streamType) {
        case AML_MP_STREAM_TYPE_VIDEO:
            return TS_STREAM_VIDEO;
        case AML_MP_STREAM_TYPE_AUDIO:
            return TS_STREAM_AUDIO;
        case AML_MP_STREAM_TYPE_AD:
            return TS_STREAM_AD;
        case AML_MP_STREAM_TYPE_SUBTITLE:
            return TS_STREAM_SUB;
        default:
            break;
    }

    return (am_tsplayer_stream_type)-1;
}

am_tsplayer_media_time_type convertToTsplayerMediaTimeType(Aml_MP_StreamType streamType) {
    switch (streamType) {
        case AML_MP_STREAM_TYPE_VIDEO:
            return TS_MEDIA_TIME_VIDEO;
        case AML_MP_STREAM_TYPE_AUDIO:
        case AML_MP_STREAM_TYPE_AD:
            return TS_MEDIA_TIME_AUDIO;
        case AML_MP_STREAM_TYPE_PCR:
            return TS_MEDIA_TIME_PCR;
        case AML_MP_STREAM_TYPE_STC:
            return TS_MEDIA_TIME_STC;
        default:
            break;
    }

    return (am_tsplayer_media_time_type)-1;
}

Aml_MP_StreamType convertToAmlMPStreamType(am_tsplayer_stream_type streamType) {
    switch (streamType) {
        case TS_STREAM_VIDEO:
            return AML_MP_STREAM_TYPE_VIDEO;
        case TS_STREAM_AUDIO:
            return AML_MP_STREAM_TYPE_AUDIO;
        case TS_STREAM_AD:
            return AML_MP_STREAM_TYPE_AD;
        case TS_STREAM_SUB:
            return AML_MP_STREAM_TYPE_SUBTITLE;
    }

    return (AML_MP_STREAM_TYPE_UNKNOWN);
}

#define CODEC_RECOVERY_NONE     0
#define CODEC_RECOVERY_DROP     1
#define CODEC_RECOVERY_DEFAULT  0x1FFF
int convertToCodecRecoveryMode(Aml_MP_VideoErrorRecoveryMode errorRecoveryMode) {
    switch (errorRecoveryMode) {
        case AML_MP_VIDEO_ERROR_RECOVERY_DROP:
            return CODEC_RECOVERY_DROP;
        case AML_MP_VIDEO_ERROR_RECOVERY_NONE:
            return CODEC_RECOVERY_NONE;
        default:
            return CODEC_RECOVERY_DEFAULT;
    }
}

Aml_MP_VideoErrorRecoveryMode convertToAmlMPErrorRecoveryMode(int codecRecoveryMode) {
    switch (codecRecoveryMode) {
        case CODEC_RECOVERY_NONE:
            return AML_MP_VIDEO_ERROR_RECOVERY_NONE;
        case CODEC_RECOVERY_DROP:
            return AML_MP_VIDEO_ERROR_RECOVERY_DROP;
        default:
            return AML_MP_VIDEO_ERROR_RECOVERY_DEFAULT;
    }
}

am_tsplayer_input_buffer_type inputStreamTypeConvert(Aml_MP_InputStreamType streamType) {
    switch (streamType) {
    case AML_MP_INPUT_STREAM_NORMAL:
        return TS_INPUT_BUFFER_TYPE_NORMAL;

    case AML_MP_INPUT_STREAM_ENCRYPTED:
        return TS_INPUT_BUFFER_TYPE_TVP;

    case AML_MP_INPUT_STREAM_SECURE_MEMORY:
        return TS_INPUT_BUFFER_TYPE_SECURE;
    }

    return TS_INPUT_BUFFER_TYPE_NORMAL;
}

#ifdef HAVE_SUBTITLE
AmlTeletextCtrlParam convertToTeletextCtrlParam(AML_MP_TeletextCtrlParam* teletextCtrlParam) {
    AmlTeletextCtrlParam params;
    memset(&params, 0, sizeof(params));
    params.magazine = teletextCtrlParam->magazine;
    params.page = teletextCtrlParam->page;
    params.event = convertToTeletextEvent(teletextCtrlParam->event);
    params.regionid = convertToRegionId(teletextCtrlParam->iso639_lang);

    return params;
}

AmlTeletextEvent convertToTeletextEvent(Aml_MP_TeletextEvent teletextEvent) {
    switch (teletextEvent) {
        case AML_MP_TT_EVENT_QUICK_NAVIGATE_RED:
            return TT_EVENT_QUICK_NAVIGATE_RED;
        case AML_MP_TT_EVENT_QUICK_NAVIGATE_GREEN:
            return TT_EVENT_QUICK_NAVIGATE_GREEN;
        case AML_MP_TT_EVENT_QUICK_NAVIGATE_YELLOW:
            return TT_EVENT_QUICK_NAVIGATE_YELLOW;
        case AML_MP_TT_EVENT_QUICK_NAVIGATE_BLUE:
            return TT_EVENT_QUICK_NAVIGATE_BLUE;
        case AML_MP_TT_EVENT_0:
            return TT_EVENT_0;
        case AML_MP_TT_EVENT_1:
            return TT_EVENT_1;
        case AML_MP_TT_EVENT_2:
            return TT_EVENT_2;
        case AML_MP_TT_EVENT_3:
            return TT_EVENT_3;
        case AML_MP_TT_EVENT_4:
            return TT_EVENT_4;
        case AML_MP_TT_EVENT_5:
            return TT_EVENT_5;
        case AML_MP_TT_EVENT_6:
            return TT_EVENT_6;
        case AML_MP_TT_EVENT_7:
            return TT_EVENT_7;
        case AML_MP_TT_EVENT_8:
            return TT_EVENT_8;
        case AML_MP_TT_EVENT_9:
            return TT_EVENT_9;
        case AML_MP_TT_EVENT_INDEXPAGE:
            return TT_EVENT_INDEXPAGE;
        case AML_MP_TT_EVENT_NEXTPAGE:
            return TT_EVENT_NEXTPAGE;
        case AML_MP_TT_EVENT_PREVIOUSPAGE:
            return TT_EVENT_PREVIOUSPAGE;
        case AML_MP_TT_EVENT_NEXTSUBPAGE:
            return TT_EVENT_NEXTSUBPAGE;
        case AML_MP_TT_EVENT_PREVIOUSSUBPAGE:
            return TT_EVENT_PREVIOUSSUBPAGE;
        case AML_MP_TT_EVENT_BACKPAGE:
            return TT_EVENT_BACKPAGE;
        case AML_MP_TT_EVENT_FORWARDPAGE:
            return TT_EVENT_FORWARDPAGE;
        case AML_MP_TT_EVENT_HOLD:
            return TT_EVENT_HOLD;
        case AML_MP_TT_EVENT_REVEAL:
            return TT_EVENT_REVEAL;
        case AML_MP_TT_EVENT_CLEAR:
            return TT_EVENT_CLEAR;
        case AML_MP_TT_EVENT_CLOCK:
            return TT_EVENT_CLOCK;
        case AML_MP_TT_EVENT_MIX_VIDEO:
            return TT_EVENT_MIX_VIDEO;
        case AML_MP_TT_EVENT_DOUBLE_HEIGHT:
            return TT_EVENT_DOUBLE_HEIGHT;
        case AML_MP_TT_EVENT_DOUBLE_SCROLL_UP:
            return TT_EVENT_DOUBLE_SCROLL_UP;
        case AML_MP_TT_EVENT_DOUBLE_SCROLL_DOWN:
            return TT_EVENT_DOUBLE_SCROLL_DOWN;
        case AML_MP_TT_EVENT_TIMER:
            return TT_EVENT_TIMER;
        case AML_MP_TT_EVENT_GO_TO_PAGE:
            return TT_EVENT_GO_TO_PAGE;
        case AML_MP_TT_EVENT_GO_TO_SUBTITLE:
            return TT_EVENT_GO_TO_SUBTITLE;
        default:
            return TT_EVENT_INVALID;
    }
}

int convertToRegionId(char iso639lang[]) {
    //Guessing table for missing "default region triplet"
    static const int pi_default_triplet[] = {
        0, 0,           // slo cze
        8,              // pol
        24,24,24,24,    //ssc scr slv rum
        32,32,32,32,32, //est lit rus bul ukr
        48,48,          //gre ell
        64,             //ara
        88,             //heb
        16 };           //default
     static const char *const ppsz_default_triplet[] = {
         "slo", "cze",
         "pol",
         "ssc", "scr", "slv", "rum",
         "est", "lit", "rus", "bul", "ukr",
         "gre", "ell",
         "ara",
         "heb",
         NULL};

    int regionid = 16;  //default value

    if (iso639lang == NULL || iso639lang[0] == '\0')  //iso639lang is NULL
        return regionid;

    for (int i = 0; ppsz_default_triplet[i] != NULL; i++)
    {
        if (!strncmp(iso639lang, ppsz_default_triplet[i], 3))
        {
            regionid = pi_default_triplet[i];
            MLOGI("overwriting default zvbi region: %d", pi_default_triplet[i] );
            break;
        }
    }

    return regionid;
}

AML_MP_SubtitleDataType convertToMpSubtitleDataType(AmlSubDataType subDataType) {
    switch (subDataType) {
        case SUB_DATA_TYPE_STRING:
            return AML_MP_SUB_DATA_TYPE_STRING;
        case SUB_DATA_TYPE_CC_JSON:
            return AML_MP_SUB_DATA_TYPE_CC_JSON;
        case SUB_DATA_TYPE_BITMAP:
            return AML_MP_SUB_DATA_TYPE_BITMAP;
        case SUB_DATA_TYPE_POSITION_BITMAP:
            return AML_MP_SUB_DATA_TYPE_POSITION_BITMAP;
        default:
            return AML_MP_SUB_DATA_TYPE_UNKNOWN;
    }
}

#endif

bool isSupportMultiHwDemux()
{
    return access("/sys/class/stb/demux0_source",F_OK) != 0;
}

NativeWindowHelper::NativeWindowHelper()
{
}

NativeWindowHelper::~NativeWindowHelper()
{
    clearTunnelId();
}

void NativeWindowHelper::clearTunnelId()
{
#ifdef ANDROID
#ifndef __ANDROID_RECOVERY__
    if (mMesonVtFd >= 0) {
        if (mTunnelId >= 0) {
            MLOGI("%s: free Id:%d", __FUNCTION__, mTunnelId);
            meson_vt_free_id(mMesonVtFd, mTunnelId);
        }
        meson_vt_close(mMesonVtFd);
        mTunnelId = -1;
        mMesonVtFd = -1;
    }
#endif
#endif
}

int NativeWindowHelper::setSidebandTunnelMode(ANativeWindow* nativeWindow)
{
    int ret = -1;

    if (nativeWindow == nullptr) {
        return ret;
    }
#ifdef ANDROID
#ifndef __ANDROID_RECOVERY__
    native_handle_t* sidebandHandle = am_gralloc_create_sideband_handle(AM_TV_SIDEBAND, AM_VIDEO_DEFAULT);
    mSidebandHandle = android::NativeHandle::create(sidebandHandle, true);

    MLOG("setAnativeWindow:%p, sidebandHandle:%p", nativeWindow, sidebandHandle);

    ret = native_window_set_sideband_stream(nativeWindow, sidebandHandle);
#endif
#endif
    if (ret < 0) {
        MLOGE("set sideband stream failed!");
    }

    return ret;
}

int NativeWindowHelper::setSidebandNonTunnelMode(ANativeWindow* nativeWindow, int* videoTunnelId)
{
    int ret = -1;

    if (nativeWindow == nullptr) {
        MLOGE("setANativeWindow failed, nativeWindow is nullptr");
        return ret;
    }

    if (videoTunnelId && *videoTunnelId != -1) {
        MLOGW("setANativeWindow mVideoTunnelId:%d", *videoTunnelId);
    }

#ifdef ANDROID
#ifndef __ANDROID_RECOVERY__
    if (mNativewindow != nullptr && mNativewindow != nativeWindow) {
        MLOGI("window changed, clear tunnel id!");
        clearTunnelId();
    }
    mNativewindow = nativeWindow;

    if (mMesonVtFd < 0) {
        int type = AM_FIXED_TUNNEL;
        mMesonVtFd = meson_vt_open();
        if (mMesonVtFd < 0) {
            MLOGE("meson_vt_open failed!");
            return ret;
        }

        int tunnelId = -1;
        if (meson_vt_alloc_id(mMesonVtFd, &tunnelId) < 0) {
            MLOGE("meson_vt_alloc_id failed!");
            meson_vt_close(mMesonVtFd);
            mMesonVtFd = -1;
            return ret;
        }
        MLOGI("setAnativeWindow: allocId: %d", tunnelId);
        mTunnelId = tunnelId;
        native_handle_t *sidebandHandle = am_gralloc_create_sideband_handle(type, mTunnelId);
        mSidebandHandle = android::NativeHandle::create(sidebandHandle, true);
    }

    if (videoTunnelId) {
        *videoTunnelId = mTunnelId;
    }

    MLOGI("setAnativeWindow:%p, sidebandHandle:%p, videoTunnelId: %d", nativeWindow, (native_handle_t*)mSidebandHandle->handle(), mTunnelId);
    ret = native_window_set_sideband_stream(nativeWindow, (native_handle_t*)mSidebandHandle->handle());
    if (ret < 0) {
        MLOGE("set sideband stream failed!");
        return ret;
    }
#endif
#endif
    return ret;
}

const char codecMap[][20][30] = {
    //Video codec
    {
        "Not defined codec",
        "video/mpeg2",          //AML_MP_VIDEO_CODEC_MPEG12
        "video/mp4v-es",        //AML_MP_VIDEO_CODEC_MPEG4
        "video/avc",            //AML_MP_VIDEO_CODEC_H264
        "video/vc1",            //AML_MP_VIDEO_CODEC_VC1
        "video/avs",            //AML_MP_VIDEO_CODEC_AVS
        "video/hevc",           //AML_MP_VIDEO_CODEC_HEVC
        "video/x-vnd.on2.vp9",  //AML_MP_VIDEO_CODEC_VP9
        "video/avs2",           //AML_MP_VIDEO_CODEC_AVS2
        "video/x-motion-jpeg",  //AML_MP_VIDEO_CODEC_MJPEG
        "video/av01",           //AML_MP_VIDEO_CODEC_AV1
        "video/dves-avc",       //AML_MP_VIDEO_CODEC_DVES_AVC
        "video/dves-hevc",      //AML_MP_VIDEO_CODEC_DVES_HEVC
        "video/vvc",            //AML_MP_VIDEO_CODEC_VVC
        "video/avs3",           //AML_MP_VIDEO_CODEC_AVS3
    },
    //Audio codec
    {
        "Not defined codec",
        "audio/mpeg-L2",    //AML_MP_AUDIO_CODEC_MP2
        "audio/mpeg",       //AML_MP_AUDIO_CODEC_MP3
        "audio/ac3",        //AML_MP_AUDIO_CODEC_AC3
        "audio/eac3",       //AML_MP_AUDIO_CODEC_EAC3
        "audio/dtshd",      //AML_MP_AUDIO_CODEC_DTS
        "audio/mp4a-latm",  //AML_MP_AUDIO_CODEC_AAC
        "audio/aac-latm",   //AML_MP_AUDIO_CODEC_LATM
        "audio/raw",        //AML_MP_AUDIO_CODEC_PCM
        "audio/ac4",        //AML_MP_AUDIO_CODEC_AC4
        "audio/flac",       //AML_MP_AUDIO_CODEC_FLAC
        "audio/vorbis",     //AML_MP_AUDIO_CODEC_VORBIS
        "audio/opus",       //AML_MP_AUDIO_CODEC_OPUS
        "audio/adpcm",      //AML_MP_AUDIO_CODEC_PCM_ADPCM_IMA_WAV
        "audio/heaac_v1",   //AML_MP_AUDIO_CODEC_HEAAC_V1
        "audio/heaac_v2",   //AML_MP_AUDIO_CODEC_HEAAC_V2
        "audio/mpegh",      //AML_MP_AUDIO_CODEC_MPEGH
    },
};

const char* convertToMIMEString(Aml_MP_CodecID codecId) {
    if ((codecId >= AML_MP_VIDEO_CODEC_BASE && codecId < AML_MP_VIDEO_CODEC_MAX) ||
        (codecId >= AML_MP_AUDIO_CODEC_BASE && codecId < AML_MP_AUDIO_CODEC_MAX)) {
        return codecMap[codecId / 1000][codecId % 1000];
    }
    return "Not defined codec";
}

Aml_MP_CodecID convertToMpCodecId(std::string mimeStr) {
    if (mimeStr.find("video") != std::string::npos) {
        for (int i = AML_MP_VIDEO_CODEC_BASE; i < AML_MP_VIDEO_CODEC_MAX; i++) {
            if (mimeStr == codecMap[i / 1000][i % 1000]) {
                return (Aml_MP_CodecID)i;
            }
        }
    } else if (mimeStr.find("audio") != std::string::npos) {
        for (int i = AML_MP_AUDIO_CODEC_BASE; i < AML_MP_AUDIO_CODEC_MAX; i++) {
            if (mimeStr == codecMap[i / 1000][i % 1000]) {
                return (Aml_MP_CodecID)i;
            }
        }
    }

    return AML_MP_CODEC_UNKNOWN;
}

void split(const std::string& s, std::vector<std::string>& tokens, const std::string& delimiters) {
    std::string::size_type lastPos = s.find_first_not_of(delimiters, 0);
    std::string::size_type pos = s.find_first_of(delimiters, lastPos);
    while (std::string::npos != pos || std::string::npos != lastPos) {
        tokens.push_back(s.substr(lastPos, pos - lastPos));
        lastPos = s.find_first_not_of(delimiters, pos);
        pos = s.find_first_of(delimiters, lastPos);
    }
}

std::string trim(std::string& s, const std::string& chars) {
    s.erase(0, s.find_first_not_of(chars.c_str()));
    s.erase(s.find_last_not_of(chars.c_str()) + 1);
    return s;
}

int setTSNSourceToLocal() {
    if (!isSupportMultiHwDemux())
        return 0;

    int ret = 0;
    ret = amsysfs_set_sysfs_str("/sys/class/stb/tsn_source", "local");
    if (ret) {
        MLOGI("Error set tsn source, ret 0x%x\n", ret);
    }
    return ret;
}

int setTSNSourceToDemod() {
    if (!isSupportMultiHwDemux())
        return 0;

    int ret = 0;
    ret = amsysfs_set_sysfs_str("/sys/class/stb/tsn_source", "demod");
    if (ret) {
        MLOGI("Error set tsn source, ret 0x%x\n", ret);
    }
    return ret;
}

void hexdump(const uint8_t* data, size_t size, std::string& result)
{
    size_t offset = 0;
    while (offset < size) {
        std::string line;
        char tmp[32];

        snprintf(tmp, sizeof(tmp), "%08lx: ", (unsigned long)offset);
        line.append(tmp);

        for (size_t i = 0; i < 16; ++i) {
            if (i == 8) {
                line.append(" ");
            }

            if (offset + i >= size) {
                line.append("   ");
            } else {
                snprintf(tmp, sizeof(tmp), "%02x ", data[offset+i]);
                line.append(tmp);
            }
        }

        line.append(" ");
        for (size_t i = 0; i < 16; ++i) {
            if (offset +i >= size) {
                break;
            }

            if (isprint(data[offset+i])) {
                line.append(1, (char)data[offset + i]);
            } else {
                line.append(".");
            }
        }

        result.append(line);
        result.append("\n");

        offset += 16;
    }
}

std::string getCommitInfo()
{
    std::stringstream ss;
    ss << "\n----------------aml_mp_sdk VERSION INFO----------------\n";
    ss << "ARCH:" <<
#if defined(__aarch64__)
          "arm64"
#else
          "arm"
#endif
    << "\n";

#ifdef HAVE_VERSION_INFO
    ss << "branch name:" << MODULE_BRANCH_NAME << "\n";
    ss << "git version:" << MODULE_GIT_VERSION << "\n";
    ss << "change-id:  " << MODULE_CHANGE_ID << "\n";
    ss << "commit date:" << MODULE_COMMIT_DATE << "\n";
    ss << "build-time: " << MODULE_BUILD_TIME << "\n";
    ss << "build name: " << MODULE_BUILD_NAME << "\n";
    ss << "dirty-file-num:" << MODULE_GIT_UNCOMMIT_FILE_NUM << "\n";
#endif

    ss << "-------------------------------------------------------";

    return ss.str();
}

}