/**
 * \page Test
 * \section Introduction
 * test code with CAS Hal APIs.
 * It supports:
 * \li Live
 * \li Record
 * \li Playback
 * \li Timeshift
 *
 * \section Usage
 *
 * Help msg will be shown if the test runs without parameters.\n
 * There are some general concepts for the parameters:
 *
 * For Live:
 * \code
 *   cas_hal_test live <fend_dev_no> <input_dev_no> <prog_index> <freqM> <isIPTV>
 * \endcode
 * For Live local:
 * \code
 *   cas_hal_test local <tsfile> <prog_index>
 * \endcode
 * For playback:
 * \code
 *   cas_hal_test dvrplay <tsfile> <scramble_flag>
 * \endcode
 * the timeshift backgroud recording file will be located in /data/data as:
 * \code
 *   /data/data/timeshifting-xxxx.*
 * \endcode
 *
 * \section FormatCode Format Code
 *
 * \li quit\n
 *             quit the test
 */
#ifndef CA_DEBUG_LEVEL
#define CA_DEBUG_LEVEL 2
#endif

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdbool.h>
#include <sys/time.h>


#ifdef ANDROID
#include <cutils/properties.h>
#endif

#include "AmTsPlayer.h"
#include "dvr_segment.h"
#include "dvr_wrapper.h"
#include "dvb_utils.h"
#include "fend.h"

#ifdef UNUSED
#undef UNUSED
#endif

#include "am_cas.h"
#include "cas_json.h"
#include "scan.h"

#define INF(fmt, ...)       fprintf(stdout, fmt, ##__VA_ARGS__)
#define ERR(fmt, ...)       fprintf(stderr, "error:" fmt, ##__VA_ARGS__)

#define FEND_DEV_NO (0)
#define DMX_DEV_NO (0)
#define DMX_DEV_NO_2ND (1)
#define AV_DEV_NO (0)
#define DSC_DEV_NO (0)
#define DVR_DEV_NO (0)
/*  Don't think about pip/fcc. two worst cases in record:
	#1, live + double record: live 0, record 1, record 2
	#2, timeshift + record: timeshift record use 0, timeshift playback use 1, another record use 2
	For tse record:
	0 and 1, tse_dmx_dev_id use dev 4, fta_dmx_dev_id use dev 5.
	2 tse_dmx_dev_id use dev 6, fta_dmx_dev_id use dev 7.
*/
#define MAX_REC_NUM (4)

#define VMX_CAS_STRING "Verimatrix"
#define NAGRA_CAS_STRING "Nagra"

#define X2_INJECT_LENGTH (256*1024)
#define X2_BLOCK_SIZE (256*1024)
#define X4_INJECT_LENGTH (188*1024)
#define X4_BLOCK_SIZE (188*1024)//same to asyncfifo flush size, it's enc block size and dec block size//65424
#define DVR_STREAM_TYPE_TO_TYPE(_t) (((_t) >> 24) & 0xF)
#define DVR_STREAM_TYPE_TO_FMT(_t)  ((_t) & 0x8F)

#define has_live(_m_)        ((_m_) & LIVE)
#define has_live_local(_m_)  ((_m_) & LIVE_LOCAL)
#define has_playback(_m_)    ((_m_) & PLAYBACK)
#define has_recording(_m_)   ((_m_) & RECORDING)
#define is_live(_m_)         ((_m_) == LIVE)
#define is_live_local(_m_)   ((_m_) == LIVE_LOCAL)
#define is_playback(_m_)     ((_m_) == PLAYBACK)
#define is_timeshifting(_m_) ((_m_) == TIMESHIFTING)
#define is_ext_playback(_m_)     ((_m_) == EXT_PLAYBACK)

struct vm_config_t {
    uint8_t run;
    uint8_t on;
    uint8_t config;
    uint8_t strength;
} g_vm_config = {0};

struct oc_config_t {
    uint8_t run;
    uint32_t flag;
    uint8_t analog;
    uint8_t cgmsa;
    uint8_t emicci;
} g_oc_config = {0};

typedef struct
{
    CasSession cas_session;
    SecMemHandle secmem_session;
    void *dvr_session; //'DVR_WrapperPlayback_t *' or 'DVR_WrapperRecord_t *'
    am_tsplayer_handle player_session;
    int replayed;
} CasTestSession;

typedef enum {
    PIN_NEED_CHECK,
    PIN_CHECK_SUCCESS,
    PIN_CHECK_FAILED,
    PIN_MAX,
} PIN_STATUS;

static int mode = 0;
static int duration=180000;
static int size=1024*1024*1024;
static char *pfilename = "/data/data/timeshifting.ts";

static int check_pin_status = PIN_MAX;
static int rec_status = 0;
static int32_t seclev = AM_TSPLAYER_DMX_FILTER_SEC_LEVEL2;
static uint32_t video_tunnel_id = 0;
static uint32_t inject_length = X4_INJECT_LENGTH;
static uint32_t block_size = X4_BLOCK_SIZE;
static const char* IOCTRL_INVOKE_GET_CAS_MODE = "{\"InvokeID\":3}";
int g_nosmp = 0;
int g_indexer = 0;
int g_tse_key_mode [MAX_REC_NUM]= {-1, -1, -1, -1};

//add for x4
#define TSN_PATH            "/sys/class/stb/tsn_source"
#define TSN_IPTV            "local"
#define TSN_DVB             "demod"
#define VIDEO_AXIS_PATH     "/sys/class/video/axis"


enum {
    LIVE        = 0x01,
    LIVE_LOCAL  = 0x02,
    PLAYBACK    = 0x04,
    RECORDING   = 0x08,
    TIMESHIFTING = PLAYBACK | RECORDING | 0x10,
    EXT_PLAYBACK = PLAYBACK | 0x10,
};

static CasHandle g_cas_handle = 0;
static CasTestSession play;
static CasTestSession recorder[MAX_REC_NUM];
static pthread_t gInjectThread;
static pthread_t gScbUpdateThread[MAX_REC_NUM];
static int running = 1;
static int gInjectRunning = 0;
static int g_frontend_id = -1;

static int watermark_test_config(
    uint8_t on,
    uint8_t config,
    uint8_t strength);
static int output_control_test_config(
    uint32_t flag,
    uint8_t analog,
    uint8_t cgmsa,
    uint8_t emicci);
static bool get_cas_mode(CasSession session);
static int get_tse_key_mode(CasSession session);
static AM_RESULT cas_event_cb(CasSession session, char *json);
static void video_callback(void *user_data, am_tsplayer_event *event);
extern int ext_dvr_playback_stop(void);
extern int ext_dvr_playback(const char *path, CasHandle cas_handle);
extern int dvr_wrapper_set_playback_secure_buffer (DVR_WrapperPlayback_t playback,
                        uint8_t *p_secure_buf,
                        uint32_t len);

int amsysfs_set_sysfs_str(const char *path, const char *val);

//convert am video codec fmt to dvb fmt
bool convert_video_codec_fmt_am2dvb(am_tsplayer_video_codec am_fmt, DVR_VideoFormat_t* dvb_fmt) {
  if (!dvb_fmt)
    return false;

  bool result = true;

  switch (am_fmt)
  {
    case AV_VIDEO_CODEC_MPEG1:
      *dvb_fmt = DVR_VIDEO_FORMAT_MPEG1;
      break;
    case AV_VIDEO_CODEC_MPEG2:
      *dvb_fmt = DVR_VIDEO_FORMAT_MPEG2;
      break;
    case AV_VIDEO_CODEC_H265:
      *dvb_fmt = DVR_VIDEO_FORMAT_HEVC;
      break;
    case AV_VIDEO_CODEC_H264:
      *dvb_fmt = DVR_VIDEO_FORMAT_H264;
      break;
    case AV_VIDEO_CODEC_VP9:
      *dvb_fmt = DVR_VIDEO_FORMAT_VP9;
      break;
    default:
      ERR("Not supported type convert, am_tsplayer_video_codec:%d\n", am_fmt);
      result = false;
      break;
  }

  return result;
}

//convert am audio codec fmt to dvb fmt
bool convert_audio_codec_fmt_am2dvb(am_tsplayer_audio_codec am_fmt, DVR_AudioFormat_t* dvb_fmt) {
  if (!dvb_fmt)
    return false;

  bool result = true;

  switch (am_fmt)
  {
    case AV_AUDIO_CODEC_MP2:
      *dvb_fmt = DVR_AUDIO_FORMAT_MPEG;
      break;
    case AV_AUDIO_CODEC_MP3:
      *dvb_fmt = DVR_AUDIO_FORMAT_MPEG;
      break;
    case AV_AUDIO_CODEC_AC3:
      *dvb_fmt = DVR_AUDIO_FORMAT_AC3;
      break;
    case AV_AUDIO_CODEC_EAC3:
      *dvb_fmt = DVR_AUDIO_FORMAT_EAC3;
      break;
    case AV_AUDIO_CODEC_DTS:
      *dvb_fmt = DVR_AUDIO_FORMAT_DTS;
      break;
    case AV_AUDIO_CODEC_AAC:
      *dvb_fmt = DVR_AUDIO_FORMAT_AAC;
      break;
    case AV_AUDIO_CODEC_LATM:
      *dvb_fmt = DVR_AUDIO_FORMAT_LATM;
      break;
    case AV_AUDIO_CODEC_PCM:
      *dvb_fmt = DVR_AUDIO_FORMAT_PCM;
      break;
    case AV_AUDIO_CODEC_AC4:
      *dvb_fmt = DVR_AUDIO_FORMAT_AC4;
      break;
    default:
      ERR("Not supported type convert, am_tsplayer_audio_codec:%d\n", am_fmt);
      result = false;
      break;
  }

  return result;
}

static int fend_lock(int dev_no, int freqM, int sym)
{
    int ret;
    int fend_id = -1;
    int wait_time = 3;
    dmd_delivery_t delivery;
    dmd_tuner_event_t status = TUNER_STATE_UNKNOWN;

    if (open_fend(dev_no, &fend_id)) {
        ERR("fend open failed\n");
        return -1;
    }

    memset(&delivery, 0, sizeof(delivery));
    delivery.device_type = DMD_CABLE;
    delivery.delivery.cable.frequency = freqM*1000;
    delivery.delivery.cable.symbol_rate = sym;
    delivery.delivery.cable.modulation = DMD_MOD_QAM;//DMD_MOD_128QAM;
    ret = dmd_lock_c(fend_id, &delivery);

    INF("DVB-C: lock to freq:%d, modulation:%d symbol_rate:%d ret:%d \n",
        delivery.delivery.cable.frequency,
        delivery.delivery.cable.modulation,
        delivery.delivery.cable.symbol_rate,
        ret);

    if (ret) {
        ERR("lock failed, ret:%d\n", ret);
        close_fend(fend_id);
        return -1;
    }

    g_frontend_id = fend_id;

    while (wait_time--) {
        sleep(1);
        status = get_dmd_lock_status(fend_id);
        if (status == TUNER_STATE_LOCKED)
            break;
    }

    if (status == TUNER_STATE_LOCKED) {
        return 0;
    }
    else {
        ERR("Try 3 times but lock failed, status:%d\n", status);
        close_fend(fend_id);
        return -1;
    }
}

int init_tsplayer_inject(dvb_service_info_t *prog)
{
    int ret;
    am_tsplayer_handle session = 0;
    am_tsplayer_input_source_type tsType = TS_MEMORY;
    am_tsplayer_input_buffer_type drmmode = TS_INPUT_BUFFER_TYPE_NORMAL;

    am_tsplayer_video_params vparam;
    am_tsplayer_audio_params aparam;
    am_tsplayer_init_params  param = {tsType, drmmode, 0, 0};

    if (prog->scrambled) {
        param.drmmode = TS_INPUT_BUFFER_TYPE_TVP;
        INF("enable local TVP\n");
    }
    ret = AmTsPlayer_create(param, &session);
    ret |= AmTsPlayer_setSurface(session, (void *)&video_tunnel_id);
    ret |= AmTsPlayer_setWorkMode(session, TS_PLAYER_MODE_NORMAL);
    ret |= AmTsPlayer_registerCb(session, video_callback, NULL);

    if (prog->scrambled && !g_nosmp) {
        AmTsPlayer_setParams(session, AM_TSPLAYER_KEY_VIDEO_SECLEVEL, &seclev);
        AmTsPlayer_setParams(session, AM_TSPLAYER_KEY_AUDIO_SECLEVEL, &seclev);
        CA_DEBUG(1,"%s secure level: %#x\n ", __func__, seclev);
    }
    memset(&vparam, 0, sizeof(vparam));
    vparam.codectype = prog->i_vformat;

    vparam.pid = prog->i_video_pid;
    ret |= AmTsPlayer_setVideoParams(session, &vparam);

    memset(&aparam, 0, sizeof(aparam));
    aparam.codectype = prog->i_aformat;
    aparam.pid = prog->i_audio_pid;
    ret |= AmTsPlayer_setAudioParams(session, &aparam);
    if (vparam.pid != 0 && vparam.pid != 0x1fff) {
        ret |= AmTsPlayer_startVideoDecoding(session);
        ret |= AmTsPlayer_showVideo(session);
        ret |= AmTsPlayer_setTrickMode(session, AV_VIDEO_TRICK_MODE_NONE);
    }
    if (aparam.pid != 0 && aparam.pid != 0x1fff) {
        ret |= AmTsPlayer_startAudioDecoding(session);
    }

    play.player_session = session;
    INF("%s ret:%d, session:%#zx\n", __func__, ret, session);

    return 0;
}

static void *inject_thread(void *arg)
{
    int fd;
    uint8_t* buf = (uint8_t*)malloc(inject_length * sizeof(uint8_t));
    if (buf == NULL) {
        ERR("%s malloc FAILED\n", __func__);
        return NULL;
    }
    char *tspath = (char *)arg;
    const int kRwTimeout = 30000;
    am_tsplayer_input_buffer ibuf = {TS_INPUT_BUFFER_TYPE_NORMAL, (char *)buf, 0};

    fd = open(tspath, O_RDONLY);
    INF("%s open %s, fd:%d\n", __func__, tspath, fd);
    if (fd == -1) {
        free(buf);
        return NULL;
    }
    while (gInjectRunning) {
        int retry = 100;
        int kRwSize = 0;
        am_tsplayer_result res;

        kRwSize = read(fd, buf, inject_length);
        if (kRwSize <= 0) {
            INF("%s read end of file, loop\n", __func__);
            lseek(fd, 0, SEEK_SET);
            continue;
        }
        ibuf.buf_size = kRwSize;

        do {
            res = AmTsPlayer_writeData(play.player_session, &ibuf, kRwTimeout);
            if (res == AM_TSPLAYER_ERROR_RETRY) {
                usleep(50000);
            } else {
                //INF("%#x Bytes injected\n", ibuf.buf_size);
                break;
            }
        } while(retry-- > 0);
    }
    free(buf);
    close(fd);
    INF("exit %s\n", __func__);
    return NULL;
}

static void *scbUpdate_thread(void *arg)
{
    int tse_key_mode = -1;
    int dev_no = *(int*)arg;
    free (arg);
    int record_is_running =1;
    int error = 0;
    pthread_detach(pthread_self());

    while (record_is_running) {
        if (recorder[dev_no].cas_session) {
            tse_key_mode = get_tse_key_mode(recorder[dev_no].cas_session);
        }else {
            INF("record [%d]has been closed. return", dev_no);
            return NULL;
        }
        switch (tse_key_mode) {
        case 0:
        case 2:
            tse_key_mode = 2;
        break;
        case 1:
        case 3:
            tse_key_mode = 3;
        break;
        default:
            INF("invalid tse key mode = %d. Quit scb thread! ", tse_key_mode);
            return NULL;
        }
        if (tse_key_mode != g_tse_key_mode[dev_no]) {
            INF("record [%d]:tse_key_mode update:%d -> %d\n", dev_no, g_tse_key_mode[dev_no], tse_key_mode);
            error = dvr_wrapper_ioctl_record(recorder[dev_no].dvr_session, DVR_RECORD_CMD_ENC_CHANGE_SCB , &tse_key_mode, sizeof(tse_key_mode));
            if (error) {
                INF("Set scb fail = (%#x)", error);
                return NULL;
            }
            g_tse_key_mode[dev_no] = tse_key_mode;
        }
        usleep(400000);/* 400ms */

        record_is_running = rec_status & (1 << dev_no);

    }
    INF("exit %s\n", __func__);
    return NULL;
}

static int dvb_init(void)
{
    int ret;

    ret = AM_CA_Init(&g_cas_handle);
    ret |= AM_CA_RegisterEventCallback((CasSession)NULL, cas_event_cb);
    INF("CAS init ret = %d\r\n", ret);

    return ret;
}

static AM_RESULT cas_event_cb(CasSession session, char *json)
{
    cJSON* cas;
    cJSON* input;
    cJSON* type;
    cJSON* state;

    UNUSED(session);
    INF("%s:%s\n", __func__, json);
    input = cJSON_Parse(json);
    if (input == NULL) {
        return -1;
    }
    cas = cJSON_GetObjectItemCaseSensitive(input, ITEM_CAS);
    if (!cJSON_IsString(cas) || (strcmp(cas->valuestring, VMX_CAS_STRING))) {
        INF("%s, not Verimatrix cas cmd\n", __func__);
        goto end;
    }
    type = cJSON_GetObjectItemCaseSensitive(input, ITEM_TYPE);
    if (!cJSON_IsString(type) || !type->valuestring) {
        INF("%s invalid cmd\n", __func__);
        goto end;
    }
    if (!strcmp(type->valuestring, ITEM_CHECK_PIN)) {
        check_pin_status = PIN_NEED_CHECK;
        INF("notify pin check status -> PIN_NEED_CHECK \n");
    } else if (!strcmp(type->valuestring, ITEM_PIN_STATE)) {
        state = cJSON_GetObjectItemCaseSensitive(input, ITEM_ERROR_CODE);
        if (!cJSON_IsNumber(state)) {
            INF("%s invalid state type\n", __func__);
            goto end;
        }
        if (state) {
            check_pin_status = PIN_CHECK_SUCCESS;
            INF("notify pin check status -> PIN_CHECK_SUCCESS\n");
        } else {
            check_pin_status = PIN_CHECK_FAILED;
            INF("notify pin check status -> PIN_CHECK_FAILED");
        }
    }
    return 0;

end:
    if (input) {
        cJSON_Delete(input);
    }

    return 0;
}

static DVR_Result_t encrypt_callback(DVR_CryptoParams_t *params, void *userdata)
{
    int ret;
    CasSession cas_session = *(CasSession *)userdata;
    AM_CA_CryptoPara_t *cryptoPara = (AM_CA_CryptoPara_t *)params;
    struct timespec start_ts, end_ts;

    if (!cas_session) {
        ERR("%s invalid cas session\n", __func__);
        return -1;
    }
    clock_gettime(CLOCK_MONOTONIC, &start_ts);

    ret = AM_CA_DVREncrypt(cas_session, cryptoPara);

    if (ret) {
        cryptoPara->buf_len = 0;
        cryptoPara->buf_out.size = 0;
        ERR("%s failed\n", __func__);
        return -1;
    }

    if (cryptoPara->buf_len) {
        clock_gettime(CLOCK_MONOTONIC, &end_ts);
        CA_DEBUG(1,"%s AM_CA_DVREncrypt use (%lu) ms for (0x%x) bytes\n ", __func__,
                (end_ts.tv_sec*1000 + end_ts.tv_nsec/1000000) -
                (start_ts.tv_sec*1000 + start_ts.tv_nsec/1000000),
                cryptoPara->buf_len);
     }
    return 0;
}
static DVR_Result_t decrypt_block_callback(DVR_CryptoParams_t *params, void *userdata)
{
    int ret;
    UNUSED(userdata);
    struct timespec start_ts, end_ts;

    AM_CA_CryptoPara_t *cryptoPara = (AM_CA_CryptoPara_t *)params;

    if (!play.replayed) {
        ret = AM_CA_DVRReplay(play.cas_session, cryptoPara);
        if (check_pin_status == PIN_NEED_CHECK) {
            do {
                //INF("wait state %d\n", check_pin_status);
                usleep(200*1000);
            } while (check_pin_status != PIN_CHECK_SUCCESS &&
                 running);
            ret = AM_CA_DVRReplay(play.cas_session, cryptoPara);
        }

        if (!ret) {
            play.replayed = 1;
        } else {
            cryptoPara->buf_len = cryptoPara->buf_in.size;
            cryptoPara->buf_out.size = cryptoPara->buf_in.size;
            return 0;
        }
    }
    clock_gettime(CLOCK_MONOTONIC, &start_ts);

    ret = AM_CA_DVRDecrypt(play.cas_session, cryptoPara);
    if (ret) {
        cryptoPara->buf_len = 0;
        cryptoPara->buf_out.size = 0;
        ERR("%s failed\n", __func__);
        return -1;
    }

    if (cryptoPara->buf_len) {
        //INF("%#x bytes decrypted\n", cryptoPara->buf_len);
    }
    if (cryptoPara->buf_len) {
        clock_gettime(CLOCK_MONOTONIC, &end_ts);
        CA_DEBUG(1,"%s AM_CA_DVRDecrypt use (%lu) ms for (0x%x) bytes.\n ", __func__,
                (end_ts.tv_sec*1000 + end_ts.tv_nsec/1000000) -
                (start_ts.tv_sec*1000 + start_ts.tv_nsec/1000000),
                cryptoPara->buf_len);
    }

    return 0;
}

static DVR_Result_t decrypt_tse_callback(DVR_CryptoParams_t *params, void *userdata)
{
    int ret;
    UNUSED(userdata);

    AM_CA_CryptoPara_t *cryptoPara = (AM_CA_CryptoPara_t *)params;
    //INF("%s cryptoPara->new_position %d， cryptoPara->offset %lld. \n", __func__, cryptoPara->new_position, cryptoPara->offset);

    if ((cryptoPara->new_position) || (cryptoPara->offset == 0)) {
        INF("%sAM_CA_DVRReplay is called \n", __func__);

        ret = AM_CA_DVRReplay(play.cas_session, cryptoPara);
        if (!play.replayed) {
            if (check_pin_status == PIN_NEED_CHECK) {
                do {
                    //INF("wait state %d\n", check_pin_status);
                    usleep(200*1000);
                } while (check_pin_status != PIN_CHECK_SUCCESS &&
                     running);
                ret = AM_CA_DVRReplay(play.cas_session, cryptoPara);
            }
            if (!ret) {
                play.replayed = 1;
            } else {
                cryptoPara->buf_len = cryptoPara->buf_in.size;
                cryptoPara->buf_out.size = cryptoPara->buf_in.size;
                return 0;
            }
        }
        if (cryptoPara->offset != 0) {

            ret = AM_CA_DVRDecrypt(play.cas_session, cryptoPara);
            cryptoPara->buf_out.addr = cryptoPara->buf_in.addr;
            if (ret) {
                cryptoPara->buf_len = 0;
                cryptoPara->buf_out.size = 0;
                ERR("%s failed at line %d\n", __func__, __LINE__);
                return -1;
            }
            cryptoPara->new_position = 0;
            ret = AM_CA_DVRReplay(play.cas_session, cryptoPara);
            if (ret) {
                cryptoPara->buf_len = cryptoPara->buf_in.size;
                cryptoPara->buf_out.size = cryptoPara->buf_in.size;
                return 0;
            }
        }
    }
    ret = AM_CA_DVRDecrypt(play.cas_session, cryptoPara);
    cryptoPara->buf_out.addr = cryptoPara->buf_in.addr;
    #if 0
    if (ret) {
        cryptoPara->buf_len = 0;
        cryptoPara->buf_out.size = 0;
        ERR("%s failed at line %d\n", __func__, __LINE__);
        return -1;
    }
    #endif
    return 0;
}

static DVR_Result_t RecEventHandler(DVR_RecordEvent_t event, void *params, void *userdata)
{
   if (userdata != NULL)
   {
      DVR_WrapperRecordStatus_t *status = (DVR_WrapperRecordStatus_t *)params;

      UNUSED(status);
      switch (event)
      {
         case DVR_RECORD_EVENT_STATUS:
            //INF("Record event %d\n", status->state);
            break;
         default:
            //ERR("Unhandled recording event 0x%x from (%s)\n", event, (char *)userdata);
         break;
      }
   }
   return DVR_SUCCESS;
}

static void video_callback(void *user_data, am_tsplayer_event *event)
{
    UNUSED(user_data);
    INF("video evt callback, type:%d\r\n", event?event->type:0);
    if (event == NULL)
        return;
    switch (event->type) {
        case AM_TSPLAYER_EVENT_TYPE_VIDEO_CHANGED:
            INF("[evt] video changed\r\n");
            break;

        case AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME:
            INF("[evt] first frame\r\n");
            break;
        default:
            break;
    }
}

static DVR_Result_t PlayEventHandler(DVR_PlaybackEvent_t event, void *params, void *userdata)
{
   UNUSED(params);

   if (userdata != NULL)
   {
      switch (event)
      {
         case DVR_PLAYBACK_EVENT_TRANSITION_OK:
            /**< Update the current player information*/
           //log_play_evt((DVR_WrapperPlaybackStatus_t *)params, userdata);
         break;
         case DVR_PLAYBACK_EVENT_REACHED_END:
            /**< File player's EOF*/
           //PLAY_EVT("EOF (%s)\n", (char *)userdata);
         break;
         default:
           //ERR("Unhandled event 0x%x from (%s)\n", event, (char *)userdata);
         break;
      }
   }
   return DVR_SUCCESS;
}

static void tsplayer_callback(void *user_data, am_tsplayer_event *event)
{
   UNUSED(user_data);

   if (event)
   {
      switch (event->type)
      {
          case AM_TSPLAYER_EVENT_TYPE_PTS:
          {
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_PTS: stream_type:%d, pts[%llu]\n",
                  event->event.pts.stream_type,
                  event->event.pts.pts);
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_DTV_SUBTITLE:
          {
              uint8_t* pbuf = event->event.mpeg_user_data.data;
              uint32_t size = event->event.mpeg_user_data.len;
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_DTV_SUBTITLE: %x-%x-%x-%x ,size %d\n",
                  pbuf[0], pbuf[1], pbuf[2], pbuf[3], size);
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_USERDATA_CC:
          {
              uint8_t* pbuf = event->event.mpeg_user_data.data;
              uint32_t size = event->event.mpeg_user_data.len;
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_USERDATA_CC: %x-%x-%x-%x ,size %d\n",
                  pbuf[0], pbuf[1], pbuf[2], pbuf[3], size);
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_USERDATA_AFD:
          {
              uint8_t* pbuf = event->event.mpeg_user_data.data;
              uint32_t size = event->event.mpeg_user_data.len;
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_USERDATA_AFD: %x-%x-%x-%x ,size %d\n",
                  pbuf[0], pbuf[1], pbuf[2], pbuf[3], size);
              //USERDATA_AFD_t afd = *((USERDATA_AFD_t *)pbuf);
              //afd.reserved = afd.pts = 0;
              //INF("[evt] video afd changed: flg[0x%x] fmt[0x%x]\n", afd.af_flag, afd.af);
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_VIDEO_CHANGED:
          {
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_VIDEO_CHANGED: [width:height] [%d x %d] @%d aspectratio[%d]\n",
              event->event.video_format.frame_width,
              event->event.video_format.frame_height,
              event->event.video_format.frame_rate,
              event->event.video_format.frame_aspectratio);
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_AUDIO_CHANGED:
          {
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_AUDIO_CHANGED: sample_rate:%d, channels:%d\n",
                  event->event.audio_format.sample_rate,
                  event->event.audio_format.channels);
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_DATA_LOSS:
          {
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_DATA_LOSS\n");
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_DATA_RESUME:
          {
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_DATA_RESUME\n");
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_SCRAMBLING:
          {
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_SCRAMBLING: stream_type:%d is_scramling[%d]\n",
                  event->event.scramling.stream_type,
                  event->event.scramling.scramling);
              break;
          }
          case AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME:
          {
              INF("[evt] AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME: ## VIDEO_AVAILABLE ##\n");
              break;
          }
          default:
              break;
      }
   }
}

static int start_descrambling(dvb_service_info_t *prog)
{
    int ret;
    AM_CA_ServiceInfo_t cas_para;
    CA_SERVICE_TYPE_t service_type = SERVICE_LIVE_PLAY;

    if (!prog->scrambled)
        return 0;

    ret = AM_CA_SetEmmPid(g_cas_handle, DMX_DEV_NO, prog->i_ca_pid);
    if (ret) {
        ERR("CAS set emm PID failed. ret = %d\r\n", ret);
    }

    ret = AM_CA_OpenSession(g_cas_handle, &play.cas_session, service_type);
    if (ret) {
        ERR("CAS open session failed. ret = %d\r\n", ret);
        return -1;
    }

    ret = AM_CA_RegisterEventCallback(play.cas_session, cas_event_cb);
    if (ret) {
        ERR("CAS RegisterEventCallback failed. ret = %d\r\n", ret);
    }

    memset(&cas_para, 0x0, sizeof(AM_CA_ServiceInfo_t));
    if (prog->service_type == IPTV_TYPE) {
        cas_para.service_mode = SERVICE_IPTV;
        INF("IPTV service mode:%d\n", cas_para.service_mode);
    } else {
        cas_para.service_mode = SERVICE_DVB;
        INF("DVB service mode:%d\n", cas_para.service_mode);
    }

    cas_para.service_id = prog->i_program_num;
    cas_para.service_type = SERVICE_LIVE_PLAY;
    cas_para.ecm_pid = prog->i_ecm_pid[0];
    cas_para.stream_pids[0] = prog->i_video_pid;
    cas_para.stream_pids[1] = prog->i_audio_pid;
    cas_para.stream_num = 2;
    if (prog->private_data[0]) {
        memcpy(cas_para.ca_private_data, prog->private_data, prog->private_data[0]);
    }
    cas_para.ca_private_data_len = prog->private_data[0];
    ret = AM_CA_StartDescrambling(play.cas_session, &cas_para);
    if (ret) {
        ERR("CAS start descrambling failed. ret = %d\r\n", ret);
        return -1;
    }

    INF("CAS started\r\n");
    return 0;
}

static int start_liveplay(dvb_service_info_t *prog)
{
    uint32_t num = 0;
    am_tsplayer_result ret;
    am_tsplayer_video_params vparam;
    am_tsplayer_audio_params aparam;
    am_tsplayer_init_params param;
    am_tsplayer_avsync_mode avsyncmode = TS_SYNC_PCRMASTER;

    am_tsplayer_handle player_session = 0;

    INF("vpid:%#x vfmt:%d apid:%#x afmt:%d ecmpid:%#x emmpid:%#x scramble:%d\r\n",
        prog->i_video_pid, prog->i_vformat,
        prog->i_audio_pid, prog->i_aformat,
        prog->i_ecm_pid[0], prog->i_ca_pid, prog->scrambled);

    memset(&param, 0 , sizeof(am_tsplayer_init_params));
    param.source = TS_DEMOD;
    param.dmx_dev_id = DMX_DEV_NO;

    if (prog->scrambled && !g_nosmp) {
        param.drmmode = TS_INPUT_BUFFER_TYPE_TVP;
        INF("enable live TVP\n");
    }
    ret = AmTsPlayer_create(param, &player_session);
    if (ret != AM_TSPLAYER_OK) {
        CA_DEBUG(0, "Create tsplayer failed!!!! err:%x", ret);
        return -1;
    }
    play.player_session = player_session;

    if (prog->scrambled && !g_nosmp) {
        AmTsPlayer_setParams(player_session, AM_TSPLAYER_KEY_VIDEO_SECLEVEL, &seclev);
        AmTsPlayer_setParams(player_session, AM_TSPLAYER_KEY_AUDIO_SECLEVEL, &seclev);
        CA_DEBUG(1,"%s secure level: %#x\n ", __func__, seclev);
    }
    INF("AmTsPlayer_setSurface player_session is %#zx,  video_tunnel_id is 0x%d\n", player_session, video_tunnel_id);
    ret = AmTsPlayer_setSurface(player_session, (void *)&video_tunnel_id);
    ret |= AmTsPlayer_getInstansNo(player_session, &num);
    ret |= AmTsPlayer_setWorkMode(player_session, TS_PLAYER_MODE_NORMAL);
    ret |= AmTsPlayer_registerCb(player_session, video_callback, NULL);
    ret |= AmTsPlayer_setSyncMode(player_session, avsyncmode);
//    ret |= AmTsPlayer_setVideoWindow(player_session, 0, 0, 1280, 720);

#ifdef ANDROID
    am_tsplayer_audio_patch_manage_mode audio_mode = AUDIO_PATCH_MANAGE_FORCE_ENABLE;
    ret |= AmTsPlayer_setParams(player_session,
                AM_TSPLAYER_KEY_SET_AUDIO_PATCH_MANAGE_MODE,
                &audio_mode);
#endif
    INF("create tsplayer success. session:%#zx instance_no:%d ret:%d\r\n", player_session, num, ret);

    memset(&vparam, 0, sizeof(vparam));
    vparam.codectype = prog->i_vformat;
    vparam.pid = prog->i_video_pid;
    AmTsPlayer_setVideoParams(player_session, &vparam);
    AmTsPlayer_startVideoDecoding(player_session);

    memset(&aparam, 0, sizeof(aparam));
    aparam.codectype = prog->i_aformat;
    aparam.pid = prog->i_audio_pid;
    AmTsPlayer_setAudioParams(player_session, &aparam);
    AmTsPlayer_startAudioDecoding(player_session);

    AmTsPlayer_showVideo(player_session);
    AmTsPlayer_setTrickMode(player_session, AV_VIDEO_TRICK_MODE_NONE);

    return 0;
}

static int stop_liveplay(void)
{
    INF("stop_liveplay==\n");
    if (play.cas_session) {
        AM_CA_StopDescrambling(play.cas_session);
        AM_CA_CloseSession(play.cas_session);
    }

    AmTsPlayer_stopAudioDecoding(play.player_session);
    AmTsPlayer_stopVideoDecoding(play.player_session);
    AmTsPlayer_release(play.player_session);

    memset(&play, 0, sizeof(CasTestSession));

    return 0;
}

static int start_recording(int dev_no, dvb_service_info_t *prog, char *tspath)
{
    DVR_WrapperRecordOpenParams_t rec_open_params;
    DVR_WrapperRecordStartParams_t rec_start_params;
    DVR_WrapperPidsInfo_t *pids_info;
    bool tse_mode = false;
    //char cmd[256];
    int error;

    AM_CA_ServiceInfo_t cas_para;
    CA_SERVICE_TYPE_t service_type = SERVICE_PVR_RECORDING;

    UNUSED(dev_no);
    DVR_WrapperRecord_t recorder_session = NULL;

    if (dev_no >= MAX_REC_NUM) {
        ERR("wrong device no %d\n", dev_no);
        return -1;
    }
    memset(&rec_open_params, 0, sizeof(DVR_WrapperRecordOpenParams_t));

    rec_open_params.dmx_dev_id = dev_no;
    rec_open_params.segment_size = 100 * 1024 * 1024;/*100MB*/
    rec_open_params.max_size = size;
    rec_open_params.max_time = duration;
    rec_open_params.event_fn = RecEventHandler;
    rec_open_params.event_userdata = "rec0";
    rec_open_params.flags = 0;
    rec_open_params.force_sysclock = true;
    if (g_nosmp == 1) {
        rec_open_params.flush_size = 188 * 1024;
    }

    if (is_timeshifting(mode)) {
        rec_open_params.flags |= DVR_RECORD_FLAG_ACCURATE;
        service_type = SERVICE_PVR_TIMESHIFT_RECORDING;
    }

    strncpy(rec_open_params.location, tspath, sizeof(rec_open_params.location));
    rec_open_params.location[sizeof(rec_open_params.location)-1] = '\0';

    rec_open_params.is_timeshift = (is_timeshifting(mode)) ? DVR_TRUE : DVR_FALSE;

    if (prog->scrambled) {
        rec_open_params.crypto_data = &recorder[dev_no].cas_session;
        rec_open_params.crypto_fn = encrypt_callback;
    }

    error = dvr_wrapper_open_record(&recorder_session, &rec_open_params);
    if (error) {
        ERR( "recorder open fail = (0x%x)\n", error);
        return -1;
    }
    recorder[dev_no].dvr_session = (void *)recorder_session;

    INF( "Starting %s recording %p [%ld secs/%llu bytes] [%s.ts]\n",
       (is_timeshifting(mode))? "timeshift" : "normal",
       recorder_session,
       rec_open_params.max_time,
       rec_open_params.max_size,
       rec_open_params.location);

    memset(&rec_start_params, 0, sizeof(rec_start_params));

    if (prog->scrambled) {
        void *buf = NULL;
        uint32_t secmem_size = block_size*20;
        SecMemHandle secmem_session;

        error = AM_CA_OpenSession(g_cas_handle, &recorder[dev_no].cas_session, service_type);
        if (error) {
            ERR("CAS open session failed. ret = %d\r\n", error);
            dvr_wrapper_close_record(recorder_session);
            return -1;
        }
        error = AM_CA_RegisterEventCallback(recorder[dev_no].cas_session, cas_event_cb);
        if (error) {
            ERR("CAS RegisterEventCallback failed. ret = %d\r\n", error);
        }

//        tse_mode = get_cas_mode(recorder[dev_no].cas_session);

        if (g_vm_config.run) {
            watermark_test_config(g_vm_config.on,
            g_vm_config.config,
            g_vm_config.strength);
        }

        if (g_oc_config.run) {
            output_control_test_config(g_oc_config.flag,
                           g_oc_config.analog,
                           g_oc_config.cgmsa,
                           g_oc_config.emicci);
        }

        INF("set AM_CA_SetEmmPid: %#x\n", prog->i_ca_pid);

        error = AM_CA_SetEmmPid(g_cas_handle, dev_no, prog->i_ca_pid);
        if (error) {
            ERR("CAS set emm PID failed. ret = %d\r\n", error);
            return -1;
        }

        memset(&cas_para, 0x0, sizeof(AM_CA_ServiceInfo_t));
        cas_para.dmx_dev = dev_no;

        cas_para.service_id = prog->i_program_num;
        cas_para.service_type = service_type;
        cas_para.ecm_pid = prog->i_ecm_pid[0];
        cas_para.stream_pids[0] = prog->i_video_pid;
        cas_para.stream_pids[1] = prog->i_audio_pid;
        cas_para.stream_num = 2;
        if (prog->private_data[0]) {
            // parser algo from pmt, use for descramble
            memcpy(cas_para.ca_private_data, prog->private_data, prog->private_data[0]);
        }
        cas_para.ca_private_data_len = prog->private_data[0];

        INF("start_recording,i_program_num=%d,ca_private_data[0]=%d,[2]=0x%x,vpid=0x%x,apid=0x%x\n", prog->i_program_num,
            cas_para.ca_private_data[0], cas_para.ca_private_data[2], prog->i_video_pid, prog->i_audio_pid);

        if (prog->service_type == IPTV_TYPE) {
            cas_para.service_mode = SERVICE_IPTV;
            INF("IPTV service mode:%d\n", cas_para.service_mode);
        } else {
            cas_para.service_mode = SERVICE_DVB;
            INF("DVB service mode:%d\n", cas_para.service_mode);
        }
        error = AM_CA_DVRStart(recorder[dev_no].cas_session, &cas_para);
        if (error) {
            ERR("CAS start DVR failed. ret = %d\r\n", error);
            AM_CA_CloseSession(recorder[dev_no].cas_session);
            recorder[dev_no].cas_session = 0;
            dvr_wrapper_close_record(recorder_session);
            return -1;
        }

        if (false == tse_mode && !g_nosmp) {
            secmem_session = AM_CA_CreateSecmem(
                recorder[dev_no].cas_session,
                service_type,
                &buf,
                &secmem_size);
            if (!secmem_session) {
                ERR("create dvr recording secmem failed\n");
                dvr_wrapper_close_record(recorder_session);
                return -1;
            }
            recorder[dev_no].secmem_session = secmem_session;

            INF("set dvr recording secmem addr:%#zx size:%#x\n", (size_t)buf, secmem_size);
            error = dvr_wrapper_set_record_secure_buffer(recorder_session, buf, secmem_size);
            if (error) {
                ERR("dvr_wrapper_set_record_secure_buffer failed\n");
                dvr_wrapper_close_record(recorder_session);
                AM_CA_DestroySecmem(recorder[dev_no].cas_session, secmem_session);
                recorder[dev_no].secmem_session = (SecMemHandle)NULL;
                return -1;
            }
        }
    }

    pids_info = &rec_start_params.pids_info;
    pids_info->nb_pids = 2;
    pids_info->pids[0].pid = prog->i_video_pid;
    pids_info->pids[1].pid = prog->i_audio_pid;

    DVR_VideoFormat_t dvb_vfmt;
    if (!convert_video_codec_fmt_am2dvb(prog->i_vformat, &dvb_vfmt)) {
        ERR("can not convert am video codec type(%d) to dtv", prog->i_vformat);
    }
    pids_info->pids[0].type = DVR_STREAM_TYPE_VIDEO << 24 | dvb_vfmt;

    DVR_AudioFormat_t dvb_afmt;
    if (!convert_audio_codec_fmt_am2dvb(prog->i_aformat, &dvb_afmt)) {
        ERR("can not convert am audio codec type(%d) to dtv", prog->i_aformat);
    }
    pids_info->pids[1].type = DVR_STREAM_TYPE_AUDIO << 24 | dvb_afmt;

    error = dvr_wrapper_start_record(recorder_session, &rec_start_params);
    if (error)
    {
        ERR( "recorder start fail = (0x%x)\n", error);
        dvr_wrapper_close_record(recorder_session);

        if (false == tse_mode && !g_nosmp) {
            AM_CA_DestroySecmem(recorder[dev_no].cas_session, recorder[dev_no].secmem_session);
            recorder[dev_no].secmem_session = (SecMemHandle)NULL;
        }
        AM_CA_CloseSession(recorder[dev_no].cas_session);
        recorder[dev_no].cas_session = 0;
        return -1;
    }

    return 0;
}

static int start_tse_recording(int dev_no, dvb_service_info_t *prog, char *tspath)
{
    DVR_WrapperRecordOpenParams_t rec_open_params;
    DVR_WrapperRecordStartParams_t rec_start_params;
    DVR_WrapperPidsInfo_t *pids_info;
    bool tse_mode = true;
    int tse_key_mode = -1;
    //char cmd[256];
    int error;

    AM_CA_ServiceInfo_t cas_para;
    CA_SERVICE_TYPE_t service_type = SERVICE_PVR_RECORDING;

    UNUSED(dev_no);
    DVR_WrapperRecord_t recorder_session = NULL;

    if (dev_no >= MAX_REC_NUM) {
        ERR("wrong device no %d\n", dev_no);
        return -1;
    }
    memset(&rec_open_params, 0, sizeof(DVR_WrapperRecordOpenParams_t));

    rec_open_params.dmx_dev_id = dev_no;
    rec_open_params.segment_size = 188 * 1024 * 1024;/*188MB*/
    rec_open_params.max_size = size;
    rec_open_params.max_time = duration;
    rec_open_params.event_fn = RecEventHandler;
    rec_open_params.event_userdata = "rec0";
    rec_open_params.flags = 0;
    rec_open_params.force_sysclock = true;
    rec_open_params.flush_size = 188 * 1024;

    if (is_timeshifting(mode)) {
        rec_open_params.flags |= DVR_RECORD_FLAG_ACCURATE;
        service_type = SERVICE_PVR_TIMESHIFT_RECORDING;
    }
    rec_open_params.flags |= DVR_RECORD_FLAG_INDEXED;

    strncpy(rec_open_params.location, tspath, sizeof(rec_open_params.location));
    rec_open_params.location[sizeof(rec_open_params.location)-1] = '\0';

    rec_open_params.is_timeshift = (is_timeshifting(mode)) ? DVR_TRUE : DVR_FALSE;

    if (prog->scrambled) {
        rec_open_params.flags |= DVR_RECORD_FLAG_EXT_TSEENC;
        rec_open_params.flags |= DVR_RECORD_FLAG_SCRAMBLED;
        rec_open_params.crypto_data = &recorder[dev_no].cas_session;
        rec_open_params.crypto_fn = encrypt_callback;
        if (dev_no == 0 || dev_no == 1) {
            rec_open_params.tse_dmx_dev_id = 4;
            rec_open_params.fta_dmx_dev_id = 5;
        } else if(dev_no == 2) {
            rec_open_params.tse_dmx_dev_id = 6;
            rec_open_params.fta_dmx_dev_id = 7;
        } else {
            ERR( "recorder open fail. don't support this dev = (0x%x)\n", dev_no);
            return -1;
        }
    }

    error = dvr_wrapper_open_record(&recorder_session, &rec_open_params);
    if (error) {
        ERR( "recorder open fail = (0x%x)\n", error);
        return -1;
    }
    recorder[dev_no].dvr_session = (void *)recorder_session;

    INF( "Starting %s recording %p [%ld secs/%llu bytes] [%s.ts]\n",
       (is_timeshifting(mode))? "timeshift" : "normal",
       recorder_session,
       rec_open_params.max_time,
       rec_open_params.max_size,
       rec_open_params.location);

    memset(&rec_start_params, 0, sizeof(rec_start_params));

    if (prog->scrambled) {
        void *buf = NULL;

        error = AM_CA_OpenSession(g_cas_handle, &recorder[dev_no].cas_session, service_type);
        if (error) {
            ERR("CAS open session failed. ret = %d\r\n", error);
            dvr_wrapper_close_record(recorder_session);
            return -1;
        }
        error = AM_CA_RegisterEventCallback(recorder[dev_no].cas_session, cas_event_cb);
        if (error) {
            ERR("CAS RegisterEventCallback failed. ret = %d\r\n", error);
        }

//        tse_mode = get_cas_mode(recorder[dev_no].cas_session);
//        INF("get_cas_mode return  tse_mode: %d\r\n", tse_mode);


        if (g_vm_config.run) {
            watermark_test_config(g_vm_config.on,
            g_vm_config.config,
            g_vm_config.strength);
        }

        if (g_oc_config.run) {
            output_control_test_config(g_oc_config.flag,
                           g_oc_config.analog,
                           g_oc_config.cgmsa,
                           g_oc_config.emicci);
        }

        INF("set AM_CA_SetEmmPid: %#x\n", prog->i_ca_pid);

        error = AM_CA_SetEmmPid(g_cas_handle, dev_no, prog->i_ca_pid);
        if (error) {
            ERR("CAS set emm PID failed. ret = %d\r\n", error);
            return -1;
        }

        memset(&cas_para, 0x0, sizeof(AM_CA_ServiceInfo_t));
        cas_para.dmx_dev = dev_no;
        cas_para.dvr_dev = rec_open_params.tse_dmx_dev_id;

        cas_para.service_id = prog->i_program_num;
        cas_para.service_type = service_type;
        cas_para.ecm_pid = prog->i_ecm_pid[0];
        cas_para.stream_pids[0] = prog->i_video_pid;
        cas_para.stream_pids[1] = prog->i_audio_pid;
        cas_para.stream_num = 2;
        if (prog->private_data[0]) {
            // parser algo from pmt, use for descramble
            memcpy(cas_para.ca_private_data, prog->private_data, prog->private_data[0]);
        }
        cas_para.ca_private_data_len = prog->private_data[0];

        INF("start_recording,i_program_num=%d,ca_private_data[0]=%d,[2]=0x%x,vpid=0x%x,apid=0x%x\n", prog->i_program_num,
            cas_para.ca_private_data[0], cas_para.ca_private_data[2], prog->i_video_pid, prog->i_audio_pid);

        if (prog->service_type == IPTV_TYPE) {
            cas_para.service_mode = SERVICE_IPTV;
            INF("IPTV service mode:%d\n", cas_para.service_mode);
        } else {
            cas_para.service_mode = SERVICE_DVB;
            INF("DVB service mode:%d\n", cas_para.service_mode);
        }
        error = AM_CA_DVRStart(recorder[dev_no].cas_session, &cas_para);
        if (error) {
            ERR("CAS start DVR failed. ret = %d\r\n", error);
            AM_CA_CloseSession(recorder[dev_no].cas_session);
            recorder[dev_no].cas_session = 0;
            dvr_wrapper_close_record(recorder_session);
            return -1;
        }
        if (true == tse_mode) {
            tse_key_mode = get_tse_key_mode(recorder[dev_no].cas_session);
            INF("get_tse_key_mode return tse_key_mode:%d\n", tse_key_mode);
            switch (tse_key_mode) {
            case 0:
            case 2:
                tse_key_mode = 2;
            break;
            case 1:
            case 3:
                tse_key_mode = 3;
            break;
            default:
                INF("invalid tse key mode = %d", tse_key_mode);
                dvr_wrapper_close_record(recorder_session);
                return -1;
            }
            error = dvr_wrapper_ioctl_record(recorder_session, DVR_RECORD_CMD_ENC_CHANGE_SCB , &tse_key_mode, sizeof(tse_key_mode));
            if (error) {
                INF("Set scb fail = (%#x)", error);
                dvr_wrapper_close_record(recorder_session);
                return -1;
            }
            g_tse_key_mode[dev_no] = tse_key_mode;
        }

    }

    pids_info = &rec_start_params.pids_info;
    pids_info->nb_pids = 2;
    pids_info->pids[0].pid = prog->i_video_pid;
    pids_info->pids[1].pid = prog->i_audio_pid;

    DVR_VideoFormat_t dvb_vfmt;
    if (!convert_video_codec_fmt_am2dvb(prog->i_vformat, &dvb_vfmt)) {
        ERR("can not convert am video codec type(%d) to dtv", prog->i_vformat);
    }
    pids_info->pids[0].type = DVR_STREAM_TYPE_VIDEO << 24 | dvb_vfmt;

    DVR_AudioFormat_t dvb_afmt;
    if (!convert_audio_codec_fmt_am2dvb(prog->i_aformat, &dvb_afmt)) {
        ERR("can not convert am audio codec type(%d) to dtv", prog->i_aformat);
    }
    pids_info->pids[1].type = DVR_STREAM_TYPE_AUDIO << 24 | dvb_afmt;
    if (prog->scrambled && true == tse_mode) {
        pids_info->pids[0].type |= 3 << 22;
        pids_info->pids[1].type |= 3 << 22;
    }

    error = dvr_wrapper_start_record(recorder_session, &rec_start_params);
    if (error)
    {
        ERR( "recorder start fail = (0x%x)\n", error);
        dvr_wrapper_close_record(recorder_session);
        if (recorder[dev_no].cas_session) {
            AM_CA_DVRStop(recorder[dev_no].cas_session);
            AM_CA_CloseSession(recorder[dev_no].cas_session);
        }
        recorder[dev_no].cas_session = 0;

        return -1;
    }
#if 1   /* test to not set scb. */
    if (prog->scrambled) {
        int * args = (int*)malloc(sizeof(int));
        *args = dev_no;
        pthread_create(&gScbUpdateThread[dev_no], NULL, scbUpdate_thread, args);
    }

#endif
    return 0;
}

static bool get_cas_mode(CasSession session)
{
    bool is_tse_mode = false;
    cJSON *input = NULL;
    cJSON *item = NULL;
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    if (session)
        AM_CA_Ioctl(session, IOCTRL_INVOKE_GET_CAS_MODE, out_json, MAX_JSON_LEN);
    //INF("%s, IOCTRL_INVOKE_GET_CAS_MODE:%s\n, out_json=%s\n", __func__, IOCTRL_INVOKE_GET_CAS_MODE, out_json);

    input = cJSON_Parse(out_json);
    item = cJSON_GetObjectItemCaseSensitive(input, ITEM_DVR_CAS_MODE);
    if (!cJSON_IsString(item) || item->valuestring[0] == '\0') {
        INF("Get cas mode failed, default r2r mode,is_tse_mode=%d\n",is_tse_mode);
    } else {
        if (strncmp(item->valuestring, "r2r", 3) == 0) {
            is_tse_mode = false;
        } else if (strncmp(item->valuestring, "tse", 3) == 0) {
            is_tse_mode = true;
        }
        //INF("%s: string: %s, is_tse_mode=%d\n", __func__, item->valuestring, is_tse_mode);
    }
    cJSON_Delete(input);
    return is_tse_mode;
}

static int set_cas_mode(uint8_t is_tse_mode)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    INF("set_cas_mode to tse: %d\n\n", is_tse_mode);

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_SET_CAS_MODE);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(is_tse_mode);
    cJSON_AddItemToObject(input, ITEM_DVR_CAS_MODE, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    AM_CA_Ioctl(0, in_json, out_json, MAX_JSON_LEN);
    INF("out_json:\n%s\n", out_json);

    return 0;
}

static int get_tse_key_mode(CasSession session)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';
    int tse_key_mode = -1;

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_GET_TSE_KEY_MODE);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);

    if (session)
        AM_CA_Ioctl(session, in_json, out_json, MAX_JSON_LEN);

    //INF("ITEM_GET_TSE_KEY_MODE,in_json:%s,out_json=%s\n", in_json, out_json);
    cJSON_Delete(input);

    input = cJSON_Parse(out_json);
    item = cJSON_GetObjectItemCaseSensitive(input, ITEM_TSE_KEY_MODE);

    //INF("get_tse_key_mode: item->type : %d, item->valueint: %d, item->valueint: %f, item->valuestring: %s\n", item->type, item->valueint, item->valuedouble, item->valuestring);

    tse_key_mode = item->valueint;
    cJSON_Delete(input);

    return tse_key_mode;
}

static int show_cardno(void)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_GETSCNO);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
    INF("show_cardno,in_json:%s,out_json=%s\n", in_json, out_json);
    cJSON_Delete(input);

    input = cJSON_Parse(out_json);
    item = cJSON_GetObjectItemCaseSensitive(input, ITEM_CARDNO);
    if (!cJSON_IsString(item) || item->valuestring[0] == '\0') {
        cJSON_Delete(input);
        INF("Get card no failed\n");
        return -1;
    }

    INF("cardno:%s\n", item->valuestring);
    cJSON_Delete(input);

    return 0;
}

static int show_boxid(void)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_GETBOXID);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
    cJSON_Delete(input);

    input = cJSON_Parse(out_json);
    item = cJSON_GetObjectItemCaseSensitive(input, ITEM_BOXID);
    if (!cJSON_IsString(item) || item->valuestring[0] == '\0') {
        cJSON_Delete(input);
        INF("Get box id failed\n");
        return -1;
    }

    INF("boxid:%s\n", item->valuestring);
    cJSON_Delete(input);

    return 0;
}

static int check_pin(char *pin, uint8_t pinIndex, uint8_t reason, uint8_t dvrChannel)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';
    CasSession cas_session;
    memset(&cas_session, 0, sizeof(CasSession));

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_CHECK_PIN);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateString(pin);
    cJSON_AddItemToObject(input, ITEM_PIN, item);
    item = cJSON_CreateNumber(pinIndex);
    cJSON_AddItemToObject(input, ITEM_PIN_INDEX, item);
    item = cJSON_CreateNumber(reason);
    cJSON_AddItemToObject(input, ITEM_REASON, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    INF("in_json:\n%s\n", in_json);
    if (dvrChannel == 0) {
        cas_session = recorder[0].cas_session;
    }else if (dvrChannel == 1) {
        cas_session = recorder[1].cas_session;
    }else {
        cas_session = play.cas_session;
    }
    if (cas_session) {
        AM_CA_Ioctl(cas_session, in_json, out_json, MAX_JSON_LEN);
        INF("out_json:\n%s\n", out_json);
    }

    return 0;
}

static int dvr_test_config(uint8_t algo)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_SET_ALGO);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(algo);
    cJSON_AddItemToObject(input, ITEM_ALGO, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    AM_CA_Ioctl(recorder[0].cas_session, in_json, out_json, MAX_JSON_LEN);
    INF("out_json:\n%s\n", out_json);

    return 0;
}

static int watermark_test_config(
    uint8_t on,
    uint8_t config,
    uint8_t strength)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    int i;
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_WATERMARK);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(on);
    cJSON_AddItemToObject(input, ITEM_ON, item);
    item = cJSON_CreateNumber(config);
    cJSON_AddItemToObject(input, ITEM_CONFIG, item);
    item = cJSON_CreateNumber(strength);
    cJSON_AddItemToObject(input, ITEM_STRENGTH, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    INF("in_json:\n%s\n", in_json);
    if (has_live(mode) && play.cas_session) {
        INF("has live\n");
        AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
    }
    for (i = 0; i < MAX_REC_NUM; i++) {
        if (recorder[i].cas_session) {
            INF("has recording%d\n", i);
            AM_CA_Ioctl(recorder[i].cas_session, in_json, out_json, MAX_JSON_LEN);
        }
    }
    INF("out_json:\n%s\n", out_json);

    return 0;
}

static int output_control_test_config(
    uint32_t flag,
    uint8_t analog,
    uint8_t cgmsa,
    uint8_t emicci)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    int i;
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_OUTPUT_CONTROL);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(flag);
    cJSON_AddItemToObject(input, ITEM_FLAG, item);
    item = cJSON_CreateNumber(analog);
    cJSON_AddItemToObject(input, ITEM_ANALOG, item);
    item = cJSON_CreateNumber(cgmsa);
    cJSON_AddItemToObject(input, ITEM_CGMSA, item);
    item = cJSON_CreateNumber(emicci);
    cJSON_AddItemToObject(input, ITEM_EMICCI, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    INF("in_json:\n%s\n", in_json);
    if (has_live(mode) && play.cas_session) {
        INF("has live\n");
        AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
    }
    for (i = 0; i < MAX_REC_NUM; i++) {
        if (recorder[i].cas_session) {
            INF("has recording%d\n", i);
            AM_CA_Ioctl(recorder[i].cas_session, in_json, out_json, MAX_JSON_LEN);
        }
    }
    INF("out_json:\n%s\n", out_json);

    return 0;
}

static int svp_test_config(size_t addr)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_SVP);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(addr);
    cJSON_AddItemToObject(input, ITEM_ADDR, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    INF("in_json:\n%s\n", in_json);
    if (has_live(mode)) {
        AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
        INF("out_json:\n%s\n", out_json);
    }

    return 0;
}

static int antirollback_test_config(uint8_t flag)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_ARB);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(flag);
    cJSON_AddItemToObject(input, ITEM_FLAG, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    INF("in_json:\n%s\n", in_json);
    if (has_live(mode)) {
        AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
        INF("out_json:\n%s\n", out_json);
    }

    return 0;
}

static int ta2ta_test_config(
    uint32_t clientid,
    const char *data,
    uint32_t len)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_TA2TA);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(clientid);
    cJSON_AddItemToObject(input, ITEM_CLIENTID, item);
    item = cJSON_CreateString(data);
    cJSON_AddItemToObject(input, ITEM_DATA, item);
    item = cJSON_CreateNumber(len);
    cJSON_AddItemToObject(input, ITEM_LEN, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    INF("in_json:\n%s\n", in_json);
    if (has_live(mode)) {
        AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
        INF("out_json:\n%s\n", out_json);
    }

    return 0;
}

static int hdcp_test_config(uint8_t svc_idx)
{
    cJSON *input = NULL;
    cJSON *item = NULL;
    char in_json[MAX_JSON_LEN];
    in_json[0] = '\0';
    char out_json[MAX_JSON_LEN];
    out_json[0] = '\0';

    input = cJSON_CreateObject();
    item = cJSON_CreateString(VMX_CAS_STRING);
    cJSON_AddItemToObject(input, ITEM_CAS, item);
    item = cJSON_CreateString(ITEM_HDCP);
    cJSON_AddItemToObject(input, ITEM_CMD, item);
    item = cJSON_CreateNumber(svc_idx);
    cJSON_AddItemToObject(input, ITEM_SERVICE_INDEX, item);

    cJSON_PrintPreallocated(input, in_json, MAX_JSON_LEN, 1);
    INF("in_json:\n%s\n", in_json);
    if (play.cas_session) {
        AM_CA_Ioctl(play.cas_session, in_json, out_json, MAX_JSON_LEN);
    }
    INF("out_json:\n%s\n", out_json);

    return 0;
}
static int stop_recording(int dev_no)
{
    int ret;
    CasSession cas_session = recorder[dev_no].cas_session;
    bool tse_mode = g_indexer;

    INF("stop_recording, dev_no=%d\n", dev_no);

    if (dev_no >= MAX_REC_NUM) {
      ERR("wrong device no %d\n", dev_no);
      return -1;
    }

    ret = dvr_wrapper_stop_record((DVR_WrapperRecord_t *)recorder[dev_no].dvr_session);
    ret |= dvr_wrapper_close_record((DVR_WrapperRecord_t *)recorder[dev_no].dvr_session);
    if (ret) {
        ERR("stop/close record failed:%d\n", ret);
        return -1;
    }
    if (cas_session) {
//        bool tse_mode = get_cas_mode(cas_session);
        AM_CA_DVRStop(cas_session);

        if (!tse_mode && !g_nosmp) {
            ret = AM_CA_DestroySecmem(cas_session, recorder[dev_no].secmem_session);
            if (ret) {
                ERR("destroy secmem failed:%d\n", ret);
                return -1;
            }
        }
        AM_CA_CloseSession(cas_session);
    }

    memset(&recorder[dev_no], 0, sizeof(CasTestSession));

    return 0;
}

static int stop_tse_recording(int dev_no)
{
    int ret;
    CasSession cas_session = recorder[dev_no].cas_session;

    INF("stop_tse_recording, dev_no=%d\n", dev_no);

    if (dev_no >= MAX_REC_NUM) {
      ERR("wrong device no %d\n", dev_no);
      return -1;
    }

    ret = dvr_wrapper_stop_record((DVR_WrapperRecord_t *)recorder[dev_no].dvr_session);
    ret |= dvr_wrapper_close_record((DVR_WrapperRecord_t *)recorder[dev_no].dvr_session);
    if (ret) {
        ERR("stop/close record failed:%d\n", ret);
        return -1;
    }
    if (cas_session) {
        AM_CA_DVRStop(cas_session);
        AM_CA_CloseSession(cas_session);
    }

    memset(&recorder[dev_no], 0, sizeof(CasTestSession));
    g_tse_key_mode[dev_no] = -1;

    return 0;
}


static int get_dvr_info(char *location, int *apid, int *afmt, int *vpid, int *vfmt)
{
    uint32_t segment_nb = 0;
    uint64_t *p_segment_ids = NULL;
    DVR_RecordSegmentInfo_t seg_info;
    int error;
    int aid = 0x1fff, vid = 0x1fff;
    int aft = 0, vft = 0;
    memset(&seg_info, 0, sizeof(DVR_RecordSegmentInfo_t));

    error = dvr_segment_get_list(location, &segment_nb, &p_segment_ids);
    if (!error && segment_nb) {
        error = dvr_segment_get_info(location, p_segment_ids[0], &seg_info);
        free(p_segment_ids);
    }
    if (!error) {
        int i;
        for (i = 0; i < seg_info.nb_pids; i++) {
            switch (DVR_STREAM_TYPE_TO_TYPE(seg_info.pids[i].type))
            {
            case DVR_STREAM_TYPE_VIDEO:
                vid = seg_info.pids[i].pid;
                vft = DVR_STREAM_TYPE_TO_FMT(seg_info.pids[i].type);
                INF("type(0x%x)[video] pid(0x%x) fmt(%d)\n",
                    DVR_STREAM_TYPE_TO_TYPE(seg_info.pids[i].type),
                    seg_info.pids[i].pid,
                    DVR_STREAM_TYPE_TO_FMT(seg_info.pids[i].type)
                    );
            break;
            case DVR_STREAM_TYPE_AUDIO:
                aid = seg_info.pids[i].pid;
                aft = DVR_STREAM_TYPE_TO_FMT(seg_info.pids[i].type);
                INF("type(0x%x)[audio] pid(0x%x) fmt(%d)\n",
                    DVR_STREAM_TYPE_TO_TYPE(seg_info.pids[i].type),
                    seg_info.pids[i].pid,
                    DVR_STREAM_TYPE_TO_FMT(seg_info.pids[i].type)
                    );
            break;
            default:
                INF("type(0x%x) pid(0x%x) fmt(%d)\n",
                    DVR_STREAM_TYPE_TO_TYPE(seg_info.pids[i].type),
                    seg_info.pids[i].pid,
                    DVR_STREAM_TYPE_TO_FMT(seg_info.pids[i].type)
                    );
            break;
            }
        }
    }

    if (apid)
        *apid = aid;
    if (afmt)
        *afmt = aft;
    if (vpid)
        *vpid = vid;
    if (vfmt)
        *vfmt = vft;

    return 0;
}

static int start_playback(void *params, int scrambled, int pause)
{
    DVR_WrapperPlayback_t player = NULL;
    DVR_PlaybackPids_t play_pids;
    DVR_WrapperPlaybackOpenParams_t play_params;
    am_tsplayer_handle tsplayer_handle = 0;
    int vpid = 1024, apid = 1025, vfmt = 0, afmt = 0;
    bool tse_mode = false;
    int error;

    void *sec_buf = NULL;
    uint32_t sec_buf_size = inject_length + 4*1024;
    CA_SERVICE_TYPE_t service_type = SERVICE_PVR_PLAY;
    INF("start_playback,0- sec_buf_size:%d\n", sec_buf_size);

    memset(&play_params, 0, sizeof(play_params));
    memset(&play_pids, 0, sizeof(play_pids));

    play_pids.video.type = DVR_STREAM_TYPE_VIDEO;
    play_pids.audio.type = DVR_STREAM_TYPE_AUDIO;

    if (is_timeshifting(mode)) {
        dvb_service_info_t *prog = (dvb_service_info_t *)params;
        strncpy(play_params.location, pfilename, sizeof(play_params.location));
        play_params.location[sizeof(play_params.location)-1] = '\0';
        play_params.is_timeshift = DVR_TRUE;
        play_params.dmx_dev_id = DMX_DEV_NO_2ND;

        vpid = prog->i_video_pid;
        DVR_VideoFormat_t dvb_vfmt;
        if (!convert_video_codec_fmt_am2dvb(prog->i_vformat, &dvb_vfmt)) {
            ERR("can not convert am video codec type(%d) to dtv", prog->i_vformat);
        }
        vfmt = dvb_vfmt;

        apid = prog->i_audio_pid;
        DVR_AudioFormat_t dvb_afmt;
        if (!convert_audio_codec_fmt_am2dvb(prog->i_aformat, &dvb_afmt)) {
            ERR("can not convert am audio codec type(%d) to dtv", prog->i_aformat);
        }
        afmt = dvb_afmt;

        service_type = SERVICE_PVR_TIMESHIFT_PLAY;
    } else {
        strncpy(play_params.location, params, sizeof(play_params.location));
        play_params.location[sizeof(play_params.location)-1] = '\0';
        play_params.is_timeshift = DVR_FALSE;
        play_params.dmx_dev_id = DMX_DEV_NO;
        get_dvr_info(params, &apid, &afmt, &vpid, &vfmt);

    }
    INF("vpid:%#x vfmt:%d apid:%#x afmt:%d\n", vpid, vfmt, apid, afmt);

    if (scrambled) {
        error = AM_CA_OpenSession(
            g_cas_handle,
            &play.cas_session,
            service_type);
        INF("%s open cas session:%#zx, start cas, return:%d\n",
            __func__, play.cas_session, error);
        if (error) {
            ERR("CAS open session failed. ret = %d\r\n", error);
            return -1;
        }
        AM_CA_RegisterEventCallback(play.cas_session, cas_event_cb);

        // dvr playback need set demux id to cas hal plugin
        AM_CA_PreParam_t preParam;
        preParam.dmx_dev = play_params.dmx_dev_id;
        AM_CA_DVRSetPreParam(play.cas_session, &preParam);

//        tse_mode = get_cas_mode(play.cas_session);

        if (!tse_mode && !g_nosmp) {
            play.secmem_session = AM_CA_CreateSecmem(
                    play.cas_session,
                    service_type,
                    &sec_buf,
                    &sec_buf_size);
            if (!play.secmem_session) {
                ERR("cas playback failed. secmem_session:%#zx\n", play.secmem_session);
            }
        }
    }

    play_pids.video.pid = vpid;
    play_pids.video.format = vfmt;
    play_pids.audio.pid = apid;
    play_pids.audio.format = afmt;

    play_params.event_fn = PlayEventHandler;
    play_params.event_userdata = "play0";

     /*open TsPlayer*/
    {
       uint32_t versionM = 0, versionL = 0;
       am_tsplayer_init_params init_param =
       {
          .source = TS_MEMORY,
          .dmx_dev_id = DMX_DEV_NO,
          .event_mask = 0,
               /*AM_TSPLAYER_EVENT_TYPE_PTS_MASK
             | AM_TSPLAYER_EVENT_TYPE_DTV_SUBTITLE_MASK
             | AM_TSPLAYER_EVENT_TYPE_USERDATA_AFD_MASK
             | AM_TSPLAYER_EVENT_TYPE_VIDEO_CHANGED_MASK
             | AM_TSPLAYER_EVENT_TYPE_AUDIO_CHANGED_MASK
             | AM_TSPLAYER_EVENT_TYPE_DATA_LOSS_MASK
             | AM_TSPLAYER_EVENT_TYPE_DATA_RESUME_MASK
             | AM_TSPLAYER_EVENT_TYPE_SCRAMBLING_MASK
             | AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME_MASK,*/
       };
       if (is_timeshifting(mode)) {
           init_param.dmx_dev_id = DMX_DEV_NO_2ND;
       }
       if (!tse_mode) {

           if (scrambled && !g_nosmp) {
               init_param.drmmode = TS_INPUT_BUFFER_TYPE_SECURE;
           }
       } else {
           if (scrambled) {
               init_param.drmmode = TS_INPUT_BUFFER_TYPE_TVP;
           }
       }
       am_tsplayer_result result =
          AmTsPlayer_create(init_param, &tsplayer_handle);
       INF( "open TsPlayer %s, result(%d)\n", (result)? "FAIL" : "OK", result);

       result = AmTsPlayer_setSurface(tsplayer_handle, (void *)&video_tunnel_id);
       INF( "set surface %s, result(%d)\n", (result)? "FAIL" : "OK", result);
       result = AmTsPlayer_getVersion(&versionM, &versionL);
       INF( "TsPlayer version(%d.%d) %s, result(%d)\n",
          versionM, versionL,
          (result)? "FAIL" : "OK",
          result);

       result = AmTsPlayer_registerCb(tsplayer_handle,
          tsplayer_callback,
          "tsp0");
       INF( " AmTsPlayer_registerCb %s, result(%d)\n", (result)? "FAIL" : "OK", result);

       if (!tse_mode && scrambled && !g_nosmp) {
           AmTsPlayer_setParams(tsplayer_handle, AM_TSPLAYER_KEY_VIDEO_SECLEVEL, &seclev);
           AmTsPlayer_setParams(tsplayer_handle, AM_TSPLAYER_KEY_AUDIO_SECLEVEL, &seclev);
           CA_DEBUG(1,"%s secure level: %#x\n ", __func__, seclev);
       }
       result = AmTsPlayer_setWorkMode(tsplayer_handle, TS_PLAYER_MODE_NORMAL);
       INF( " TsPlayer set Workmode NORMAL %s, result(%d)\n", (result)? "FAIL" : "OK", result);
       //result = AmTsPlayer_setSyncMode(tsplayer_handle, TS_SYNC_NOSYNC );
       //PLAY_DBG(" TsPlayer set Syncmode FREERUN %s, result(%d)", (result)? "FAIL" : "OK", result);
       result = AmTsPlayer_setSyncMode(tsplayer_handle, TS_SYNC_PCRMASTER );
       INF( " TsPlayer set Syncmode PCRMASTER %s, result(%d)\n", (result)? "FAIL" : "OK", result);
//       result = AmTsPlayer_setVideoWindow(tsplayer_handle, 0, 0, 1280, 720);

#ifdef ANDROID
       am_tsplayer_audio_patch_manage_mode audio_mode = AUDIO_PATCH_MANAGE_FORCE_ENABLE;
       result = AmTsPlayer_setParams(tsplayer_handle,
                AM_TSPLAYER_KEY_SET_AUDIO_PATCH_MANAGE_MODE,
                &audio_mode);
       INF( " TsPlayer set audio patch %s, result(%d)\n", (result)? "FAIL" : "OK", result);
#endif
       play_params.playback_handle = (Playback_DeviceHandle_t)tsplayer_handle;
       play.player_session = tsplayer_handle;
    }

    play.replayed = 0;
    if (scrambled) {
        play_params.crypto_fn = decrypt_block_callback;
        play_params.crypto_data = NULL;
    }
    play_params.block_size = block_size;
    play_params.control_speed_enable = true;
    error = dvr_wrapper_open_playback(&player, &play_params);
    if (!error)
    {
       //DVR_PlaybackFlag_t play_flag = (is_timeshifting(mode))? DVR_PLAYBACK_STARTED_PAUSEDLIVE : 0;
       DVR_PlaybackFlag_t play_flag = (pause)? DVR_PLAYBACK_STARTED_PAUSEDLIVE : 0;
       play.dvr_session = (void *)player;

       if (!tse_mode) {

           if (scrambled && !g_nosmp) {
               INF("cas playback set secure buffer:%p, secure buffer size:%#x\n",
                            sec_buf, sec_buf_size);
               dvr_wrapper_set_playback_secure_buffer(player, sec_buf, sec_buf_size);
           }
       }
       INF( "Starting playback\n");

       error = dvr_wrapper_start_playback(player, play_flag, &play_pids);
       if (error)
       {
          ERR( "Start play failed, error %d\n", error);
       }
     }

    return 0;
}

static int start_tse_playback(void *params, int scrambled, int pause)
{
    DVR_WrapperPlayback_t player = NULL;
    DVR_PlaybackPids_t play_pids;
    DVR_WrapperPlaybackOpenParams_t play_params;
    am_tsplayer_handle tsplayer_handle = 0;
    int vpid = 1024, apid = 1025, vfmt = 0, afmt = 0;
    int error;

    CA_SERVICE_TYPE_t service_type = SERVICE_PVR_PLAY;

    memset(&play_params, 0, sizeof(play_params));
    memset(&play_pids, 0, sizeof(play_pids));

    play_pids.video.type = DVR_STREAM_TYPE_VIDEO;
    play_pids.audio.type = DVR_STREAM_TYPE_AUDIO;

    if (is_timeshifting(mode)) {
        dvb_service_info_t *prog = (dvb_service_info_t *)params;
        strncpy(play_params.location, pfilename, sizeof(play_params.location));
        play_params.location[sizeof(play_params.location)-1] = '\0';
        play_params.is_timeshift = DVR_TRUE;
        play_params.dmx_dev_id = DMX_DEV_NO_2ND;

        vpid = prog->i_video_pid;
        DVR_VideoFormat_t dvb_vfmt;
        if (!convert_video_codec_fmt_am2dvb(prog->i_vformat, &dvb_vfmt)) {
            ERR("can not convert am video codec type(%d) to dtv", prog->i_vformat);
        }
        vfmt = dvb_vfmt;

        apid = prog->i_audio_pid;
        DVR_AudioFormat_t dvb_afmt;
        if (!convert_audio_codec_fmt_am2dvb(prog->i_aformat, &dvb_afmt)) {
            ERR("can not convert am audio codec type(%d) to dtv", prog->i_aformat);
        }
        afmt = dvb_afmt;

        service_type = SERVICE_PVR_TIMESHIFT_PLAY;
    } else {
        strncpy(play_params.location, params, sizeof(play_params.location));
        play_params.location[sizeof(play_params.location)-1] = '\0';
        play_params.is_timeshift = DVR_FALSE;
        play_params.dmx_dev_id = DMX_DEV_NO;
        get_dvr_info(params, &apid, &afmt, &vpid, &vfmt);

    }
    INF("vpid:%#x vfmt:%d apid:%#x afmt:%d\n", vpid, vfmt, apid, afmt);

    if (scrambled) {
        error = AM_CA_OpenSession(
            g_cas_handle,
            &play.cas_session,
            service_type);
        INF("%s open cas session:%#zx, start cas, return:%d\n",
            __func__, play.cas_session, error);
        if (error) {
            ERR("CAS open session failed. ret = %d\r\n", error);
            return -1;
        }
        AM_CA_RegisterEventCallback(play.cas_session, cas_event_cb);

        // dvr playback need set demux id to cas hal plugin
        AM_CA_PreParam_t preParam;
        preParam.dmx_dev = play_params.dmx_dev_id;
        preParam.stream_pids[0] = vpid;
        preParam.stream_pids[1] = apid;
        preParam.stream_num =2;
        AM_CA_DVRSetPreParam(play.cas_session, &preParam);
    }

    play_pids.video.pid = vpid;
    play_pids.video.format = vfmt;
    play_pids.audio.pid = apid;
    play_pids.audio.format = afmt;

    play_params.event_fn = PlayEventHandler;
    play_params.event_userdata = "play0";

     /*open TsPlayer*/
    {
       uint32_t versionM = 0, versionL = 0;
       am_tsplayer_init_params init_param =
       {
          .source = TS_MEMORY,
          .dmx_dev_id = DMX_DEV_NO,
          .event_mask = 0,
               /*AM_TSPLAYER_EVENT_TYPE_PTS_MASK
             | AM_TSPLAYER_EVENT_TYPE_DTV_SUBTITLE_MASK
             | AM_TSPLAYER_EVENT_TYPE_USERDATA_AFD_MASK
             | AM_TSPLAYER_EVENT_TYPE_VIDEO_CHANGED_MASK
             | AM_TSPLAYER_EVENT_TYPE_AUDIO_CHANGED_MASK
             | AM_TSPLAYER_EVENT_TYPE_DATA_LOSS_MASK
             | AM_TSPLAYER_EVENT_TYPE_DATA_RESUME_MASK
             | AM_TSPLAYER_EVENT_TYPE_SCRAMBLING_MASK
             | AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME_MASK,*/
       };
       if (is_timeshifting(mode)) {
           init_param.dmx_dev_id = DMX_DEV_NO_2ND;
       }

       if (scrambled) {
           init_param.drmmode = TS_INPUT_BUFFER_TYPE_TVP;
       }

       am_tsplayer_result result =
          AmTsPlayer_create(init_param, &tsplayer_handle);
       INF( "open TsPlayer %s, result(%d)\n", (result)? "FAIL" : "OK", result);

       result = AmTsPlayer_setSurface(tsplayer_handle, (void *)&video_tunnel_id);
       INF( "set surface %s, result(%d)\n", (result)? "FAIL" : "OK", result);
       result = AmTsPlayer_getVersion(&versionM, &versionL);
       INF( "TsPlayer version(%d.%d) %s, result(%d)\n",
          versionM, versionL,
          (result)? "FAIL" : "OK",
          result);

       result = AmTsPlayer_registerCb(tsplayer_handle,
          tsplayer_callback,
          "tsp0");
       INF( " AmTsPlayer_registerCb %s, result(%d)\n", (result)? "FAIL" : "OK", result);

       result = AmTsPlayer_setWorkMode(tsplayer_handle, TS_PLAYER_MODE_NORMAL);
       INF( " TsPlayer set Workmode NORMAL %s, result(%d)\n", (result)? "FAIL" : "OK", result);
       if (scrambled) {
           AmTsPlayer_setParams(tsplayer_handle, AM_TSPLAYER_KEY_VIDEO_SECLEVEL, &seclev);
           AmTsPlayer_setParams(tsplayer_handle, AM_TSPLAYER_KEY_AUDIO_SECLEVEL, &seclev);
           INF( "%s secure level: %#x\n ", __func__, seclev);
           CA_DEBUG(1,"%s secure level: %#x\n ", __func__, seclev);
       }
       result = AmTsPlayer_setSyncMode(tsplayer_handle, TS_SYNC_PCRMASTER );
       INF( " TsPlayer set Syncmode PCRMASTER %s, result(%d)\n", (result)? "FAIL" : "OK", result);

#ifdef ANDROID
       am_tsplayer_audio_patch_manage_mode audio_mode = AUDIO_PATCH_MANAGE_FORCE_ENABLE;
       result = AmTsPlayer_setParams(tsplayer_handle,
                AM_TSPLAYER_KEY_SET_AUDIO_PATCH_MANAGE_MODE,
                &audio_mode);
       INF( " TsPlayer set audio patch %s, result(%d)\n", (result)? "FAIL" : "OK", result);
#endif
       play_params.playback_handle = (Playback_DeviceHandle_t)tsplayer_handle;
       play.player_session = tsplayer_handle;
    }

    play.replayed = 0;
    if (scrambled) {
        play_params.crypto_fn = decrypt_tse_callback;
        play_params.crypto_data = NULL;
    }
    play_params.block_size = block_size;
    play_params.control_speed_enable = true;
    error = dvr_wrapper_open_playback(&player, &play_params);
    if (!error)
    {
       //DVR_PlaybackFlag_t play_flag = (is_timeshifting(mode))? DVR_PLAYBACK_STARTED_PAUSEDLIVE : 0;
       DVR_PlaybackFlag_t play_flag = (pause)? DVR_PLAYBACK_STARTED_PAUSEDLIVE : 0;
       play_flag = play_flag | DVR_PLAYBACK_FLAG_INDEXED;
       play.dvr_session = (void *)player;

       INF( "Starting playback\n");

       error = dvr_wrapper_start_playback(player, play_flag, &play_pids);
       if (error)
       {
          ERR( "Start play failed, error %d\n", error);
       }
     }

    return 0;
}

static int pause_playback(void)
{
    int error = 0;

    if (play.dvr_session) {
        error = dvr_wrapper_pause_playback(play.dvr_session);
    }

    INF("pause = (%d)\n", error);
    return error;
}

static int resume_playback(void)
{
    int error = 0;

    if (play.dvr_session) {
        error = dvr_wrapper_resume_playback(play.dvr_session);
    }

    INF("resume = (%d)\n", error);
    return error;
}

static int fast_playback(float speed)
{
    int error = 0;

    if (play.dvr_session) {
        error = dvr_wrapper_set_playback_speed(play.dvr_session, speed);
    }

    INF("fast_speed %f = (%d)\n", speed, error);
    return error;
}

static int seek_playback(int time)
{
    int error = 0;

    if (play.dvr_session) {
        error = dvr_wrapper_seek_playback(play.dvr_session, time);
    }

    INF("see %d = (%d)\n", time, error);
    return error;
}

static int stop_playback(void)
{
    INF("stop_playback ==\n");
    dvr_wrapper_stop_playback((DVR_WrapperPlayback_t *)play.dvr_session);
    if (play.cas_session) {
        bool tse_mode = g_indexer;
        AM_CA_DVRStopReplay(play.cas_session);

        if (!tse_mode && !g_nosmp) {
            AM_CA_DestroySecmem(play.cas_session, play.secmem_session);
        }
        AM_CA_CloseSession(play.cas_session);
    }
    //AmTsPlayer_stopAudioDecoding(play.player_session);
    //AmTsPlayer_stopVideoDecoding(play.player_session);
    dvr_wrapper_close_playback((DVR_WrapperPlayback_t *)play.dvr_session);
    AmTsPlayer_release(play.player_session);

    return 0;
}

static void usage(int argc, char *argv[])
{
    UNUSED(argc);

    INF("Usage: live      : %s live <fend_dev_no> <input_dev_no> <prog_idx> <freqM> <isIPTV> <sym>\n", argv[0]);
    INF("Usage: local     : %s local <tsfile> <prog_idx>\n", argv[0]);
    INF("Usage: playback  : %s dvrplay <tsfile> <scramble_flag>\n", argv[0]);
    INF("Usage: NOSMP=1   : S1A part don't use smp feature. need export it.\n");
    INF("Usage: INDEXER=1 : Use Indexr mode in DVR.\n");
}

static int cas_test_term(void)
{
    INF("\n\n cas_test_term, mode=0x%x,has_live=%d, has_recording=%d,has_playback=%d\n",
        mode, has_live(mode), has_recording(mode), has_playback(mode));

    if (has_live(mode)) {
        close_fend(g_frontend_id);
        stop_liveplay();
    }

    if (has_live_local(mode)) {
        gInjectRunning = 0;
        pthread_join(gInjectThread, NULL);
        stop_liveplay();
    }

    if (has_recording(mode)) {
        int i;
        INF("%s,rec_status=0x%x\n", __func__, rec_status);
        for (i = 0; i < MAX_REC_NUM; i++) {
            if (rec_status & (1 << i)) {
                stop_recording(i);
            }
        }
    }

    if (is_ext_playback(mode)) {
        ext_dvr_playback_stop();
    } else if (has_playback(mode)) {
        stop_playback();
    }

    if (g_cas_handle) {
        AM_CA_Term(g_cas_handle);
    }
#ifdef ANDROID
    property_set("vendor.amtsplayer.pipeline", "1");
    property_set("vendor.dtv.audio.skipamadec", "true");
#endif

    amsysfs_set_sysfs_str(TSN_PATH, TSN_DVB);

    return 0;
}

int amsysfs_set_sysfs_str(const char *path, const char *val) {
    int fd;
    int bytes;
    fd = open(path, O_CREAT | O_RDWR | O_TRUNC, 0644);
    if (fd >= 0) {
        bytes = write(fd, val, strlen(val));
        close(fd);
        return 0;
    }  else {
        INF("open path:%s failed, err:%s", path, strerror(errno));
        return -1;
    }
}


static void handle_signal(int signal)
{
    UNUSED(signal);
    cas_test_term();
    exit(0);
}

static void init_signal_handler()
{
    struct sigaction act;
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_handler = handle_signal;
    sigaction(SIGINT, &act, NULL);
}

int main(int argc, char *argv[])
{
    int ret;
    char cmd[256];
    char tspath[256] = {0};
    int dvr_dev_no = 0;
    int fend_dev_no = 0;
    int sym = 5217;
    int input_dev_no = 0;
    int prog_idx = 0;
    int scrambled = 1;
    int freqM = 394;
    int isIPTV = 0;
    dvb_service_info_t *prog = NULL;

    char *secdvr = getenv("SECDVR");
    int secure_dvr = 0;

    char *nosmp = getenv("NOSMP");
    g_nosmp = 0;

    char *indexer = getenv("INDEXER");
    g_indexer = 0;

    if (secdvr) {
        secure_dvr = atoi(secdvr);
        if (secure_dvr) {
            INF("enable secure dvr for FTA stream\n");
        }
    }

    if (nosmp) {
        g_nosmp = atoi(nosmp);
        if (g_nosmp) {
            INF("Env command config No smp part such as S1A T6d etc.\n");
            pfilename = "/mnt/pvrdisk/timeshifting.ts";
        }
    }
    else {
#ifdef NOSMP_SUPPORTED
        g_nosmp = 1;
        INF("No smp part is found such as S1A T6d etc.\n");
#endif
    }


    if (indexer) {
        g_indexer = atoi(indexer);
        if (g_indexer) {
            INF("enable indexer mode\n");
        }
    }

    if (argc < 3) {
        usage(argc, argv);
        exit(0);
    }

    init_signal_handler();

    memset(&play, 0, sizeof(CasTestSession));
    memset(recorder, 0, sizeof(CasTestSession)*MAX_REC_NUM);
    amsysfs_set_sysfs_str(TSN_PATH, TSN_DVB);

    char axis_buf[40];
    sprintf(axis_buf, "%d %d %d %d", 0, 0, 0, 0);
    amsysfs_set_sysfs_str(VIDEO_AXIS_PATH, axis_buf);

    if (strcmp(argv[1], "live") == 0) {
        mode = LIVE;
        sscanf(argv[2], "%d", &fend_dev_no);
        if (argc > 3) {
            sscanf(argv[3], "%d", &input_dev_no);
        }
        if (argc > 4) {
            sscanf(argv[4], "%d", &prog_idx);
        }
        if (argc > 5) {
            sscanf(argv[5], "%d", &freqM);
        }
        if (argc > 6) {
            sscanf(argv[6], "%d", &isIPTV);
        }
        if (argc > 7) {
            sscanf(argv[7], "%d", &sym);
        }
    } else if (strcmp(argv[1], "local") == 0) {
        mode = LIVE_LOCAL;
        strncpy(tspath, argv[2],256);
        tspath[255] = '\0';
        sscanf(argv[3], "%d", &prog_idx);
        amsysfs_set_sysfs_str(TSN_PATH, TSN_IPTV);
    } else if (strcmp(argv[1], "dvrrecord") == 0) {
        strncpy(tspath, argv[2],256);
        tspath[255] = '\0';
        mode = RECORDING;
    } else if (strcmp(argv[1], "dvrplay") == 0) {
        int ret;
        struct stat buf;

        strncpy(tspath, argv[2],256);
        tspath[255] = '\0';
        if (argc > 3) {
            sscanf(argv[3], "%d", &scrambled);
        }

        amsysfs_set_sysfs_str(TSN_PATH, TSN_IPTV);

        ret = stat(tspath, &buf);
        INF("@@@in dvrplay argc=%d, argv[3]=%s scrambled=%d,ret =%d,errno=%d\n",
            argc, argv[3], scrambled, ret, errno);
        if (ret == -1 && errno == ENOENT) {
            //aml dvr file path
            mode = PLAYBACK;
        } else {
            //external dvr file path
            mode = EXT_PLAYBACK;
        }
    } else {
        usage(argc, argv);
        exit(0);
    }

    INF("@@@in cas_hal_test mode = 0x%x\n", mode);


    if (0 == dvr_check_dmx_isNew())
    {
            sprintf(cmd, "echo 1 > /sys/class/stb/demux_reset_all_flag");
            system(cmd);
            inject_length = X2_INJECT_LENGTH;
            block_size = X2_BLOCK_SIZE;
    }

    ret = dvb_init();
    set_cas_mode(g_indexer);

    int max_try = 5;
    if (!ret) {
        while (max_try-- > 0) {
            if (!show_cardno()) {
                break;
            }
            sleep(1);
        };
    }

    if (is_live(mode) || is_live_local(mode)) {
        if (is_live(mode)) {
            DVB_DemuxSource_t dmx_src;
            dmx_src = DVB_DEMUX_SOURCE_TS0_1 + input_dev_no;
            if (dmx_src > DVB_DEMUX_SOURCE_TS7_1) {
                dmx_src = DVB_DEMUX_SOURCE_TS0_1;
            }
            dvb_set_demux_source(DMX_DEV_NO, dmx_src);

            ret = fend_lock(fend_dev_no, freqM, sym);
            if (ret) {
                INF("@@@fend_lock failed and exit with %d\n", ret);
                cas_test_term();
                exit(0);
            }
        } else {
            dvb_service_info_t prog;

            dvb_set_demux_source(DMX_DEV_NO, DVB_DEMUX_SOURCE_DMA0);
            memset(&prog, 0, sizeof(prog));
#if 0
            prog.i_video_pid = 0x22;
            prog.i_vformat = 2;
            prog.i_audio_pid = 0x21;
            prog.i_aformat = 2;
#else
            prog.i_video_pid = 0x1fff;
            prog.i_audio_pid = 0x1fff;
#endif
            init_tsplayer_inject(&prog);
            gInjectRunning = 1;
            pthread_create(&gInjectThread, NULL, inject_thread, &tspath[0]);
        }

        int pmt_num = aml_scan();

        INF("%d programs scanned\r\n", pmt_num);

        if (is_live_local(mode)) {
            gInjectRunning = 0;
            pthread_join(gInjectThread, NULL);
            stop_liveplay();
        }

        gInjectRunning = 0;
        prog = aml_get_program(prog_idx);
        INF("try to play program:%d handle:%#zx, secure_dvr=%d,prog->scrambled=%d\r\n",
            prog_idx, (size_t)prog, secure_dvr, prog->scrambled);
        if (prog && is_live(mode)) {
            if (secure_dvr) {
                prog->scrambled = 1;
            }
            if (isIPTV) {
                prog->service_type = IPTV_TYPE;
            } else {
                prog->service_type = DVB_TYPE;
            }
            start_descrambling(prog);
            start_liveplay(prog);
        } else if (prog && is_live_local(mode)) {
            start_descrambling(prog);
            init_tsplayer_inject(prog);
            gInjectRunning = 1;
            pthread_create(&gInjectThread, NULL, inject_thread, &tspath[0]);
        }
#if 0 //for test pattern
        else {
            dvb_service_info_t prog;

            prog.i_audio_pid = 0x1fff;
            prog.i_video_pid = 0x80;
            prog.i_vformat = 2;
            start_liveplay(&prog);
            start_descrambling(&prog);
            INF("invalid prog_idx:%x \r\n", prog_idx);
        }
#endif
    } else if (is_playback(mode)) {
        INF("try to play file:%s scrambled:%d pause:0\r\n",
            tspath, scrambled);

        dvb_set_demux_source(DMX_DEV_NO, DVB_DEMUX_SOURCE_DMA0);
        if (g_indexer) {
            ret = start_tse_playback(tspath, scrambled, 0);
            } else {
            ret = start_playback(tspath, scrambled, 0);
            }
        if (ret) {
            INF("@@@start_playback failed and exit with %d\n", ret);
            cas_test_term();
            exit(0);
        }
    } else if (is_ext_playback(mode)) {
        INF("try to play file:%s\r\n", tspath);
        dvb_set_demux_source(DMX_DEV_NO, DVB_DEMUX_SOURCE_DMA0);
        ret = ext_dvr_playback(tspath, g_cas_handle);
        if (ret) {
            INF("@@@ext_dvr_playback failed and exit with %d\n", ret);
            cas_test_term();
            exit(0);
        }

    }

    sprintf(cmd, "mount -t debugfs debugfs /sys/kernel/debug");
    system(cmd);
    sprintf(cmd, "echo 1 > /sys/kernel/debug/dri/0/vpu/blank");
    system(cmd);



    sprintf(cmd, "echo 1 > /sys/class/graphics/fb0/osd_display_debug");
    system(cmd);
    sprintf(cmd, "echo 1 > /sys/class/graphics/fb0/blank");
    system(cmd);
    sprintf(cmd, "echo 1 > /sys/class/graphics/fb1/blank");
    system(cmd);

    sprintf(cmd, " echo 1 > /sys/kernel/debug/dri/0/vpu/blank");
    system(cmd);

    sprintf(cmd, "echo 0 2 > /sys/class/video/path_select");
    system(cmd);
    sprintf(cmd, "echo 1 > /sys/class/video/video_global_output");
    system(cmd);
    sprintf(cmd, "echo 0 > /sys/class/video/disable_video");
    system(cmd);


    while ( running ) {
        char buf[256];
        memset( buf, 0 , 256 );

        INF( "********************\n" );
        INF( "* commands:\n" );
        INF( "* dvrrecord <dvr_dev_no> <prog_idx> <tspath> <algono> <isIPTV>\n" );
        INF( "*           //algono: choose differ algo,\n" );
        INF( "* dvrstop <dvr_dev_no>   // dvrrecord stop\n" );
        INF( "* zap <prog_idx>         //zap live channel\n" );
        INF( "* tsstart <algono>       // from live enter timeshift\n" );
        INF( "*           //algono: choose differ algo,\n" );
        INF( "* tsstop     // timeshift stop, enter live\n" );
        INF( "* oc <value> [<AnalogProtection> <Cgmsa> <Emicci>]\n");
        INF( "* pin <pin> <pinIdx> <reason> <dvr_dev_no>\n");
        INF( "* wm <on> <config> <strength>\n");
        INF( "* hdcp <svc_idx>\n");
        INF( "* ta2ta <client id> <ascii input data>\n");
        INF( "* arb <0>/<1>\n");
        INF( "* quit\n" );
        INF( "********************\n" );

        if (fgets(buf, 256, stdin)) {
            if (!strncmp(buf, "quit", 4)) {
                running = 0;
            } else if (!strncmp(buf, "stop", 4)) {
                stop_liveplay();
            } else if (!strncmp(buf, "zap", 3)) {
                int prog_idx;

                ret = sscanf(buf, "zap %d", &prog_idx);
                if (ret >= 1) {
                    if (has_live(mode)) {
                        prog = aml_get_program(prog_idx);
                        if (prog) {
                            stop_liveplay();
                            start_descrambling(prog);
                            start_liveplay(prog);
                        }
                    }
                }

            } else if (!strncmp(buf, "dvrrecord", 9)) {
                int prog_idx;
                uint8_t algo;
                DVB_DemuxSource_t dmx_src;

                INF("dvrrecord buf=%s\r\n", buf);

                isIPTV = 0;
                ret = sscanf(buf, "dvrrecord %d %d %255s %hhu %d", &dvr_dev_no,
                     &prog_idx, &tspath[0], &algo, &isIPTV);
                INF("dvrrecord dvr_dev_no:%d,%d,%s,0x%x, %d\r\n",
                    dvr_dev_no, prog_idx, tspath, algo, isIPTV);
                if (dvr_dev_no >= MAX_REC_NUM || dvr_dev_no < 0) {
                    INF("dvrrecord dvr_dev_no is not correct value!\r\n");
                    continue;
                }

                if (ret >= 4) {
                    dvr_test_config(algo);
                }
                if (ret >= 3) {
#if 0
                    if (mode & RECORDING) {
                        ERR("DVR already start, please stop dvr first\r\n");
                        continue;
                    }
                    if (dvr_dev_no != 0) {
                        ERR("Now, must use DVR device0\r\n");
                        continue;
                    }
#endif
                    prog = aml_get_program(prog_idx);
                    INF("try to record program:%d handle:%#zx\r\n", prog_idx, (size_t)prog);
                    if (prog) {
                        if (isIPTV) {
                            prog->service_type = IPTV_TYPE;
                        } else {
                            prog->service_type = DVB_TYPE;
                        }

                        if (secure_dvr) {
                            prog->scrambled = 1;
                        }
                        //TODO: change source according by CAS encryption mode. M2M or TSE
                        dmx_src = DVB_DEMUX_SOURCE_TS0_1 + input_dev_no;
                        if (dmx_src > DVB_DEMUX_SOURCE_TS7_1) {
                            dmx_src = DVB_DEMUX_SOURCE_TS0_1;
                        }

                        //if (prog->scrambled) {
                        //    dvr_dev_no = dvr_dev_no + 1;
                        //}
                        INF("try to record prog->scrambled=%d,dvr_dev_no=%d, dmx_src=%d\r\n",
                            prog->scrambled, dvr_dev_no, dmx_src);
                        dvb_set_demux_source(dvr_dev_no, dmx_src);
                        if (g_indexer) {
                            ret = start_tse_recording(dvr_dev_no, prog, tspath);
                        } else {
                            ret = start_recording(dvr_dev_no, prog, tspath);
                        }
                        if (!ret) {
                            mode |= RECORDING;
                            rec_status |= (1 << dvr_dev_no);
                            INF("recording%d started\n", dvr_dev_no);
                        } else {
                            ERR("start recording failed. ret:%d\r\n", ret);
                        }
                    } else {
                        ERR("invalid prog_idx:%x \r\n", prog_idx);
                    }
                }
            } else if (!strncmp(buf, "dvrstop", 7)) {
                ret = sscanf(buf, "dvrstop %d", &dvr_dev_no);
                if (ret != 1)
                {
                    ERR("wrong input, cmd: dvrstop dvr_dev_no");
                    continue;
                }
                if (dvr_dev_no >= MAX_REC_NUM || dvr_dev_no < 0) {
                    INF("dvrrecord dvr_dev_no is not correct value!\r\n");
                    continue;
                }
                rec_status &= ~(1 << dvr_dev_no);
                if (rec_status == 0) {
                    mode &= ~RECORDING;
                }

                if (g_indexer) {
                    ret = stop_tse_recording(dvr_dev_no);
                }else {
                    ret = stop_recording(dvr_dev_no);
                }
                if (!ret) {
                    INF("recording%d stopped\n", dvr_dev_no);
                } else {
                    INF("recording%d stop failed:%d\n", dvr_dev_no, ret);
                }
            } else if (!strncmp(buf, "tsstart", 7)) {
                if (has_recording(mode)) {
                    ERR("DVR already start, please stop dvr first\n");
                    continue;
                }
                if (is_live(mode)) {
                    uint8_t algo;
                    stop_liveplay();

                    mode = TIMESHIFTING;
                    strncpy(tspath, pfilename,256);
                    tspath[255] = '\0';
                    ret = sscanf(buf, "tsstart %hhu", &algo);
                    if (ret >= 1) {
                       dvr_test_config(algo);
                    }

                    dvb_set_demux_source(DMX_DEV_NO, DVB_DEMUX_SOURCE_TS0 + input_dev_no);
                    if (g_indexer) {
                        ret = start_tse_recording(DVR_DEV_NO, prog, tspath);
                    } else {
                        ret = start_recording(DVR_DEV_NO, prog, tspath);
                    }

                    if (!ret) {
                        rec_status |= (1 << DVR_DEV_NO);
                        INF("recording-%d started\n", DVR_DEV_NO);
                    } else {
                        INF("recording-%d failed. return.\n", DVR_DEV_NO);
                        rec_status &= (1 << DVR_DEV_NO);
                        stop_playback();
                        if (g_indexer) {
                            ret = stop_tse_recording(DVR_DEV_NO);
                        }else {
                            ret = stop_recording(DVR_DEV_NO);
                        }
                        INF("recording%d stopped, ret: %d\n", DVR_DEV_NO,ret);
                        mode = LIVE;
                        dvb_set_demux_source(DMX_DEV_NO, DVB_DEMUX_SOURCE_TS0_1 + input_dev_no);
                        start_descrambling(prog);
                        start_liveplay(prog);
                        continue;
                    }


                    INF("timeshift%d before play\n", dvr_dev_no);
                    //amsysfs_set_sysfs_str(TSN_PATH, TSN_IPTV);
                    usleep(2000000);
                    INF("timeshift%d begin play\n", dvr_dev_no);

                    dvb_set_demux_source(DMX_DEV_NO_2ND, DVB_DEMUX_SOURCE_DMA1);
                    if (g_indexer) {
                        ret = start_tse_playback(prog, prog->scrambled, 0);
                    } else {
                        ret = start_playback(prog, prog->scrambled, 0);
                    }
                    if (ret) {
                        INF("@@@start_playback failed and exit with %d\n", ret);
                        rec_status &= (1 << DVR_DEV_NO);
                        stop_playback();
                        if (g_indexer) {
                            ret = stop_tse_recording(DVR_DEV_NO);
                        }else {
                            ret = stop_recording(DVR_DEV_NO);
                        }
                        INF("recording%d stopped, ret: %d\n", DVR_DEV_NO,ret);
                        mode = LIVE;
                        dvb_set_demux_source(DMX_DEV_NO, DVB_DEMUX_SOURCE_TS0_1 + input_dev_no);
                        start_descrambling(prog);
                        start_liveplay(prog);
                        continue;
                    }


                } else {
                    ERR("Not in live only mode, cannot enter timeshift\n");
                }
            } else if (!strncmp(buf, "tsstop", 6)) {
                if (is_timeshifting(mode)) {

                    rec_status &= (1 << DVR_DEV_NO);
                    stop_playback();
                    if (g_indexer) {
                        ret = stop_tse_recording(DVR_DEV_NO);
                    }else {
                        ret = stop_recording(DVR_DEV_NO);
                    }
                    INF("recording%d stopped, ret: %d\n", DVR_DEV_NO,ret);
                    mode = LIVE;
                    dvb_set_demux_source(DMX_DEV_NO, DVB_DEMUX_SOURCE_TS0_1 + input_dev_no);
                    start_descrambling(prog);
                    start_liveplay(prog);
                } else {
                    ERR("Not in timeshifint mode\n");
                }
            } else if (!strncmp(buf, "pause", 5)) {
                INF("pause, has_playback(mode=%d)=%d\n", mode, has_playback(mode));
                if (has_playback(mode)) {
                    pause_playback();
                }
            } else if (!strncmp(buf, "resume", 6)) {
                if (has_playback(mode)) {
                    resume_playback();
                }
            } else if (!strncmp(buf, "fast", 4)) {
                if (has_playback(mode)) {
                    float speed = 100;
                    ret = sscanf(buf, "fast %f ", &speed);
                    if (ret >= 1) {
                        fast_playback(speed);
                    }
                }
            }  else if (!strncmp(buf, "seek", 4)) {
                if (has_playback(mode)) {
                    int time = 0;
                    ret = sscanf(buf, "seek %d ", &time);
                    if (ret >= 1) {
                        seek_playback(time);
                    }
                }
            } else if (!strncmp(buf, "cardno", 6)) {
                show_cardno();
            } else if (!strncmp(buf, "boxid", 5)) {
                show_boxid();
            } else if (!strncmp(buf, "wm", 2)) {
                uint8_t on = 0, config = 0, strength = 0;
                ret = sscanf(buf, "wm %hhu %hhu %hhu", &on, &config, &strength);
                if (ret >= 1) {
                    g_vm_config.run = 1;
                    g_vm_config.on = on;
                    g_vm_config.config = config;
                    g_vm_config.strength = strength;
                    watermark_test_config(on, config, strength);
                }
            } else if (!strncmp(buf, "oc", 2)) {
                uint32_t flag = 0;
                uint8_t analog = 0, cgmsa = 0, emicci = 0;
                ret = sscanf(buf, "oc %u %hhu %hhu %hhu", &flag, &analog, &cgmsa, &emicci);
                if (ret >= 1) {
                    g_oc_config.run = 1;
                    g_oc_config.flag = flag;
                    g_oc_config.analog = analog;
                    g_oc_config.cgmsa = cgmsa;
                    g_oc_config.emicci = emicci;
                    output_control_test_config(flag, analog, cgmsa, emicci);
                }
            } else if (!strncmp(buf, "pin", 3)) {
                uint8_t pinIndex, reason, dvrChannel;
                char pin[64];

                dvrChannel = 255;
                ret = sscanf(buf, "pin %s %hhu %hhu %hhu", pin, &pinIndex, &reason, &dvrChannel);
                if (ret >= 3) {
                    check_pin(pin, pinIndex, reason, dvrChannel);
                }
            } else if (!strncmp(buf, "svp", 3)) {
                size_t addr;
                ret = sscanf(buf, "svp 0x%x", &addr);
                if (ret == 1) {
                    svp_test_config(addr);
                }
            } else if (!strncmp(buf, "arb", 3)) {
                uint8_t flag;
                ret = sscanf(buf, "arb %hhu", &flag);
                if (ret == 1) {
                    antirollback_test_config(flag);
                }
            } else if (!strncmp(buf, "ta2ta", 5)) {
                char *data = (char*)malloc(2048);
                if (data == NULL) {
                    ERR("malloc error!\n");
                    continue;
                }
                uint32_t len = 0;
                uint32_t clientid;
                uint32_t i;

                if (buf[5] != '\0' && buf[6] != '\0' && buf[7] != '\0' && buf[8]!= '\0') {
                    sscanf(buf, "ta2ta %u", &clientid);
                    strncpy(data, buf + 8, 2048);
                    data[2047] = '\0';
                    len = strlen(data);
                    INF("sending len=%u data=", len);
                    for (i = 0; i < len &&  i < 256; i++) {
                        INF("%02x ", data[i]);
                    }
                    INF("\n");
                    ta2ta_test_config(clientid, data, len);
                    INF("received data=");
                    for (i = 0; i < len &&  i < 256; i++) {
                        INF("%02x ", data[i]);
                    }
                    INF("\n");
                }
                if (data)
                    free(data);
            } else if (!strncmp(buf, "hdcp", 4)) {
                uint8_t svc_idx = 0;
                sscanf(buf, "hdcp %hhu", &svc_idx);
                hdcp_test_config(svc_idx);
            }
        }
    };

    cas_test_term();
    exit(0);
}