/******************************************************************************
 *    (c)2008-2009 Broadcom Corporation
 *
 * This program is the proprietary software of Broadcom Corporation and/or its licensors,
 * and may only be used, duplicated, modified or distributed pursuant to the terms and
 * conditions of a separate, written license agreement executed between you and Broadcom
 * (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
 * no license (express or implied), right to use, or waiver of any kind with respect to the
 * Software, and Broadcom expressly reserves all rights in and to the Software and all
 * intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
 * HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
 * NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
 *
 * Except as expressly set forth in the Authorized License,
 *
 * 1.     This program, including its structure, sequence and organization, constitutes the valuable trade
 * secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
 * and to use this information only in connection with your use of Broadcom integrated circuit products.
 *
 * 2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
 * AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
 * THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
 * OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
 * LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
 * OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
 * USE OR PERFORMANCE OF THE SOFTWARE.
 *
 * 3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
 * LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
 * EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
 * USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
 * ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
 * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
 * ANY LIMITED REMEDY.
 *
 * $brcm_Workfile:  $
 * $brcm_Revision:  $
 * $brcm_Date:  $
 *
 * Module Description:
 *
 * Manage application settings like volume, channel map, etc.
 *
 * Revision History:
 *
 * Created: 09/28/2009 by Jeff Fisher
 *
 * $brcm_Log:  $
 * 
 *
 *****************************************************************************/
#include "bstd.h"
#include "bkni.h"
#include "bdbg.h"

#include "bapp.h"
#include "bapp_settings.h"
#include "bfdb.h"
#include "bspi_flash.h"

BDBG_MODULE(bast);		/* Register software module with debug interface */


struct settings_state_t {
	bfdb_handle db;
	uint8_t data[BFDB_DATA_MAX];
};

static struct settings_state_t sst;

static bfdb_err bast_add(bfdb_handle handle, uint8_t id, uint8_t *data, size_t size);

/* 
 * Flash configuration. for most flashes sector size and page size should be
 * left at default. Offset is a starting offset of database from the beginning
 * of the flash. DB_SIZE and DB_OFFSET must be divisible by SECTOR_SIZE
 */

#define FLASH_PAGE_SIZE 	0x100
#define FLASH_SECTOR_SIZE	0x10000
#define FLASH_DB_SIZE		0x40000
#define FLASH_DB_OFFSET		(0x400000 - FLASH_DB_SIZE)
#define MEM_DB_OFFSET		0
#define MEM_DB_SIZE			FLASH_DB_SIZE

/*
 * Open and initialize database.
 */
void bast_init(bapp_t *app)
{
	bfdb_err dberr;
	struct bfdb_settings dbset;
	bspi_settings_t spi_settings;
	bresult rc;

	rc = bspi_identify(&spi_settings);
	BDBG_ASSERT(rc == b_ok);

	dbset.page_size = FLASH_PAGE_SIZE;
	dbset.sector_size = spi_settings.sector_size;
	dbset.db_offset = FLASH_DB_OFFSET;
	dbset.db_size = FLASH_DB_SIZE;

	BKNI_Memset(&sst, 0, sizeof(struct settings_state_t));
	dberr = bfdb_open(&dbset, &sst.db);
	if (BFDB_OK != dberr) {
		BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
		if (BFDB_LOG_ERROR == dberr) {
			dberr = bfdb_erase(sst.db);
			if (BFDB_OK != dberr) {
				BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
			}
		}
	}
}	

bfdb_err bast_delete_all(uint8_t id)
{
	bfdb_err dberr;

	dberr = bfdb_rewind(sst.db, id);
	switch(dberr) {
	case BFDB_OK:
		/* we have records in database, delete them */
		do {
			dberr = bfdb_delete(sst.db);
			if (BFDB_OK != dberr) {
				BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
				goto ExitFunc;
			}
			dberr = bfdb_next(sst.db, id);
		} while (BFDB_OK == dberr);
	case BFDB_RECORD_NOT_FOUND:
		dberr = BFDB_OK;
		break;
	default:
		BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
	}
ExitFunc:
	return dberr;
}

/* add with compact if add fails */
bfdb_err bast_add(bfdb_handle handle, uint8_t id, uint8_t *data, size_t size)
{
	bfdb_err dberr;
	
	do {
		dberr = bfdb_add(handle, id, data, size);
		if (BFDB_LOG_FULL == dberr) {
			dberr = bfdb_compact(handle);
			if (BFDB_OK == dberr) {
				dberr = BFDB_LOG_FULL;
			}
		}
	} while (BFDB_LOG_FULL == dberr);
	return dberr;
}

void bast_channel_save(bapp_t *app)
{
	bfdb_err dberr;
	struct channel_settings_t *channel;

	/* use data memory block */
	channel = (struct channel_settings_t *)sst.data;
	channel->channel = app->settings.ch_map.cur_ch;
	channel->volume = app->settings.audio_vol;

	dberr = bast_delete_all(BAST_CHANNEL_ID);
	if (BFDB_OK != dberr)
	{
		BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
		goto ExitFunc;
	}

	/* create new record */
	dberr = bast_add(sst.db, BAST_CHANNEL_ID, (uint8_t *)channel, sizeof(struct channel_settings_t));
	if (BFDB_OK != dberr) {
		BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
	}
ExitFunc:
	return;
}

void bast_misc_save(bapp_t *app)
{
	bfdb_err dberr;
	struct misc_settings_t *misc;

	misc = (struct misc_settings_t *)sst.data;
	misc->bits.activated = app->settings.activated;
	misc->bits.deactivated = app->settings.deactivated;
	misc->bits.standby = app->settings.standby;
	misc->bits.has_CAT = app->settings.has_CAT;
	misc->bits.av_mute = app->settings.av_mute;
	misc->bits.psi_scan = app->settings.psi_scan;
	misc->bits.state = app->settings.state;
	misc->bits.dummy = 0x3fffff;
	misc->dst_delta = app->settings.dst_delta;
	misc->timeout_policy = app->settings.timeout_policy;
	misc->SCP_operating_mode = app->settings.SCP_operating_mode;
	misc->dummy0 = 0xff;
	misc->CA_System_ID = app->settings.CA_System_ID;
	misc->EMM_Provider_ID = app->settings.EMM_Provider_ID;
	misc->EMM_PID = app->settings.EMM_PID;
	misc->VCT_ID = app->settings.VCT_ID;
	misc->network_PID = app->settings.network_PID;
	misc->hunt_cnt = app->settings.hunt_cnt;
	misc->download_failed_cnt = app->settings.download_failed_cnt;
	misc->download_invalid_cnt = app->settings.download_invalid_cnt;
	misc->timeout = app->settings.timeout;
	misc->max_location_errors = app->settings.max_location_errors;
	misc->location_errors = app->settings.location_errors;
	misc->message_time = app->settings.message_time;
	misc->turn_on_freq_khz = app->settings.turn_on_freq_khz;
	misc->addressable_time = app->settings.addressable_time;
	misc->timeout_cnt = app->settings.timeout_cnt;
	misc->location = app->settings.location;
	misc->utc_offset = app->settings.utc_offset;
	misc->dst_entry = app->settings.dst_entry;
	misc->dst_exit = app->settings.dst_exit;

    misc->aspect_ratio = app->settings.hd_config.aspect_ratio;
    misc->hd_options = app->settings.hd_config.hd_options;
    misc->output_format = app->settings.hd_config.output_format;
    misc->sharpness = app->settings.hd_config.sharpness;
    misc->sd_options = app->settings.sd_options;

	dberr = bast_delete_all(BAST_MISC_ID);
	if(BFDB_OK != dberr){
	BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}

	dberr = bast_add(sst.db, BAST_MISC_ID, (uint8_t*)misc, sizeof(struct misc_settings_t));
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}

ExitFunc:
	return;
}

void bast_eas_save(bapp_t *app)
{
#if 0
    bfdb_err dberr;
    struct eas_settings_t * eas;

    eas = (struct eas_settings_t *)sst.data;
    eas->eas_filter_control = app->settings.eas_filter_control;
    eas->eas_state_code = app->settings.eas_state_code;
    eas->eas_county_subdivision = app->settings.eas_county_subdivision;
    eas->eas_county_code = app->settings.eas_county_code;

    dberr = bast_delete_all(BAST_EAS_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }

    dberr = bast_add(sst.db, BAST_EAS_ID, (uint8_t*)eas, sizeof(struct eas_settings_t));
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
#endif
    return;
}

void bast_phone_number_save(bapp_t *app)
{
	bfdb_err dberr;
	size_t len;
	struct phone_number_settings_t *phone;

	phone = (struct phone_number_settings_t *)sst.data;
	len = strlen(app->settings.phonenumber);
	if (len > (MAX_PHONE_LEN-2)) {
		BDBG_ERR(("Truncating phone number"));
		len = (MAX_PHONE_LEN-2);
	}

	phone->size = len;
	strcpy(phone->data, app->settings.phonenumber);

	dberr = bast_delete_all(BAST_PHONE_NUMBER_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	dberr = bast_add(sst.db, BAST_PHONE_NUMBER_ID, (uint8_t*)phone, len+1);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
ExitFunc:
	return;
}

bfdb_err bast_channel_map_erase(void)
{

	bfdb_err dberr;
	/* erase all components of the channel map */
	dberr = bast_delete_all(BAST_CHANNEL_MAP_HEADER_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	dberr = bast_delete_all(BAST_MMS_ENTRY_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	dberr = bast_delete_all(BAST_FREQ_ENTRY_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	dberr = bast_delete_all(BAST_ST_ENTRY_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	dberr = bast_delete_all(BAST_VCH_ENTRY_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
ExitFunc:
	return dberr;
}

#define BAST_MAX_ITEM 8

bfdb_err bast_mms_save(bapp_t *app)
{
	bfdb_err dberr;
	unsigned int mms_count;
	unsigned int i, j;
	struct mms_entry_settings_t * mms;

	dberr = BFDB_OK;
	mms = (struct mms_entry_settings_t *)sst.data;
	mms_count = app->settings.ch_map.mms_map.num_mms;

	for(i = 0; i < mms_count; ){
		j = 0;
		while((j < BAST_MAX_ITEM) && (i < mms_count)){
			mms->mms[j].idx = app->settings.ch_map.mms_map.mms[i].idx;
			mms->mms[j].code_rate = app->settings.ch_map.mms_map.mms[i].code_rate;
			mms->mms[j].modulation = app->settings.ch_map.mms_map.mms[i].modulation;
			mms->mms[j].symbol_rate = app->settings.ch_map.mms_map.mms[i].symbol_rate;
			j++; i++;
		}

		/* fill unused values */
		while(j < BAST_MAX_ITEM){
			mms->mms[j].idx = 0xff;
			mms->mms[j].code_rate = 0xff;
			mms->mms[j].modulation = 0xff;
			mms->mms[j].symbol_rate = 0xffffffff;
			j++;
		}

		dberr = bast_add(sst.db, BAST_MMS_ENTRY_ID, (uint8_t*)mms, sizeof(struct mms_entry_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
			goto ExitFunc;
		}
	}

ExitFunc:
	return dberr;
}

bfdb_err bast_freq_save(bapp_t *app)
{
	bfdb_err dberr;
	unsigned int i, j;
	struct freq_entry_settings_t * fr;
	unsigned int freq_count;

	dberr = BFDB_OK;
	fr = (struct freq_entry_settings_t*)sst.data;
	freq_count = app->settings.ch_map.freq_map.num_freq;

	for(i = 0; i < freq_count; ){
		j = 0;
		while((j < BAST_MAX_ITEM) && (i < freq_count)){
			fr->freq[j].idx = app->settings.ch_map.freq_map.freq[i].idx;
			fr->freq[j].freq_khz = app->settings.ch_map.freq_map.freq[i].freq_khz;
			i++; j++;
		}

		/* fill unused values */
		while(j < BAST_MAX_ITEM){
			fr->freq[j].idx = 0xff;
			fr->freq[j].freq_khz = 0xffffffff;
			j++;
		}

		dberr = bast_add(sst.db, BAST_FREQ_ENTRY_ID, (uint8_t*)fr, sizeof(struct freq_entry_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
			goto ExitFunc;
		}
	}
ExitFunc:
	return dberr;
}

bfdb_err bast_st_save(bapp_t *app)
{
	bfdb_err dberr;
	unsigned int i;
	unsigned int st_count;
	struct st_entry_settings_t * st;

	dberr = BFDB_OK;
	st = (struct st_entry_settings_t*)sst.data;
	st_count = app->settings.ch_map.st_map.num_st;
	for(i = 0 ; i < st_count; i++){
		BKNI_Memset(st, 0xff, sizeof(struct st_entry_settings_t));
		st->source_id = app->settings.ch_map.st_map.st[i].source_id;
		strcpy(st->name, app->settings.ch_map.st_map.st[i].name);

		dberr = bast_add(sst.db, BAST_ST_ENTRY_ID, (uint8_t*)st, sizeof(struct st_entry_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
			goto ExitFunc;
		}
	}

ExitFunc:
	return dberr;
}

bfdb_err bast_vch_save(bapp_t *app)
{
    bfdb_err dberr;
    unsigned i,j;
    unsigned vch_count;
    struct vch_entry_settings_t * vch;

    dberr = BFDB_OK;
    vch = (struct vch_entry_settings_t *)sst.data;
    vch_count = app->settings.ch_map.vch_map.num_vch;

    for(i = 0; i < vch_count; i++){
        vch->ch_num = app->settings.ch_map.vch_map.vch[i].ch_num;
        vch->source_id = app->settings.ch_map.vch_map.vch[i].source_id;
        vch->program_num = app->settings.ch_map.vch_map.vch[i].program_num;
        vch->pcr_pid = app->settings.ch_map.vch_map.vch[i].pcr_pid;
        vch->scte127_pid = app->settings.ch_map.vch_map.vch[i].scte127_pid;
        vch->video_pid = app->settings.ch_map.vch_map.vch[i].video_pid;
        vch->video_type = app->settings.ch_map.vch_map.vch[i].video_type;
        vch->ca_pid = app->settings.ch_map.vch_map.vch[i].ca_pid;
        vch->freq_idx = app->settings.ch_map.vch_map.vch[i].freq_idx;
        vch->mms_idx = app->settings.ch_map.vch_map.vch[i].mms_idx;
        vch->vchflags = app->settings.ch_map.vch_map.vch[i].vchflags;
        vch->audio_count = app->settings.ch_map.vch_map.vch[i].num_audio;
        vch->audio_current = app->settings.ch_map.vch_map.vch[i].cur_audio;
        for(j = 0; j < VCH_MAX_AUDIO; j++){
            vch->audio_pid[j] = app->settings.ch_map.vch_map.vch[i].audio_pid[j];
            vch->audio_type[j] = app->settings.ch_map.vch_map.vch[i].audio_type[j];
            vch->audio_lang[j][0] = app->settings.ch_map.vch_map.vch[i].audio_lang[j][0];
            vch->audio_lang[j][1] = app->settings.ch_map.vch_map.vch[i].audio_lang[j][1];
            vch->audio_lang[j][2] = app->settings.ch_map.vch_map.vch[i].audio_lang[j][2];
        }
#ifdef CONFIG_DVB_SUBTITLE
		vch->dsub_count = app->settings.ch_map.vch_map.vch[i].num_dsub;
		vch->dsub_current = app->settings.ch_map.vch_map.vch[i].cur_dsub;
		for (j=0; j<VCH_MAX_DSUB; j++) {
			vch->dsub_pid[j] = app->settings.ch_map.vch_map.vch[i].dsub_pid[j];
			vch->dsub_lang[j][0] = app->settings.ch_map.vch_map.vch[i].dsub_lang[j][0];
			vch->dsub_lang[j][1] = app->settings.ch_map.vch_map.vch[i].dsub_lang[j][1];
			vch->dsub_lang[j][2] = app->settings.ch_map.vch_map.vch[i].dsub_lang[j][2];
			vch->dsub_page[j] = app->settings.ch_map.vch_map.vch[i].dsub_page[j];
		}
#endif
        dberr = bast_add(sst.db, BAST_VCH_ENTRY_ID, (uint8_t*)vch, sizeof(struct vch_entry_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
    }
ExitFunc:
    return dberr;
}

void bast_channel_map_save(bapp_t *app)
{
    bfdb_err dberr;
    struct channel_map_header_settings_t * header;

    dberr = bast_channel_map_erase();
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }

    header = (struct channel_map_header_settings_t *)sst.data;
    header->mms_count = app->settings.ch_map.mms_map.num_mms;
    header->freq_count = app->settings.ch_map.freq_map.num_freq;
    header->st_count = app->settings.ch_map.st_map.num_st;
    header->vch_count = app->settings.ch_map.vch_map.num_vch;

    if(0 != (header->mms_count + header->freq_count + header->st_count + header->vch_count)){

        dberr = bast_add(sst.db, BAST_CHANNEL_MAP_HEADER_ID, (uint8_t*)header, sizeof(struct channel_map_header_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }

        dberr = bast_mms_save(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        dberr = bast_freq_save(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        dberr = bast_st_save(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        dberr = bast_vch_save(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }

        if(BFDB_OK != dberr)
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
    return;
}

int bast_channel_read(bapp_t *app)
{
    bfdb_err dberr;
    struct channel_settings_t * channel;

    dberr =  bfdb_rewind(sst.db, BAST_CHANNEL_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct channel_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        channel = (struct channel_settings_t *)sst.data;
        app->settings.ch_map.cur_ch = channel->channel;
        app->settings.audio_vol = channel->volume;
    }
ExitFunc:
    return dberr;
}

int bast_misc_read(bapp_t *app)
{
    bfdb_err dberr;
    struct misc_settings_t * misc;

    dberr = bfdb_rewind(sst.db, BAST_MISC_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct misc_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        misc = (struct misc_settings_t *)sst.data;
        app->settings.activated = misc->bits.activated;
        app->settings.deactivated = misc->bits.deactivated;
        app->settings.standby = misc->bits.standby;
        app->settings.has_CAT = misc->bits.has_CAT;
        app->settings.av_mute = misc->bits.av_mute;
        app->settings.psi_scan = misc->bits.psi_scan;
        app->settings.state = misc->bits.state;
        app->settings.dst_delta = misc->dst_delta;
        app->settings.timeout_policy = misc->timeout_policy;
        app->settings.SCP_operating_mode = misc->SCP_operating_mode;
        app->settings.CA_System_ID = misc->CA_System_ID;
        app->settings.EMM_Provider_ID = misc->EMM_Provider_ID;
        app->settings.EMM_PID = misc->EMM_PID;
        app->settings.VCT_ID = misc->VCT_ID;
        app->settings.network_PID = misc->network_PID;
        app->settings.hunt_cnt = misc->hunt_cnt;
        app->settings.download_failed_cnt = misc->download_failed_cnt;
        app->settings.download_invalid_cnt = misc->download_invalid_cnt;
        app->settings.timeout = misc->timeout;
        app->settings.max_location_errors = misc->max_location_errors;
        app->settings.location_errors = misc->location_errors;
        app->settings.message_time = misc->message_time;
        app->settings.turn_on_freq_khz = misc->turn_on_freq_khz;
        app->settings.addressable_time = misc->addressable_time;
        app->settings.timeout_cnt = misc->timeout_cnt;
        app->settings.location = misc->location;
        app->settings.utc_offset = misc->utc_offset;
        app->settings.dst_entry = misc->dst_entry;
        app->settings.dst_exit = misc->dst_exit;

        app->settings.hd_config.aspect_ratio = misc->aspect_ratio;
        app->settings.hd_config.hd_options = misc->hd_options;
        app->settings.hd_config.output_format = misc->output_format;
        app->settings.hd_config.sharpness = misc->sharpness;
        app->settings.sd_options = misc->sd_options;
    }
ExitFunc:
    return dberr;
}


int bast_eas_read(bapp_t *app)
{
#if 0
    bfdb_err dberr;
    struct eas_settings_t * eas;

    dberr = bfdb_rewind(sst.db, BAST_EAS_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct eas_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        eas = (struct eas_settings_t *)sst.data;
        app->settings.eas_filter_control = eas->eas_filter_control;
        app->settings.eas_state_code = eas->eas_state_code;
        app->settings.eas_county_subdivision = eas->eas_county_subdivision;
        app->settings.eas_county_code = eas->eas_county_code;
    }
ExitFunc:
    return dberr;
#endif
return 0;
}

int bast_phone_number_read(bapp_t *app)
{
    bfdb_err dberr;
    struct phone_number_settings_t * phone;

    dberr = bfdb_rewind(sst.db, BAST_PHONE_NUMBER_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct phone_number_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        phone = (struct phone_number_settings_t*)sst.data;
        phone->data[phone->size] = 0;
        strcpy(app->settings.phonenumber, phone->data);
    }
ExitFunc:
    return dberr;
}

bfdb_err bast_mms_read(bapp_t *app)
{
    bfdb_err dberr;
    unsigned int i, j;
    unsigned int count;
    struct mms_entry_settings_t * mms;

    dberr = bfdb_rewind(sst.db, BAST_MMS_ENTRY_ID);
    if(BFDB_OK == dberr){
        count = app->settings.ch_map.mms_map.num_mms;
        mms = (struct mms_entry_settings_t *)sst.data;
        for(i = 0; i < count; ){
            dberr = bfdb_get(sst.db, sst.data, sizeof(struct mms_entry_settings_t));
            if(BFDB_OK != dberr){
                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                goto ExitFunc;
            }
            j = 0;
            while((j < BAST_MAX_ITEM) && (i < count)){
                app->settings.ch_map.mms_map.mms[i].idx = mms->mms[j].idx;
                app->settings.ch_map.mms_map.mms[i].code_rate = mms->mms[j].code_rate;
                app->settings.ch_map.mms_map.mms[i].modulation = mms->mms[j].modulation;
                app->settings.ch_map.mms_map.mms[i].symbol_rate = mms->mms[j].symbol_rate;
                j++; i++;
            }
            if(i >= count)
                continue;
            dberr = bfdb_next(sst.db, BAST_MMS_ENTRY_ID);
            if(BFDB_OK != dberr){
                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                goto ExitFunc;
            }
        }
    }
ExitFunc:
    return dberr;
}

bfdb_err bast_freq_read(bapp_t *app)
{
    bfdb_err dberr;
    unsigned int i, j;
    struct freq_entry_settings_t * fr;
    unsigned int count;

    dberr = bfdb_rewind(sst.db, BAST_FREQ_ENTRY_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    count = app->settings.ch_map.freq_map.num_freq;
    fr = (struct freq_entry_settings_t*)sst.data;
    for(i = 0; i < count; ){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct freq_entry_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        j = 0;
        while((j < BAST_MAX_ITEM) && (i < count)){
            app->settings.ch_map.freq_map.freq[i].idx = fr->freq[j].idx;
            app->settings.ch_map.freq_map.freq[i].freq_khz = fr->freq[j].freq_khz;
            i++; j++;
        }
        if(i >= count)
            continue;
        dberr = bfdb_next(sst.db, BAST_FREQ_ENTRY_ID);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
    }
ExitFunc:
    return dberr;
}
bfdb_err bast_st_read(bapp_t *app)
{
    bfdb_err dberr;
    unsigned int i;
    unsigned int count;
    struct st_entry_settings_t * st;

    dberr = bfdb_rewind(sst.db, BAST_ST_ENTRY_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    count = app->settings.ch_map.st_map.num_st;
    st = (struct st_entry_settings_t *)sst.data;
    for(i = 0; i < count;){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct st_entry_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        app->settings.ch_map.st_map.st[i].source_id = st->source_id;
        strcpy(app->settings.ch_map.st_map.st[i].name, st->name);
        i++;
        if(i >= count)
            continue;
        dberr = bfdb_next(sst.db, BAST_ST_ENTRY_ID);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
    }
ExitFunc:
    return dberr;
}

bfdb_err bast_vch_read(bapp_t *app)
{
    bfdb_err dberr;
    unsigned i,j;
    unsigned count;
    struct vch_entry_settings_t * vch;

    dberr = bfdb_rewind(sst.db, BAST_VCH_ENTRY_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    count = app->settings.ch_map.vch_map.num_vch;
    vch = (struct vch_entry_settings_t *)sst.data;
    for(i = 0; i < count; ){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct vch_entry_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        app->settings.ch_map.vch_map.vch[i].ch_num = vch->ch_num;
        app->settings.ch_map.vch_map.vch[i].source_id = vch->source_id;
        app->settings.ch_map.vch_map.vch[i].program_num = vch->program_num;
        app->settings.ch_map.vch_map.vch[i].pcr_pid = vch->pcr_pid;
        app->settings.ch_map.vch_map.vch[i].scte127_pid = vch->scte127_pid;
        app->settings.ch_map.vch_map.vch[i].video_pid = vch->video_pid;
        app->settings.ch_map.vch_map.vch[i].video_type = vch->video_type;
        app->settings.ch_map.vch_map.vch[i].ca_pid = vch->ca_pid;
        app->settings.ch_map.vch_map.vch[i].freq_idx = vch->freq_idx;
        app->settings.ch_map.vch_map.vch[i].mms_idx = vch->mms_idx;
        app->settings.ch_map.vch_map.vch[i].vchflags = vch->vchflags;
        app->settings.ch_map.vch_map.vch[i].num_audio = vch->audio_count;
        app->settings.ch_map.vch_map.vch[i].cur_audio = vch->audio_current;
        for(j = 0; j < VCH_MAX_AUDIO; j++){
            app->settings.ch_map.vch_map.vch[i].audio_pid[j] = vch->audio_pid[j];
            app->settings.ch_map.vch_map.vch[i].audio_type[j] = vch->audio_type[j];
            app->settings.ch_map.vch_map.vch[i].audio_lang[j][0] = vch->audio_lang[j][0];
            app->settings.ch_map.vch_map.vch[i].audio_lang[j][1] = vch->audio_lang[j][1];
            app->settings.ch_map.vch_map.vch[i].audio_lang[j][2] = vch->audio_lang[j][2];
        }
#ifdef CONFIG_DVB_SUBTITLE
		app->settings.ch_map.vch_map.vch[i].num_dsub = vch->dsub_count;
		app->settings.ch_map.vch_map.vch[i].cur_dsub = vch->dsub_current;
		for (j=0; j<VCH_MAX_DSUB; j++) {
			app->settings.ch_map.vch_map.vch[i].dsub_pid[j] = vch->dsub_pid[j];
			app->settings.ch_map.vch_map.vch[i].dsub_lang[j][0] = vch->dsub_lang[j][0];
			app->settings.ch_map.vch_map.vch[i].dsub_lang[j][1] = vch->dsub_lang[j][1];
			app->settings.ch_map.vch_map.vch[i].dsub_lang[j][2] = vch->dsub_lang[j][2];
			app->settings.ch_map.vch_map.vch[i].dsub_page[j] = vch->dsub_page[j];
		}
#endif
        i++;
        if(i >= count)
            continue;
        dberr = bfdb_next(sst.db, BAST_VCH_ENTRY_ID);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
    }
ExitFunc:
    return dberr;
}
int bast_channel_map_read(bapp_t *app)
{
    bfdb_err dberr;
    struct channel_map_header_settings_t * header;

    dberr = bfdb_rewind(sst.db, BAST_CHANNEL_MAP_HEADER_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, sst.data, sizeof(struct channel_map_header_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        header = (struct channel_map_header_settings_t *)sst.data;
        app->settings.ch_map.mms_map.num_mms = header->mms_count;
        app->settings.ch_map.freq_map.num_freq = header->freq_count;
        app->settings.ch_map.st_map.num_st = header->st_count;
        app->settings.ch_map.vch_map.num_vch = header->vch_count;

        dberr = bast_mms_read(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        dberr = bast_freq_read(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        dberr = bast_st_read(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
        dberr = bast_vch_read(app);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
            goto ExitFunc;
        }
    }
ExitFunc:
    return dberr;
}

void bast_shared_key_save(struct shared_key_settings_t * key)
{
    bfdb_err dberr;

    dberr = bast_delete_all(BAST_SHARED_KEY_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    /* create new record */
    dberr = bast_add(sst.db, BAST_SHARED_KEY_ID, (uint8_t*)key, sizeof(struct shared_key_settings_t));
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
    return;
}

void bast_upk_generator_save(struct upk_generator_settings_t * gen)
{
    bfdb_err dberr;

    dberr = bast_delete_all(BAST_UPK_GENERATOR_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    /* create new record */
    dberr = bast_add(sst.db, BAST_UPK_GENERATOR_ID, (uint8_t*)gen, sizeof(struct upk_generator_settings_t));
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
    return;
}

int bast_shared_key_read(struct shared_key_settings_t * key)
{
    bfdb_err dberr;
    dberr = bfdb_rewind(sst.db, BAST_SHARED_KEY_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)key, sizeof(struct shared_key_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }
    return dberr;
}

int bast_upk_generator_read(struct upk_generator_settings_t * gen)
{
    bfdb_err dberr;
    dberr = bfdb_rewind(sst.db, BAST_UPK_GENERATOR_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)gen, sizeof(struct upk_generator_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }
    return dberr;
}

void bast_block_save(uint32_t id, uint8_t size, uint8_t *data)
{
    bfdb_err dberr;

    dberr = bast_delete_all(id);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    /* create new record */
    dberr = bast_add(sst.db, id, data, size);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
    return;
}

/*
 * Summary:
 *     Save digital closed captioning settings.
 *      */


void bast_dcc_save(dcc_settings_t *settings)
{
    bfdb_err dberr;

    dberr = bast_delete_all(BAST_DCC_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    /* create new record */
    dberr = bast_add(sst.db, BAST_DCC_ID, (uint8_t*)settings, sizeof(dcc_settings_t));
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
    return;
}
/*
 * Summary:
 *     Read digital closed captioning settings.
 *      */

int bast_dcc_read(dcc_settings_t *settings)
{
    bfdb_err dberr;
    dberr = bfdb_rewind(sst.db, BAST_DCC_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(dcc_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }
    return dberr;
}

/*
 * Summary:
 *     Save ratings settings.
 *      */
void bast_ratings_save(ratings_settings_t *settings)
{
    bfdb_err dberr;

    dberr = bast_delete_all(BAST_RATINGS_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }
    /* create new record */
    dberr = bast_add(sst.db, BAST_RATINGS_ID, (uint8_t*)settings, sizeof(ratings_settings_t));
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
    return;
}
/*
 * Summary:
 *     Read ratings settings.
 *      */

int bast_ratings_read(ratings_settings_t *settings)
{
    bfdb_err dberr;
    dberr = bfdb_rewind(sst.db, BAST_RATINGS_ID);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(ratings_settings_t));
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }
    return dberr;
}

/*
 * Summary:
 *     Save RRT settings.
 *      */
void bast_rrt_save(rrt_settings_t *settings)
{
    bfdb_err dberr;
    uint32_t size;

    dberr = bast_delete_all(BAST_RRT_SETTINGS_ID);
    dberr |= bast_delete_all(BAST_RRT_DIM_0);
    dberr |= bast_delete_all(BAST_RRT_DIM_1);
    dberr |= bast_delete_all(BAST_RRT_DIM_2);
    dberr |= bast_delete_all(BAST_RRT_TBL_0);
    dberr |= bast_delete_all(BAST_RRT_TBL_1);
    dberr |= bast_delete_all(BAST_RRT_TBL_2);
    dberr |= bast_delete_all(BAST_RRT_TBL_3);
    dberr |= bast_delete_all(BAST_RRT_TBL_4);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }

    size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
    /* create new record */
    dberr = bast_add(sst.db, BAST_RRT_SETTINGS_ID, (uint8_t*)settings, size);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_DIM_0, (uint8_t*)settings->ratings_rrt, 0xFF);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_DIM_1, (uint8_t*)&(settings->ratings_rrt[0xFF]),
                     sizeof(unsigned short) * MAX_RRT_DIM/2);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_DIM_2, (uint8_t*)&(settings->ratings_rrt[0xFF * 2]),2);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_TBL_0, (uint8_t*)settings->rrt, 0xFF);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_TBL_1, (uint8_t*)&(settings->rrt[0xFF]), 0xFF);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_TBL_2, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_TBL_3, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
    dberr = bast_add(sst.db, BAST_RRT_TBL_4, (uint8_t*)&(settings->rrt[4*0xFF]),4);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
    return;
}
/*
 * Summary:
 *     Read RRT settings.
 *      */

int bast_rrt_read(rrt_settings_t *settings)
{
    bfdb_err dberr;
    uint32_t size;

    dberr = bfdb_rewind(sst.db, BAST_RRT_SETTINGS_ID);
    if(BFDB_OK == dberr){
        size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
        dberr = bfdb_get(sst.db, (uint8_t*)settings, size);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_0);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)settings->ratings_rrt, 0xFF);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_1);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[0xFF]),0xFF);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_2);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[2*0xFF]),2);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_0);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)settings->rrt, 0xFF);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_1);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[0xFF]),0xFF);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_2);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_3);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_4);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[4*0xFF]),4);
        if(BFDB_OK != dberr){
            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    }

    return dberr;
}

/*
 * Summary:
 * Save menu settings
 */
void bast_screen_save(bapp_t *app)
{
    bfdb_err dberr;
    struct screen_settings_t *screen;

	screen = (struct screen_settings_t *)sst.data;
	screen->sound = app->settings.sound; 
	screen->picture = app->settings.picture; 
	screen->language = app->settings.language ; 
	screen->wiz_completed = app->settings.wiz_completed ; 
	screen->ratings_lock = app->settings.ratings_lock ; 
	screen->ratings_tv = app->settings.ratings_tv ; 
	screen->ratings_movies = app->settings.ratings_movies;
	screen->content_d = app->settings.content_d ; 
	screen->content_l =  app->settings.content_l ; 
	screen->content_s = app->settings.content_s ; 
	screen->content_v = app->settings.content_v ; 
	screen->captions_basic = app->settings.dcc.captions_basic ;
	screen->captions_font = app->settings.dcc.captions_font ; 
	screen->captions_font_size = app->settings.dcc.captions_font_size ; 
	screen->captions_font_style = app->settings.dcc.captions_font_style ; 
	screen->captions_font_color = app->settings.dcc.captions_font_color ; 
	screen->captions_font_opacity = app->settings.dcc.captions_font_opacity ; 
	screen->captions_back_color = app->settings.dcc.captions_back_color ; 
	screen->captions_back_opacity = app->settings.dcc.captions_back_opacity ; 
	screen->captions_edge_color = app->settings.dcc.captions_edge_color ; 
	screen->captions_edge_type = app->settings.dcc.captions_edge_type ; 
	screen->rrt_status = app->settings.rrt_status ; 
	screen->time_zone = app->settings.time_zone ; 
	screen->dst =  app->settings.dst ; 
	screen->last_rrt_id = app->settings.last_rrt_id ; 
	screen->pin = app->settings.pin;
	screen->auto_power = app->settings.auto_power;	
	screen->auto_power_off = app->settings.auto_power_off;

    dberr = bast_delete_all(BAST_SCREEN_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }

    dberr = bast_add(sst.db, BAST_SCREEN_ID, (uint8_t*)screen, sizeof(struct screen_settings_t));
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
	return ;
}

/*
 * Summary:
 * Read menu settings
 */
int bast_screen_read(bapp_t *app)
{
	bfdb_err dberr;
	struct screen_settings_t *screen;
	
	dberr = bfdb_rewind(sst.db, BAST_SCREEN_ID);
	if (BFDB_OK == dberr) {
		dberr = bfdb_get(sst.db, sst.data, sizeof(struct screen_settings_t));
		if (dberr != BFDB_OK) {
			BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
			goto ExitFunc;
		}
		screen = (struct screen_settings_t *)sst.data;
		app->settings.sound = screen->sound;
		app->settings.picture = screen->picture;
		app->settings.language = screen->language;
		app->settings.wiz_completed = screen->wiz_completed;
		app->settings.ratings_lock = screen->ratings_lock;
		app->settings.ratings_tv = screen->ratings_tv;
		app->settings.content_d = screen->content_d;
		app->settings.content_l = screen->content_l;
		app->settings.content_s = screen->content_s;
		app->settings.content_v = screen->content_v;
		app->settings.ratings_movies = screen->ratings_movies;
		app->settings.dcc.captions_basic = screen->captions_basic;
		app->settings.dcc.captions_font = screen->captions_font;
		app->settings.dcc.captions_font_size = screen->captions_font_size;
		app->settings.dcc.captions_font_style = screen->captions_font_style;
		app->settings.dcc.captions_font_color = screen->captions_font_color;
		app->settings.dcc.captions_font_opacity = screen->captions_font_opacity;
		app->settings.dcc.captions_back_color = screen->captions_back_color;
		app->settings.dcc.captions_back_opacity = screen->captions_back_opacity;
		app->settings.dcc.captions_edge_color = screen->captions_edge_color;
		app->settings.dcc.captions_edge_type = screen->captions_edge_type;
		app->settings.rrt_status = screen->rrt_status;
		app->settings.time_zone = screen->time_zone;
		app->settings.dst = screen->dst;
		app->settings.last_rrt_id = screen->last_rrt_id;
		app->settings.pin = screen->pin;
		app->settings.auto_power = screen->auto_power;
		app->settings.auto_power_off = screen->auto_power_off;
	}
ExitFunc:	
	return dberr;
}