/*
 * 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 "AmlDVRPlayer"
#include "AmlDVRPlayer.h"
#include <Aml_MP/Dvr.h>
#include <Aml_MP/Aml_MP.h>
#include <utils/AmlMpHandle.h>
#include <utils/AmlMpUtils.h>
#include <utils/AmlMpLog.h>
#ifdef ANDROID
#ifndef __ANDROID_VNDK__
#include <gui/Surface.h>
#endif

#include <amlogic/am_gralloc_ext.h>
#endif

namespace aml_mp {

#ifdef HAVE_LIBDVR
static Aml_MP_DVRPlayerState convertToMpDVRPlayerState(DVR_PlaybackPlayState_t state);
static Aml_MP_DVRPlayerSegmentFlag convertToMpDVRSegmentFlag(DVR_PlaybackSegmentFlag_t flag);
static void convertToMpDVRPlayerStatus(Aml_MP_DVRPlayerStatus* mpStatus, DVR_WrapperPlaybackStatus_t* dvrStatus);
#endif

///////////////////////////////////////////////////////////////////////////////
AmlDVRPlayer::AmlDVRPlayer(Aml_MP_DVRPlayerBasicParams* basicParams, Aml_MP_DVRPlayerDecryptParams* decryptParams)
{
    snprintf(mName, sizeof(mName), "%s", LOG_TAG);
    MLOG();

#ifdef HAVE_LIBDVR
    memset(&mPlaybackOpenParams, 0, sizeof(DVR_WrapperPlaybackOpenParams_t));
#endif

    memset(&mVideoParams, 0, sizeof(mVideoParams));
    mVideoParams.pid = AML_MP_INVALID_PID;
    mVideoParams.videoCodec = AML_MP_CODEC_UNKNOWN;

    memset(&mAudioParams, 0, sizeof(mAudioParams));
    mAudioParams.pid = AML_MP_INVALID_PID;
    mAudioParams.audioCodec = AML_MP_CODEC_UNKNOWN;

    memset(&mADParams, 0, sizeof(mADParams));
    mADParams.pid = AML_MP_INVALID_PID;
    mADParams.audioCodec = AML_MP_CODEC_UNKNOWN;

    memset(&mSubtitleParams, 0, sizeof(mSubtitleParams));
    mSubtitleParams.pid = AML_MP_INVALID_PID;
    mSubtitleParams.subtitleCodec = AML_MP_CODEC_UNKNOWN;

    setBasicParams(basicParams);
    mRecStartTime = 0;
    mLimit = 0;
    mAudioPresentationId = -1;
    mIsEncryptStream = basicParams->drmMode != AML_MP_INPUT_STREAM_NORMAL;
    mInputStreamType = basicParams->drmMode;
    mStartOffset = -1;

    if (decryptParams != nullptr) {
        setDecryptParams(decryptParams);
    }

    createMpPlayerIfNeeded();
}

AmlDVRPlayer::~AmlDVRPlayer()
{
    MLOG();
}

int AmlDVRPlayer::registerEventCallback(Aml_MP_PlayerEventCallback cb, void* userData)
{
    AML_MP_TRACE(10);

#ifdef HAVE_LIBDVR
    mEventCb = cb;
    mEventUserData = userData;
    if (mMpPlayerHandle) {
        Aml_MP_Player_RegisterEventCallBack(mMpPlayerHandle, mEventCb, mEventUserData);
    }
#else
    AML_MP_UNUSED(cb);
    AML_MP_UNUSED(userData);
#endif

    return 0;
}

int AmlDVRPlayer::setStreams(Aml_MP_DVRStreamArray* streams)
{
    MLOG();
    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    setStreamsCommon(streams);
    if (mDVRPlayerHandle) {
        if (mAudioPresentationId > -1) {
            ret = dvr_wrapper_set_ac4_preselection_id(mDVRPlayerHandle, mAudioPresentationId);
            if (ret < 0) {
                MLOGE("set ac4 preselection id failed!");
            }
        }
        ret = dvr_wrapper_update_playback(mDVRPlayerHandle, &mPlayPids);
        if (ret < 0) {
            MLOGE("update playback failed!");
        }
    }
#else
    AML_MP_UNUSED(streams);
#endif

    return ret;
}

int AmlDVRPlayer::onlySetStreams(Aml_MP_DVRStreamArray* streams)
{
    MLOG();
    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    setStreamsCommon(streams);
    if (mDVRPlayerHandle) {
        if (mAudioPresentationId > -1) {
            ret = dvr_wrapper_set_ac4_preselection_id(mDVRPlayerHandle, mAudioPresentationId);
            if (ret < 0) {
                MLOGE("set ac4 preselection id failed!");
            }
        }
        ret = dvr_wrapper_only_update_playback(mDVRPlayerHandle, &mPlayPids);
        if (ret < 0) {
            MLOGE("update playback failed!");
        }
    }
#else
    AML_MP_UNUSED(streams);
#endif

    return ret;
}

int AmlDVRPlayer::start(bool initialPaused)
{
    MLOG();
    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    DVR_PlaybackFlag_t play_flag;
    ret = createMpPlayerIfNeeded();
    if (ret != 0) {
        return -1;
    }
    ret = Aml_MP_Player_RegisterEventCallBack(mMpPlayerHandle, mEventCb, mEventUserData);

#ifdef ANDROID
    ret = Aml_MP_Player_SetANativeWindow(mMpPlayerHandle, mNativeWindow.get());
#endif

    ret = Aml_MP_Player_Start(mMpPlayerHandle);

    Playback_DeviceHandle_t mTsPlayerHandle;
    ret = Aml_MP_Player_GetParameter(mMpPlayerHandle, AML_MP_PLAYER_PARAMETER_TSPLAYER_HANDLE, (void *)&mTsPlayerHandle);
    MLOGI(" MpPlayer get ts player handle %s, result(%d)", (ret)? "FAIL" : "OK", ret);
    if (ret != 0) {
        goto err;
    }

    mPlaybackOpenParams.playback_handle = (Playback_DeviceHandle_t)mTsPlayerHandle;
    mPlaybackOpenParams.event_fn = [](DVR_PlaybackEvent_t event, void* params, void* userData) {
        AmlDVRPlayer* player = static_cast<AmlDVRPlayer*>(userData);
        return player->eventHandlerLibDVR(event, params);
    };
    mPlaybackOpenParams.event_userdata = this;

    //apply parameters
    mPlaybackOpenParams.vendor = (DVR_PlaybackVendor_t)mVendorID;
    ret = dvr_wrapper_open_playback(&mDVRPlayerHandle, &mPlaybackOpenParams);
    if (ret < 0) {
        MLOGE("open playback failed!");
        goto err;
    }

    if (mIsEncryptStream) {
        dvr_wrapper_set_playback_secure_buffer(mDVRPlayerHandle, mSecureBuffer, mSecureBufferSize);
    }

    if (mRecStartTime > 0) {
        dvr_wrapper_setlimit_playback(mDVRPlayerHandle, mRecStartTime, mLimit);
    }
    play_flag = initialPaused ? DVR_PLAYBACK_STARTED_PAUSEDLIVE : (DVR_PlaybackFlag_t)0;

    play_flag = (DVR_PlaybackFlag_t)(play_flag | mPlayFlags);

    ret = dvr_wrapper_start_playback(mDVRPlayerHandle, play_flag, &mPlayPids);
    if (ret != DVR_SUCCESS) {
        MLOGE("start playback failed!");
        goto err;
    } else if (mStartOffset >= 0) {
        seek(mStartOffset);
        mStartOffset = -1;
    }

    return 0;

#else
    AML_MP_UNUSED(initialPaused);
    return AML_MP_ERROR;
#endif

err:
    stopInternal();

    return ret;
}


int AmlDVRPlayer::stop()
{
    MLOG();

    return stopInternal();
}

int AmlDVRPlayer::stopInternal()
{
    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    if (mDVRPlayerHandle) {
        ret = dvr_wrapper_stop_playback(mDVRPlayerHandle);
        if (ret < 0) {
            MLOGE("dvr player stop playback failed!");
        }

        DVR_WrapperPlayback_t tmp = mDVRPlayerHandle;
        mDVRPlayerHandle = 0;
        ret = dvr_wrapper_close_playback(tmp);
        if (ret < 0) {
            MLOGE("dvr player close playback failed!");
        }
    }

    if (mMpPlayerHandle != AML_MP_INVALID_HANDLE) {
        ret = Aml_MP_Player_Stop(mMpPlayerHandle);
        if (ret < 0) {
            MLOGE("mp player stop playback failed!");
        }

        AML_MP_PLAYER tmpHandle = mMpPlayerHandle;
        mMpPlayerHandle = AML_MP_INVALID_HANDLE;
        ret = Aml_MP_Player_Destroy(tmpHandle);
        if (ret < 0) {
            MLOGE("mp player close playback failed!");
        }
    }

    mStartOffset = -1;
#endif

    return ret;
}

int AmlDVRPlayer::pause()
{
    MLOG();

    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    ret = dvr_wrapper_pause_playback(mDVRPlayerHandle);
    if (ret < 0) {
        MLOGE("ts player pause playback failed!");
    }

    ret = Aml_MP_Player_Pause(mMpPlayerHandle);
    if (ret < 0) {
        MLOGE("mp player pause playback failed!");
    }
#endif

    return ret;
}

int AmlDVRPlayer::resume()
{
    MLOG();

    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    ret = dvr_wrapper_resume_playback(mDVRPlayerHandle);
    if (ret < 0) {
        MLOGE("ts player resume playback failed!");
    }

    ret = Aml_MP_Player_Resume(mMpPlayerHandle);
    if (ret < 0) {
        MLOGE("mp player resume playback failed!");
    }
#endif

    return ret;
}

int AmlDVRPlayer::setLimit(uint32_t time, uint32_t limit)
{
    MLOG("rec start time:%u limit:%u", time, limit);

#ifdef HAVE_LIBDVR
    mRecStartTime = time;
    mLimit = limit;
    if (mRecStartTime > 0) {
        dvr_wrapper_setlimit_playback(mDVRPlayerHandle, mRecStartTime, mLimit);
    }
    return 0;
#else
    AML_MP_UNUSED(time);
    AML_MP_UNUSED(limit);
    return AML_MP_ERROR;
#endif
}

int AmlDVRPlayer::seek(int timeOffset)
{
    MLOG("timeOffset:%d", timeOffset);

    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    if (mDVRPlayerHandle) {
        ret = dvr_wrapper_seek_playback(mDVRPlayerHandle, timeOffset);
        if (ret < 0) {
            MLOGE("seek playback %d failed!", timeOffset);
        }
    } else {
        mStartOffset = timeOffset;
        MLOGE("AmlDVRPlayer not started, store offset %d.", mStartOffset);
    }
#else
    AML_MP_UNUSED(timeOffset);
#endif

    return ret;
}

int AmlDVRPlayer::setPlaybackRate(float rate)
{
    MLOG("rate:%f", rate);

#ifdef HAVE_LIBDVR
    int ret = dvr_wrapper_set_playback_speed(mDVRPlayerHandle, rate * 100);
    if (ret < 0) {
        MLOGE("set playback speed failed!");
    }
    return ret;
#else
    AML_MP_UNUSED(rate);
    return AML_MP_ERROR;
#endif
}

int AmlDVRPlayer::getStatus(Aml_MP_DVRPlayerStatus* status)
{
    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    DVR_WrapperPlaybackStatus_t dvrStatus;
    ret = dvr_wrapper_get_playback_status(mDVRPlayerHandle, &dvrStatus);
    if (ret < 0) {
        MLOGE("get playback status failed!");
        return ret;
    }

    //coverity[uninit_use_in_call]
    convertToMpDVRPlayerStatus(status, &dvrStatus);
#else
    AML_MP_UNUSED(status);
#endif

    return ret;
}

int AmlDVRPlayer::showVideo()
{
    MLOG();

    int ret = Aml_MP_Player_ShowVideo(mMpPlayerHandle);

    return ret;
}

int AmlDVRPlayer::hideVideo()
{
    MLOG();

    int ret = Aml_MP_Player_HideVideo(mMpPlayerHandle);

    return ret;
}

int AmlDVRPlayer::setVolume(float volume)
{
    MLOG("volume:%f", volume);

    int ret = Aml_MP_Player_SetVolume(mMpPlayerHandle, volume);

    return ret;
}

int AmlDVRPlayer::getVolume(float* volume)
{
    MLOG();

    int ret = Aml_MP_Player_GetVolume(mMpPlayerHandle, volume);

    return ret;
}

int AmlDVRPlayer::setParameter(Aml_MP_PlayerParameterKey key, void* parameter)
{
    RETURN_IF(-1, parameter == nullptr);

    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    switch (key) {
        case AML_MP_PLAYER_PARAMETER_VENDOR_ID:
            mVendorID = *(int*)parameter;
            break;
        case AML_MP_PLAYER_PARAMETER_AUDIO_PRESENTATION_ID:
        {
            mAudioPresentationId = *(int32_t*)parameter;
            break;
        }
        case AML_MP_PLAYER_PARAMETER_LIBDVR_FAKE_PID:
        {
            const int fake_pid = *(int*)parameter;
            dvr_wrapper_property_set("vendor.tv.dtv.fake_pid",std::to_string(fake_pid).c_str());
            break;
        }
        default:
            break;

    }
    ret = Aml_MP_Player_SetParameter(mMpPlayerHandle, key, parameter);
#else
    AML_MP_UNUSED(key);
    AML_MP_UNUSED(parameter);
#endif

    return ret;
}

int AmlDVRPlayer::getParameter(Aml_MP_PlayerParameterKey key, void* parameter)
{
    RETURN_IF(-1, parameter == nullptr);

    int ret = Aml_MP_Player_GetParameter(mMpPlayerHandle, key, parameter);
    return ret;
}

int AmlDVRPlayer::setANativeWindow(ANativeWindow* nativeWindow) {
    MLOG();

#ifdef ANDROID
    mNativeWindow = nativeWindow;
    MLOGI("PVR setAnativeWindow: %p, mNativewindow: %p", nativeWindow, mNativeWindow.get());
#endif

    int ret = Aml_MP_Player_SetANativeWindow(mMpPlayerHandle, nativeWindow);
    return ret;
}

int AmlDVRPlayer::setVideoWindow(int x, int y, int width, int height)
{
    MLOG("x:%d, y:%d, width:%d, height:%d", x, y, width, height);

    int ret = Aml_MP_Player_SetVideoWindow(mMpPlayerHandle, x, y, width, height);
    return ret;
}

int AmlDVRPlayer::setADVolume(float volume)
{
    MLOG("ad volume:%f", volume);

    int ret = Aml_MP_Player_SetADVolume(mMpPlayerHandle, volume);
    return ret;
}

int AmlDVRPlayer::getADVolume(float* volume)
{
    MLOG();

    if (volume == NULL) {
       return -1;
    }

    int ret = Aml_MP_Player_GetADVolume(mMpPlayerHandle, volume);
    return ret;
}

////////////////////////////////////////////////////////////////////////////////
int AmlDVRPlayer::setBasicParams(Aml_MP_DVRPlayerBasicParams* basicParams)
{
#ifdef HAVE_LIBDVR
    mPlaybackOpenParams.dmx_dev_id = basicParams->demuxId;
    memcpy(&(mPlaybackOpenParams.location), &(basicParams->location), DVR_MAX_LOCATION_SIZE);
    mPlaybackOpenParams.block_size = basicParams->blockSize;
    mPlaybackOpenParams.is_timeshift = basicParams->isTimeShift;
    mPlaybackOpenParams.is_notify_time = basicParams->isNotifyTime;
    mPlayFlags = (DVR_PlaybackFlag_t)basicParams->playFlags;
#else
    AML_MP_UNUSED(basicParams);
#endif

    return 0;
}

int AmlDVRPlayer::setDecryptParams(Aml_MP_DVRPlayerDecryptParams * decryptParams)
{
#ifdef HAVE_LIBDVR
    mPlaybackOpenParams.crypto_fn = (DVR_CryptoFunction_t)decryptParams->cryptoFn;
    mPlaybackOpenParams.crypto_data = decryptParams->cryptoData;

    mSecureBuffer = decryptParams->secureBuffer;
    mSecureBufferSize = decryptParams->secureBufferSize;

    MLOGI("mSecureBuffer:%p, mSecureBufferSize:%zu", mSecureBuffer, mSecureBufferSize);

    mPlaybackOpenParams.clearkey = decryptParams->clearKey;
    mPlaybackOpenParams.cleariv = decryptParams->clearIV;
    mPlaybackOpenParams.keylen = decryptParams->keyLength;
#else
    AML_MP_UNUSED(decryptParams);
#endif

    return 0;
}

int AmlDVRPlayer::createMpPlayerIfNeeded()
{
    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    if (mMpPlayerHandle != AML_MP_INVALID_HANDLE) {
        return 0;
    }

    Aml_MP_PlayerCreateParams mMpPlayerInitparam;
    memset(&mMpPlayerInitparam, 0, sizeof(mMpPlayerInitparam));
    mMpPlayerInitparam.channelId = AML_MP_CHANNEL_ID_AUTO;
    mMpPlayerInitparam.demuxId = (Aml_MP_DemuxId)mPlaybackOpenParams.dmx_dev_id;
    mMpPlayerInitparam.sourceType = AML_MP_INPUT_SOURCE_TS_MEMORY;
    mMpPlayerInitparam.drmMode = mInputStreamType;
    mMpPlayerInitparam.options = AML_MP_OPTION_DVR_PLAYBACK;
    MLOGI("drmMode: %d", mMpPlayerInitparam.drmMode);

#ifdef CONFIG_AMP_SERVER
    mMpPlayerInitparam.reserved[0] = 'n';
    mMpPlayerInitparam.reserved[1] = 'u';
    mMpPlayerInitparam.reserved[2] = 'r';
    mMpPlayerInitparam.reserved[3] = 'p';
#endif

    AML_MP_PLAYER playerHandle;
    ret = Aml_MP_Player_Create(&mMpPlayerInitparam, &playerHandle);
    if (ret != AML_MP_OK) {
        MLOGE("Create MpPlayer fail");
    } else {
       mMpPlayerHandle = playerHandle;
    }
#endif

    return ret;
}

#ifdef HAVE_LIBDVR
DVR_Result_t AmlDVRPlayer::eventHandlerLibDVR(DVR_PlaybackEvent_t event, void* params)
{
    DVR_Result_t ret = DVR_SUCCESS;
    Aml_MP_DVRPlayerStatus mpStatus;

    convertToMpDVRPlayerStatus(&mpStatus, (DVR_WrapperPlaybackStatus_t*)params);

    switch (event) {
    case DVR_PLAYBACK_EVENT_ERROR:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_ERROR, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_TRANSITION_OK:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_TRANSITION_OK, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_TRANSITION_FAILED:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_TRANSITION_FAILED, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_KEY_FAILURE:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_KEY_FAILURE, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_NO_KEY:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_NO_KEY, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_REACHED_BEGIN:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_REACHED_BEGIN, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_REACHED_END:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_REACHED_END, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_NOTIFY_PLAYTIME:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_NOTIFY_PLAYTIME, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_FIRST_FRAME:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_PLAYER_EVENT_FIRST_FRAME, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_TIMESHIFT_FR_REACHED_BEGIN:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_TIMESHIFT_FR_REACHED_BEGIN, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_TIMESHIFT_FF_REACHED_END:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_TIMESHIFT_FF_REACHED_END, (int64_t)&mpStatus);
        break;

    case DVR_PLAYBACK_EVENT_AUTO_RESUMED:
        if (mEventCb) mEventCb(mEventUserData, AML_MP_DVRPLAYER_EVENT_AUTO_RESUMED, (int64_t)&mpStatus);
        break;

    default:
        MLOG("unhandled event:%d", event);
        break;
    }

    return ret;
}
#endif

int AmlDVRPlayer::getMpPlayerHandle(AML_MP_PLAYER* handle)
{
    *handle = AML_MP_INVALID_HANDLE;
    if (mMpPlayerHandle != AML_MP_INVALID_HANDLE) {
        *handle = mMpPlayerHandle;
        return 0;
    }
    return -1;
}

int AmlDVRPlayer::setStreamsCommon(Aml_MP_DVRStreamArray* streams)
{
    int ret = AML_MP_ERROR;

#ifdef HAVE_LIBDVR
    Aml_MP_DVRStream* videoStream   = &streams->streams[AML_MP_DVR_VIDEO_INDEX];
    Aml_MP_DVRStream* audioStream   = &streams->streams[AML_MP_DVR_AUDIO_INDEX];
    Aml_MP_DVRStream* adStream      = &streams->streams[AML_MP_DVR_AD_INDEX];
    Aml_MP_DVRStream* subStream     = &streams->streams[AML_MP_DVR_SUBTITLE_INDEX];

    MLOG("video:pid %#x, codecId: %s, audio:pid %#x, codecId: %s, ad:pid: %#x, codecId: %s, sub:pid %#x, codecId: %s",
            videoStream->pid, mpCodecId2Str(videoStream->codecId),
            audioStream->pid, mpCodecId2Str(audioStream->codecId),
            adStream->pid, mpCodecId2Str(adStream->codecId),
            subStream->pid, mpCodecId2Str(subStream->codecId));

    memset(&mPlayPids, 0, sizeof(mPlayPids));
    mPlayPids.video.type = DVR_STREAM_TYPE_VIDEO;
    mPlayPids.video.pid = videoStream->pid;
    mPlayPids.video.format = convertToDVRVideoFormat(videoStream->codecId);

    mPlayPids.audio.type = DVR_STREAM_TYPE_AUDIO;
    mPlayPids.audio.pid = audioStream->pid;
    mPlayPids.audio.format = convertToDVRAudioFormat(audioStream->codecId);

    mPlayPids.ad.type = DVR_STREAM_TYPE_AD;
    mPlayPids.ad.pid = adStream->pid;
    mPlayPids.ad.format = convertToDVRAudioFormat(adStream->codecId);

    //If audio and AD pid is same, set invalid pid for AD
    if (mPlayPids.ad.pid == mPlayPids.audio.pid) {
        mPlayPids.ad.pid = AML_MP_INVALID_PID;
        mPlayPids.ad.format = (DVR_AudioFormat_t)(-1);
    }

    //set audio/video/ad/subtitle param to mp player
    mVideoParams.pid = videoStream->pid;
    mVideoParams.videoCodec = videoStream->codecId;
    mVideoParams.secureLevel = videoStream->secureLevel;

    mAudioParams.pid = audioStream->pid;
    mAudioParams.audioCodec = audioStream->codecId;
    mAudioParams.secureLevel = audioStream->secureLevel;

    mADParams.pid = adStream->pid;
    mADParams.audioCodec = adStream->codecId;
    mADParams.secureLevel = adStream->secureLevel;
    if (mADParams.pid == mAudioParams.pid) {
        mADParams.pid = AML_MP_INVALID_PID;
        mADParams.audioCodec = (Aml_MP_CodecID)-1;
        mADParams.secureLevel = AML_MP_DEMUX_MEM_SEC_NONE;
    }

    mSubtitleParams.pid = subStream->pid;
    mSubtitleParams.subtitleCodec = subStream->codecId;

    if (mMpPlayerHandle) {
        //coverity[value_overwrite]
        ret = Aml_MP_Player_SetVideoParams(mMpPlayerHandle, &mVideoParams);
        //coverity[value_overwrite]
        ret = Aml_MP_Player_SetAudioParams(mMpPlayerHandle, &mAudioParams);
        if (mADParams.pid != AML_MP_INVALID_PID) {
            //coverity[value_overwrite]
            ret = Aml_MP_Player_SetADParams(mMpPlayerHandle, &mADParams);
        }
        if (mSubtitleParams.subtitleCodec != AML_MP_VIDEO_CODEC_BASE &&
            mSubtitleParams.subtitleCodec != AML_MP_CODEC_UNKNOWN) {
            //coverity[value_overwrite]
            ret = Aml_MP_Player_SetSubtitleParams(mMpPlayerHandle, &mSubtitleParams);
        }
    }
#else
    AML_MP_UNUSED(streams);
#endif

    return ret;
}

////////////////////////////////////////////////////////////////////////////////
#ifdef HAVE_LIBDVR
Aml_MP_DVRPlayerState convertToMpDVRPlayerState(DVR_PlaybackPlayState_t state)
{
    switch (state) {
    case DVR_PLAYBACK_STATE_START:
        return AML_MP_DVRPLAYER_STATE_START;
        break;

    case DVR_PLAYBACK_STATE_STOP:
        return AML_MP_DVRPLAYER_STATE_STOP;
        break;

    case DVR_PLAYBACK_STATE_PAUSE:
        return AML_MP_DVRPLAYER_STATE_PAUSE;
        break;

    case DVR_PLAYBACK_STATE_FF:
        return AML_MP_DVRPLAYER_STATE_FF;
        break;

    case DVR_PLAYBACK_STATE_FB:
        return AML_MP_DVRPLAYER_STATE_FB;
        break;

    default:
        break;
    }

    return AML_MP_DVRPLAYER_STATE_START;
}

Aml_MP_DVRPlayerSegmentFlag convertToMpDVRSegmentFlag(DVR_PlaybackSegmentFlag_t flag)
{
    switch (flag) {
    case DVR_PLAYBACK_SEGMENT_ENCRYPTED:
        return AML_MP_DVRPLAYER_SEGMENT_ENCRYPTED;
        break;

    case DVR_PLAYBACK_SEGMENT_DISPLAYABLE:
        return AML_MP_DVRPLAYER_SEGMENT_DISPLAYABLE;
        break;

    case DVR_PLAYBACK_SEGMENT_CONTINUOUS:
        return AML_MP_DVRPLAYER_SEGMENT_CONTINUOUS;
        break;

    default:
        break;
    }

    return AML_MP_DVRPLAYER_SEGMENT_DISPLAYABLE;
}

static void convertToMpDVRPlayerStatus(Aml_MP_DVRPlayerStatus* mpStatus, DVR_WrapperPlaybackStatus_t* dvrStatus)
{
    mpStatus->state = convertToMpDVRPlayerState(dvrStatus->state);
    convertToMpDVRSourceInfo(&mpStatus->infoCur, &dvrStatus->info_cur);
    convertToMpDVRSourceInfo(&mpStatus->infoFull, &dvrStatus->info_full);

    convertToMpDVRStream(&mpStatus->pids.streams[AML_MP_DVR_VIDEO_INDEX], &dvrStatus->pids.video);
    convertToMpDVRStream(&mpStatus->pids.streams[AML_MP_DVR_AUDIO_INDEX], &dvrStatus->pids.audio);
    convertToMpDVRStream(&mpStatus->pids.streams[AML_MP_DVR_AD_INDEX], &dvrStatus->pids.ad);
    convertToMpDVRStream(&mpStatus->pids.streams[AML_MP_DVR_SUBTITLE_INDEX], &dvrStatus->pids.subtitle);
    convertToMpDVRStream(&mpStatus->pids.streams[AML_MP_DVR_PCR_INDEX], &dvrStatus->pids.pcr);

    mpStatus->pids.nbStreams = AML_MP_DVR_STREAM_NB;
    mpStatus->speed = dvrStatus->speed;
    mpStatus->flags = convertToMpDVRSegmentFlag(dvrStatus->flags);
    convertToMpDVRSourceInfo(&mpStatus->infoObsolete, &dvrStatus->info_obsolete);
}
#endif

}