dbparser.cpp

AliEditor_Source code

// DbParser.cpp: implementation of the CDbParser class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "AliEditor.h"
#include "DbParser.h"
#include "UploadDlg.h"
#include "AliEditorView.h"
#include "Navigator.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define USER_DB_LENGTH 0x100000			//(1024 * 1024)
#define DATA_LIMIT_LEN USER_DB_LENGTH*10	//udb offset * 10 as limite len

#define DB_MULTI_SECTOR

#define DB_SUCCES 0
#define DBERR_PARAM		-1
/*flash reclaim fail*/
#define DBERR_RECLAIM		-2
/*flash full of valid data*/
#define DBERR_FLASH_FULL	-3
/*data already exist*/
#define DBERR_EXSITS		-4
/*command buffer full*/
#define DBERR_CMDBUF_FULL	-5
/*view buffer full*/
#define DBERR_VIEW_FULL	-6
/**/
#define DBERR_INIT			-7
/*to max number*/
#define DBERR_MAX_LIMIT	-8
/*update fail*/
#define DBERR_UPDATE		-9		

#define DBERR_ID_ASSIGN		-10
/*BASIC OPERTION LAYER*/
/*flash wirte error*/
#define DBERR_BO_WRITE			-11
/*flash read error*/
#define DBERR_BO_READ			-12
/*flash erase error*/
#define DBERR_BO_ERASE			-13
/*node header errupted*/
#define DBERR_BO_BAD_HEADER	-14
/*node header errupted*/
#define DBERR_BO_THRESHOLD	-15
/*need reclaim*/
#define DBERR_BO_NEED_RACLAIM	-16
/*addr init failed*/
#define DBERR_BO_INIT			-17

/*DATA OBJECT LAYER*/
/*create table failed*/
#define DBERR_DO_TABLE		-18
/*create view failed*/
#define DBERR_DO_VIEW		-19
/* reclaim failed*/
#define DBERR_DO_RECLAIM	-20
/*cmd buf*/
#define DBERR_DO_CMDBUF	-21

#define DBERR_DO_PROCESS_OP	-22

/*API LAYER*/
/* node not found*/
#define DBERR_API_NOFOUND	-23
#define DBERR_PACK		-24

/*buffer not enough or overflow*/
#define DBERR_BUF		-25

/*flash sector status*/
enum  
{
	BO_SS_UNKNOWN = 0xffff,
	BO_SS_SPARE = 0xfffc,
	BO_SS_COPYING = 0xfff0,
	BO_SS_VALID = 0xffc0,
	BO_SS_SELECT = 0xff00,
	BO_SS_ERASING = 0xfc00,
	BO_SS_INVALID = 0x0000,
}BO_Sec_Status;

/*flash sector type*/
enum
{
	BO_TYPE_UNKNOWN = 0xff,
	BO_TYPE_HEAD = 0xfc,
	BO_TYPE_DATA = 0xf0,
	BO_TYPE_TMP = 0xc0,
}BO_Sec_Type;

#define OP_VALID_FLAG	0xA5

enum 
{
	OPERATION_ADD = 0x01,
	OPERATION_EDIT = 0x02,
	OPERATION_DEL = 0x03,
	OPERATION_MOVE = 0x04,

}Operation_Type;

/*db node type*/
enum
{
	TYPE_PROG_NODE = 0,
	TYPE_TP_NODE =	1,
	TYPE_SAT_NODE = 2,
	TYPE_SEARCH_TP_NODE = 3,
	TYPE_UNKNOWN_NODE = 0xFF,
};

const char prog_template_buf[256] =
{
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 
	0x00, 0x00, 0xFF, 0x1F, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};

SDX_Map_Table SDX_Sat_Table[] =
{
	{SKEYZ_SAT_NAME, 10, 18, 0, 0},
	{SKEYZ_SAT_ORBIT, 51, 4, 0, 0},
};

Sat_Name_Map_Table Sat_Name_Table[]=
{
	{"Astra 19.2","0192"},
	{"Hotbird","0130"},
	{"Turksat 1C","0420"},
	{"Sirius 2/3","0050"},
	{"Eutelsat W3","0070"},
	{"Eutelsat W1","0100"},
	{"Eutelsat W2","0160"},
	{"Eutelsat W6","0215"},
	{"Astra 23.5","0235"},
	{"Badr C/3","0260"},
	{"Eurobird 2","0260"},
	{"Astra 28.2","0282"},
	{"Arabsat 2B","0305"},
	{"Hellas Sat 2","0390"},
	{"Hispasat 1C/1D","3300"},
	{"Intelsat 907","3325"},
	{"Telstar 12","3450"},
	{"Atlantic Bird 1","3475"},
	{"Telecom 2D","3520"},
	{"Nilesat 101/102","3530"},
	{"Atlantic Bird 3","3550"},
	{"Amos 1","3560"},
	{"Thor 2/3","3592"},
	{"Intelsat 10-02","3590"},
};

SDX_Map_Table SDX_TP_Table[] =
{
	{TKEYZ_FREQ, 33, 6, 0, 0},
	{TKEYZ_POL, 42, 1, 0, 0	},
	{TKEYZ_SYMBOL, 69, 5, 0, 0},
	{TKEYZ_T_S_ID, 97, 5, 0, 0},
	{TKEYZ_NETWORK_ID, 92, 5, 0, 0}
};
SDX_Map_Table SDX_Prog_Table[] =
{
	{PKEYZ_SERVICE_NAME, 43, 8, 115, 12},
	{PKEYZ_AUDIO_PID1, 79, 4, 0, 0},
	{PKEYZ_PCR_PID, 83, 4, 0, 0},
	{PKEYZ_PROG_NUMBER, 87, 5, 0, 0},
	{PKEYZ_VIDEO_PID, 75, 4, 0, 0},
};

int g_group_count = 1;
group_id_name Group_Id_Name_Table[] = 
{
	{0x01, "Favorite Group"}
};
int g_txt_column_count = 13;
txt_column txt_column_sat[] = 
{
	{STRING, SKEYZ_SAT_NAME},
	{DIGIT, SKEYZ_K22},//22K
	{DIGIT, SKEYZ_V12},//12V
	{DIGIT, SKEYZ_DISEQC_PORT},//DiSEqC_Port
	{DIGIT, NULL},
	{DIGIT, NULL},
	{DIGIT, SKEYZ_LNB_LOW},//LNB_FRQ
	{DIGIT, SKEYZ_LNB_POWER},//LNB_POWER
	{DIGIT, NULL},
	{DIGIT, NULL},
	{DIGIT, NULL},
	{DIGIT, NULL},
	{DIGIT, NULL}
};
bool g_freeaddr_full = false;
txt_column txt_column_prog[] = 
{
	{STRING, PKEYZ_SERVICE_NAME},//节目名
	{DIGIT, PKEYZ_TELETEXT_PID},//Teletxet pid
	{DIGIT, PKEYZ_VIDEO_PID},//视频pid
	{DIGIT, PKEYZ_AUDIO_PID1},//音频pid1
	{DIGIT, PKEYZ_AUDIO_PID2},//音频pid2
	{DIGIT, PKEYZ_AUDIO_PID3},//音频pid3
	{DIGIT, PKEYZ_PCR_PID},//pcrpid
	{DIGIT, TKEYZ_FREQ},//下行频率 tp
	{DIGIT, TKEYZ_SYMBOL},//符号率 tp
	{STRING, TKEYZ_POL},//极化 tp
	{DIGIT, PKEYZ_LEVEL},//节目级别
	{DIGIT, PKEYZ_PRESET_FLAG},//预置标记
	{DIGIT, PKEYZ_TV_RADIO}//TV/Radio
};

int g_Cur_Sat_Id;
int g_Cur_Tp_Id;
int g_Cur_Prog_Id;
CString g_strLastSatName;
CString g_strLastTpName;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDbParser::CDbParser()
{
	m_user_data_addr = 0;
	m_def_data_addr = 0;
	m_block_numbers = 0;
	m_default_whole_len = 0;
	m_user_data_whole_len = 0;
	db_update_buf = (UINT8 *)malloc(1024 * 128);
	m_pdatabuf = NULL;
	bo_sec_list = NULL;

	memset(&m_tpheader,0, sizeof(db_header_t));
	memset(&m_satheader,0, sizeof(db_header_t));
	memset(&m_progheader,0, sizeof(db_header_t));

	m_sat_of_sat_index = -1;
	m_sat_of_tp_index = -1;
	m_sat_of_prog_index = -1;
	m_tp_of_tp_index = -1;
	m_tp_of_prog_index = -1;
	m_sat_service_name_index = -1;
	m_tp_service_name_index = -1;
	m_prog_service_name_index = -1;
	m_free_addr = 0;

	m_nCurSatId = 0;
	m_nCurTpId = 0;
	m_pFavoriteGroup = NULL;
}

CDbParser::~CDbParser()
{
	if(db_update_buf) 
	{
		delete []db_update_buf;
		db_update_buf = NULL;
	}

	if( bo_sec_list )
	{
		free(bo_sec_list);
		bo_sec_list = NULL;
	}
}

BOOL CDbParser::GetDataBaseAddr(const CString& strPathName)
{
	CUploadDlg dlg;
	dlg.m_Path = strPathName;
	m_block_numbers = dlg.getBlockNumber();
	if(!dlg.m_user_data_addr && !dlg.m_default_addr)
	{
		m_block_numbers = 0;
		m_user_data_addr = 0;
		m_def_data_addr = 0;
		m_default_whole_len = 0;
		m_user_data_whole_len = 0;
		return FALSE;
	}
	m_user_data_addr = dlg.m_user_data_addr + 128;//skip header
	m_def_data_addr = dlg.m_default_addr + 128;
	m_default_whole_len = dlg.m_default_whole_len - 0x80;
	m_user_data_whole_len = dlg.m_user_data_whole_len - 0x80;
	
	
	return TRUE;
}

INT32 CDbParser::DO_create_table()
{
	INT32 ret = 0;
	UINT32 header_start, header_free;
	UINT16 i, j, node_num;
	UINT8 header_node[BO_HEADER_NODE_SIZE];
	DB_TABLE *t_attr = (DB_TABLE *)&db_table[0];
	UINT32 node_id = 0;
	UINT8 node_type = TYPE_UNKNOWN_NODE;
	
	UINT8 *temp_buf = db_update_buf;//give a block of memory , maybe frame buffer
	
	OP_PARAM param;
	INT32 table_node_len = db_table_node_length;
	UINT32 node_addr = 0;
	UINT8 tmp[4];
	UINT8 op_param_err = 0;

	ret = BO_get_header(&header_start, &node_num,&header_free);
	if(ret != DB_SUCCES)
	{
		//DO_PRINTF("DO_create_table():get header failed!\n");
		return -1;
	}
	header_start += 4 + 2;
	//read header, add each node id, addr into table
	for(i = 0; i < node_num; i++)
	{
		BO_read_data(header_start+ i *BO_HEADER_NODE_SIZE, BO_HEADER_NODE_SIZE, header_node);
		memcpy((UINT8 *)&node_id, header_node, NODE_ID_SIZE);
		node_type = DO_get_node_type(node_id);
		if(node_type == TYPE_UNKNOWN_NODE)
		{
			//DO_PRINTF("unnknown node type at %d in header!\n",i);
			return -1;
		}
		else 
		{
			memcpy((UINT8 *)&(t_attr[node_type].table_buf[t_attr[node_type].node_num]), header_node, BO_HEADER_NODE_SIZE);
			t_attr[node_type].node_num++;
		}
		
	}
	header_start += node_num * BO_HEADER_NODE_SIZE + 4;
	//process the operation:type, node id, addr, valid flag
	//while((header_start < header_free) && (header_start+4 <= header_free))
	while(header_start+4 <= header_free)
	{
		BO_read_data(header_start, sizeof(OP_PARAM), (UINT8 *)&param);
		ret = DO_t_process_operation(param, temp_buf);
		//if error during create table, what should do?
		if(ret != DB_SUCCES)
		{
			//read and process operation param error, break
			op_param_err = 1;
			break;
			
			//return DBERR_DO_TABLE;
		}
		header_start += sizeof(OP_PARAM);
	}
	//after process operation, rearange each table
	for(i = 0; i < DB_TABLE_NUM; i++)
	{
		DO_table_rearrange(&t_attr[i], temp_buf);
	}
	//read and process operation param error, use current table as table
	if(op_param_err == 1)
	{
		ret = DB_reclaim_write_header();
		if(ret != DB_SUCCES)
			return ret;
	}
	//after table created, compute the node length in all tables
	for(i = 0; i < DB_TABLE_NUM; i++)
	{
		for(j = 0; j < t_attr[i].node_num; j++)
		{
			memcpy((UINT8 *)&node_addr, t_attr[i].table_buf[j].node_addr, NODE_ADDR_SIZE);
			BO_read_data(node_addr,4, tmp);
			table_node_len += (INT32)tmp[NODE_ID_SIZE] + NODE_ID_SIZE;
		}
	}
	DO_set_table_node_length(table_node_len);
	
	return ret;
}

INT32 CDbParser::DO_init(UINT32 db_base_addr, UINT32 db_length)
{
	INT32 ret = DB_SUCCES;
	UINT8 i;

	ret = BO_init(db_base_addr, db_length);
	if(ret != DB_SUCCES)
	{
		return ret;
	}

	for(i = 0; i < DB_TABLE_NUM; i++)
		memset(&db_table[i], 0, sizeof(DB_TABLE));
//	MEMSET(&db_view, 0, sizeof(DB_VIEW));
//	MEMSET(&db_cmd_buf, 0, sizeof(DB_CMD_BUF));

	db_table[TYPE_SAT_NODE].type = TYPE_SAT_NODE;
	db_table[TYPE_SAT_NODE].max_cnt = MAX_SAT_NUM;
	db_table[TYPE_SAT_NODE].table_buf = (NODE_IDX_PARAM *)&db_table_set_buf[0];
	
	db_table[TYPE_TP_NODE].type = TYPE_TP_NODE;
	db_table[TYPE_TP_NODE].max_cnt = MAX_TP_NUM;
	db_table[TYPE_TP_NODE].table_buf = (NODE_IDX_PARAM *)&db_table_tp_buf[0];
	
	db_table[TYPE_PROG_NODE].type = TYPE_PROG_NODE;
	db_table[TYPE_PROG_NODE].max_cnt = MAX_PROG_NUM;
	db_table[TYPE_PROG_NODE].table_buf = (NODE_IDX_PARAM *)&db_table_pg_buf[0];
	
//	db_view.pre_type = db_view.cur_type = TYPE_UNKNOWN_NODE;
//	db_view.max_cnt = (MAX_PROG_NUM > MAX_TP_NUM)?MAX_PROG_NUM : MAX_TP_NUM;
//	db_view.node_buf = db_view_buf;

	db_cmd_buf.max_cnt = MAX_CMD_NUM;
	db_cmd_buf.buf = db_cmd_list;

	ret = DO_create_table();
	if(ret != DB_SUCCES)
	{
		return ret;
	}
	return DB_SUCCES;
}

INT32 CDbParser::BO_init(UINT32 db_base_addr, UINT32 db_length)
{
	INT32 ret = DB_SUCCES;
	UINT32 head_free_addr;
	UINT32 data_free_addr;
	UINT8 i = 0;
	
	UINT8 data_sec_cnt = 0;
	UINT8 free_sec_cnt = 0;
	UINT32 unknow_sec_cnt = 0;
	UINT8 free_sec_idx;

	BO_reset();

	g_db_base_addr =  db_base_addr;
	g_db_length = db_length;
	m_nSectorNum = g_db_length/DB_SECTOR_SIZE;

	if(bo_sec_list == NULL)
	{
		bo_sec_list = (struct BO_Sec_Info*)malloc(m_nSectorNum *sizeof(struct BO_Sec_Info));
		if(bo_sec_list == NULL)
		{
			//PRINTF("BO_init(): Malloc bo_sec_list memory failed!\n");
			return DBERR_BO_INIT;
		}
	}

	memset(bo_sec_list, 0x00, sizeof(struct BO_Sec_Info)*m_nSectorNum);
	memset(bo_free_sec_list, 0, BO_MAX_SECTOR_NUM+1);

	if(m_nSectorNum == 1)
	{
		bo_head_sec_index = bo_cur_data_sec_index = 0;
	}
	else
	{
#if defined(DB_MULTI_SECTOR)
		for(;i < m_nSectorNum; i++)
			BO_read_data(((UINT32)i)<<NODE_ADDR_OFFSET_BIT, sizeof(struct BO_Sec_Info), (UINT8 *)&bo_sec_list[i]);
			
		for(i = 0; i < m_nSectorNum; i++)
		{	
			//here can diagnose db sectors, find out power loss, esrase unfinished etc. 
			ret = BO_sector_diagnose(i, &bo_sec_list[i]);
			if(ret != DB_SUCCES)
				return ret;
			
			if(bo_sec_list[i].type == BO_TYPE_HEAD && bo_sec_list[i].valid_flag == BO_VALID_FLAG)
				bo_head_sec_index = i;
			else if(bo_sec_list[i].type == BO_TYPE_DATA && bo_sec_list[i].valid_flag == BO_VALID_FLAG)
				data_sec_cnt += 1;
			else if(bo_sec_list[i].type == BO_TYPE_UNKNOWN && bo_sec_list[i].status == BO_SS_SPARE
					&& bo_sec_list[i].valid_flag == BO_VALID_FLAG)
			{
				free_sec_cnt += 1;
				BO_add_to_free_list(i);
			}
			else if(bo_sec_list[i].type == BO_TYPE_UNKNOWN && bo_sec_list[i].status == BO_SS_UNKNOWN
					&& bo_sec_list[i].logic_number == 0xFFFFFFFF 
					&& bo_sec_list[i].erase_count == 0xFFFFFFFF
					&& bo_sec_list[i].valid_flag == 0xFF)
			{
				bo_sec_list[i].status = BO_SS_SPARE;
				bo_sec_list[i].erase_count = 0;
				bo_sec_list[i].valid_flag = BO_VALID_FLAG;
				if(BO_flash_write((UINT8 *)&bo_sec_list[i], sizeof(struct BO_Sec_Info), (UINT32)i<<NODE_ADDR_OFFSET_BIT) != DB_SUCCES)
				{
					//BO_PRINTF("BO_init(): change sector %d status to spare failed!\n",i);
					return DBERR_BO_INIT;
				}
				free_sec_cnt += 1;
				BO_add_to_free_list(i);
			}
		}

		if(free_sec_cnt == m_nSectorNum)
		{
			BO_get_free_sector(&free_sec_idx);
			bo_head_sec_index = free_sec_idx;
			if(DBERR_BO_THRESHOLD==BO_get_free_sector(&free_sec_idx))
				return DBERR_BO_INIT;