📄 rdcp.c
字号:
}
if(i!=6){ // incorrect password
gv_reason_code = RDCP_ERR_INVALID_PASSWD;
return 3;
}
// check firmware state
rdcp_open_all();
return 0;
}
//###############################################################################
//
//###############################################################################
static u8 Proc_Close_Request(void)
{
return 0;
}
//###############################################################################
// Tx payload : vy_dvr_info_basic (20 bytes)
//###############################################################################
static u8 Proc_Get_Info_Request(void)
{
// prepare information
gv_txbuf[3] = MODEL_NUMBER;
gv_txbuf[4] = FW_MJ_VER;
gv_txbuf[5] = FW_MN_VER;
gv_txbuf[6] = EPROM_SetUp_data_Read(EPROM_EACH_QUAD);
gv_txbuf[7] = EPROM_SetUp_data_Read(EPROM_CAMERA_OF_SET);
gv_txbuf[8] = EPROM_SetUp_data_Read(EPROM_CAMERA_OF_RECORD);
gv_txbuf[9] = EPROM_SetUp_data_Read(EPROM_VIDIO_QUALITY);
gv_txbuf[10] = gv_NTSC_PAL; // 0:NTSC, 1:PAL
gv_txbuf[11] = EPROM_SetUp_data_Read(EPROM_RECORD_FRAME_RATE);
gv_txbuf[12]= EPROM_SetUp_data_Read(EPROM_ALARM_DURATION);
gv_txbuf[13]= EPROM_SetUp_data_Read(EPROM_RECORD_DURATION);
gv_txbuf[14] = (Val_EPROM_AUDIO_SET & 0x03) |
((gv_audif)?0x80:0x00) |
((Val_EPROM_AUDIO_CH<<2) /*& 0x0C*/);
// Master
gv_txbuf[15]= gv_HDD_exist[0]; // hdd_exist master
gv_txbuf[16]= EPROM_SetUp_data_Read(EPROM_M_WRAPPING_FLAG); // hdd_full_flag master
gv_txbuf[17]= gv_HDD_size[0] & 0x000000FF; // hdd size by 4KB offset
gv_txbuf[18]= (gv_HDD_size[0] >> 8)& 0x000000FF;
gv_txbuf[19]= (gv_HDD_size[0] >> 16)& 0x000000FF;
gv_txbuf[20]= (gv_HDD_size[0] >> 24)& 0x000000FF;
gv_txbuf[21]= gv_WCurrent_LBA[0] & 0x000000FF; // current writing LBA 4KB offset
gv_txbuf[22]= (gv_WCurrent_LBA[0] >> 8)& 0x000000FF;
gv_txbuf[23]= (gv_WCurrent_LBA[0] >> 16)& 0x000000FF;
gv_txbuf[24]= (gv_WCurrent_LBA[0] >> 24)& 0x000000FF;
// Slave
gv_txbuf[25]= gv_HDD_exist[1]; // hdd_exist master
gv_txbuf[26]= EPROM_SetUp_data_Read(EPROM_S_WRAPPING_FLAG); // hdd_full_flag master
gv_txbuf[27]= gv_HDD_size[1] & 0x000000FF; // hdd size by 4KB offset
gv_txbuf[28]= (gv_HDD_size[1] >> 8)& 0x000000FF;
gv_txbuf[29]= (gv_HDD_size[1] >> 16)& 0x000000FF;
gv_txbuf[30]= (gv_HDD_size[1] >> 24)& 0x000000FF;
gv_txbuf[31]= gv_WCurrent_LBA[1] & 0x000000FF; // current writing LBA 4KB offset
gv_txbuf[32]= (gv_WCurrent_LBA[1] >> 8)& 0x000000FF;
gv_txbuf[33]= (gv_WCurrent_LBA[1] >> 16)& 0x000000FF;
gv_txbuf[34]= (gv_WCurrent_LBA[1] >> 24)& 0x000000FF;
gv_txlen += 32;
return 0;
}
//###############################################################################
// Rx payload : EACH=0x00, QUAD=0x01 (1 byte)
//###############################################################################
static u8 Proc_CmdSetRecordMode_Request(void)
{
// change record mode
Val_EPROM_EACH_QUAD = gv_rxbuf[HDSZ];
EPROM_SetUp_data_Write(EPROM_EACH_QUAD, Val_EPROM_EACH_QUAD);
v1_v2_reg_set();
return 0;
}
//###############################################################################
// Rx payload : camera set bit3->ch0, bit2->ch1, bit1->ch2, bit2->ch3 (1 byte)
//###############################################################################
static u8 Proc_CmdSetInputCamera_Request(void)
{
Val_EPROM_CAMERA_OF_SET = gv_rxbuf[HDSZ];
EPROM_SetUp_data_Write(EPROM_CAMERA_OF_SET, Val_EPROM_CAMERA_OF_SET);
xioWriteByte(QUAD_REG_CH_STAT, Val_EPROM_CAMERA_OF_SET); // Quad REGISTER setup
Channel_Display(1); // update video out
return 0;
}
//###############################################################################
// Rx payload : record set bit3->ch0, bit2->ch1, bit1->ch2, bit2->ch3 (1 byte)
//###############################################################################
static u8 Proc_CmdSetRecordCamera_Request(void)
{
Val_EPROM_CAMERA_OF_RECORD = gv_rxbuf[HDSZ];
EPROM_SetUp_data_Write(EPROM_CAMERA_OF_RECORD, Val_EPROM_CAMERA_OF_RECORD);
v1_v2_reg_set();
if(Val_EPROM_EACH_QUAD==0)
gv_temp_CAMERA_OF_RECORD = Val_EPROM_CAMERA_OF_RECORD;
else
gv_temp_CAMERA_OF_RECORD = 0x1f;
Channel_Display(1); // update video out
return 0;
}
//###############################################################################
// Rx payload : 0:Low, 1:Normal, 2:High quality of recording (1 byte)
//###############################################################################
static u8 Proc_CmdSetVideoQuality_Request(void)
{
Val_EPROM_VIDIO_QUALITY = gv_rxbuf[HDSZ];
EPROM_SetUp_data_Write(EPROM_VIDIO_QUALITY, Val_EPROM_VIDIO_QUALITY);
// [0<LOW>,4,5..] --> 4(R) [1<HIGH>,2<NORMAL>] --> 2(R),3(R)
if((Val_EPROM_VIDIO_QUALITY == 0) || (Val_EPROM_VIDIO_QUALITY > 3))
QLEVEL_REGISTER = 4;
else
QLEVEL_REGISTER = Val_EPROM_VIDIO_QUALITY+1;
return 0;
}
//###############################################################################
// Rx payload : index of recording frame rate array for each NTSC/PAL (1 byte)
//###############################################################################
static u8 Proc_CmdSetRecordFrameRate_Request(void)
{
#ifdef DEBUG_CFGAUD
printf("\n\rClient: SetRecordFrameRate");
#endif
gv_rdcp_changed_vfr = 1;
Val_EPROM_RECORD_FRAME_RATE = gv_rxbuf[HDSZ];
EPROM_SetUp_data_Write(EPROM_RECORD_FRAME_RATE, Val_EPROM_RECORD_FRAME_RATE);
gv_rec_frame_rate = code_frame_rate[Val_EPROM_RECORD_FRAME_RATE];//2002.10.10
FRAME_RATE_REGISTER = gv_rec_frame_rate;
return 0;
}
//###############################################################################
// Rx payload : 0 ~ 34, 35(CONT) (1 byte)
//###############################################################################
static u8 Proc_CmdSetAlarmOnDuration_Request(void)
{
Val_EPROM_ALARM_DURATION = gv_rxbuf[HDSZ];
EPROM_SetUp_data_Write(EPROM_ALARM_DURATION, Val_EPROM_ALARM_DURATION);
return 0;
}
//###############################################################################
// Rx payload : 5,10,15,20,25,30 (1 byte)
//###############################################################################
static u8 Proc_CmdSetAlarmRecordDuration_Request(void)
{
Val_EPROM_RECORD_DURATION = gv_rxbuf[HDSZ];
EPROM_SetUp_data_Write(EPROM_RECORD_DURATION, Val_EPROM_RECORD_DURATION);
return 0;
}
//###############################################################################
//
//###############################################################################
static u8 Proc_CmdSetAudio_Request(void)
{
xdata u8 tmp;
tmp = gv_rxbuf[HDSZ];
Val_EPROM_AUDIO_SET = tmp & 0x03; // audio recording flag and mute
EPROM_SetUp_data_Write(EPROM_AUDIO_SET, Val_EPROM_AUDIO_SET);
audioif_mute( Val_EPROM_AUDIO_SET & AUD_MUTE );
Val_EPROM_AUDIO_CH = ((tmp>>2) & 0x03);
EPROM_SetUp_data_Write(EPROM_AUDIO_CHANNEL, Val_EPROM_AUDIO_CH);
audio_ch_sel();
return 0;
}
//###############################################################################
// Tx payload : Recording schedule (6 bytes)
//###############################################################################
static u8 Proc_CmdGetSchedule_Request(void)
{
u8 i;
for(i=0;i<6;i++)
gv_txbuf[HDSZ+i] = EPROM_SetUp_data_Read(EPROM_SCHEDULE_BASE+i);
gv_txlen += 6;
return 0;
}
//###############################################################################
// Rx payload : Recording schedule (6 bytes)
//###############################################################################
static u8 Proc_CmdSetSchedule_Request(void)
{
u8 i;
for(i=0;i<6;i++)
EPROM_SetUp_data_Write(EPROM_SCHEDULE_BASE+i, gv_rxbuf[HDSZ+i]);
return 0;
}
//###############################################################################
// Tx payload : Current time (6 bytes)
//###############################################################################
static u8 Proc_CmdGetTime_Request(void)
{
u8 i;
ds1307_time_read();
for(i=0;i<6;i++)
gv_txbuf[i+HDSZ] = gv_time_data[i];
gv_txlen += 6;
return 0;
}
//###############################################################################
// Rx payload : Current time (6 bytes)
//###############################################################################
static u8 Proc_CmdSetTime_Request(void)
{
u8 i;
for(i=0;i<6;i++)
gv_time_data[i] = gv_rxbuf[i+HDSZ];
ds1307_time_set();
SCHEDULE_TIME_DISP(0);
return 0;
}
//###############################################################################
// Rx payload : hdd_id(1byte) + password (6 bytes)
//###############################################################################
static u8 Proc_CmdFormatHdd_Request(void)
{
u8 i;
// check password
for(i=0;i<6;i++){
if(EPROM_SetUp_data_Read(EPROM_PASSWORD_BASE + i) != gv_rxbuf[HDSZ+1+i])
break;
}
if(i!=6){ // incorrect password
gv_reason_code = RDCP_ERR_INVALID_PASSWD;
return 1;
}
i = gv_rxbuf[HDSZ]; // HDD Id (Master/Slave
if(i>1)
{
gv_reason_code = RDCP_ERR_INVALID_PARAM;
return 2;
}
if(!gv_HDD_exist[i])
{
gv_reason_code = RDCP_ERR_HDD_NONE;
return 3;
}
HDD_Format(i); // format HDD
SearchNewEvent();
return 0;
}
//###############################################################################
//
//###############################################################################
static u8 Proc_CmdRecordStart_Request(void)
{
if(gv_hdd_count!=0)
{
gv_rdcp_rec_stop_request = 1;
return 0;
}
else{
gv_reason_code = RDCP_ERR_HDD_NONE;
return 1;
}
}
//###############################################################################
//
//###############################################################################
static u8 Proc_CmdRecordStop_Request(void)
{
gv_rdcp_rec_stop_request = 2;
#ifdef DEBUG_RECSTART
printf("S");
#endif
return 0;
}
//=====================================================================================================
//
//=====================================================================================================
static void mark_event(u8 hddIndex, u8 type, u32 start_lba, u8* start_time, u8* end_time, u8* buffIndex)
{
u8 i;
//u16 j = *buffIndex;
u8 j = *buffIndex;
gv_txbuf[j++] = hddIndex;
gv_txbuf[j++] = type;
gv_txbuf[j++] = (start_lba & 0x000000FF);
gv_txbuf[j++] = (start_lba & 0x0000FF00)>>8;
gv_txbuf[j++] = (start_lba & 0x00FF0000)>>16;
gv_txbuf[j++] = (start_lba & 0xFF000000)>>24;
// start time 04 - 09
for(i=0;i<6;i++)
gv_txbuf[j++] = start_time[i];
// end time 10 - 15
for(i=0;i<6;i++)
gv_txbuf[j++] = end_time[i];
*buffIndex = j;
#ifdef DEBUG_SENDEVENT
printf("\r\n mrk_evt: TY=%d LBA=%08lx ",(u16)type, (u32)start_lba);
printf("S-");
for(i=0;i<6;i++)
printf("%02x:",(u16)start_time[5-i]);
printf(" E-");
for(i=0;i<6;i++)
printf("%02x:",(u16)end_time[5-i]);
#endif
}
//###############################################################################
// Tx payload : Start LBA, Start time and End time (12 bytes)
//###############################################################################
static u8 Proc_CmdPlaySearch_Request(void)
{
u8 i, j;
u8 first_round_flag, buffIndex;
u32 start_lba = 0;
u8 start_time[6];
u8 end_time[6];
EvtNode evt_node;
u16 event_offset;
u16 event_off_save;
#ifdef DEBUG_PLAYSEARCH
u8 k;
#endif
#ifdef DEBUG_PLAYSEARCH
printf("\n\rPlaySearch_Request -- start");
#endif
if(gv_hdd_count==0) goto EXIT_PLAY_SEARCH;
//Get HDD's start/end time
for(i=0;i<2;i++)
{
buffIndex = HDSZ;
if(gv_HDD_exist[i])
{
//HDD_EventLog_Load(i);
#ifdef DEBUG_PLAYSEARCH
printf("\r\n PlaySearch - %s",i?"SLAVE ":"MASTER");
#endif
if(!Val_EPROM_WRAPPING_FLAG[i] && !gv_WCurrent_LBA[i])
{// hdd empty
#ifdef DEBUG_PLAYSEARCH
printf("\r\nEmpty!!! i = %d",(u16)i);
#endif
continue;
}
get_time_for_play(i,&start_lba,start_time,end_time);
#ifdef DEBUG_PLAYSEARCH
printf("\n\r --> "); for(k=0;k<6;k++) printf("%02d:", (int)start_time[k]);
printf(" ~ "); for(k=0;k<6;k++) printf("%02d:", (int)end_time[k]);
#endif
mark_event(i, LIST_TYPE_WHOLE_HDD, start_lba, start_time, end_time, &buffIndex);
first_round_flag = 0;
event_offset = 0xffff;
while(1)
{
event_off_save = event_offset;
DOIT_AGAIN:
// get end event
if(HDD_EventLog_Get(i, &event_offset, first_round_flag?EVTREQ_PAST:EVTREQ_CURRENT, &evt_node))
{
// there's no more data
#ifdef DEBUG_PLAYSEARCH
printf("\r\n[Event Get] No more data\r\nbreak;");
#endif
break;
}
// get start event
else
{
if(evt_node.evt_id != EVTID_RECSTOP)
{
#ifdef DEBUG_PLAYSEARCH
printf("\n\r[Event Get] We lost some event or error happens");
#endif
break;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -