3086 lines
99 KiB
C
3086 lines
99 KiB
C
/**
|
||
* \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(¶m, 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);
|
||
}
|
||
|