Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

bapp.c @ 29

Last change on this file since 29 was 2, checked in by phkim, 11 years ago

1.phkim

revision copy newcon3sk r27

Property svn:executable set to *

File size: 83.3 KB

Line
1	/***************************************************************************
2	* Copyright (c) 2003-2006, Broadcom Corporation
3	* All Rights Reserved
4	* Confidential Property of Broadcom Corporation
5	*
6	* THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7	* AGREEMENT BETWEEN THE USER AND BROADCOM. YOU HAVE NO RIGHT TO USE OR
8	* EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9	*
10	* $brcm_Workfile: $
11	* $brcm_Revision: $
12	* $brcm_Date: $
13	*
14	* Module Description:
15	*
16	* Revision History:
17	*
18	* $brcm_Log: $
19	*
20	***************************************************************************/
21
22	#include "bapp.h"
23	#include "bgfx.h"
24	#include "bstd.h"
25	#include "bos.h"
26	#include "ministd.h"
27	#include "cache_util.h"
28	#include "bapp_palette.h"
29	#include "bsettop_graphics.h"
30	static void bapp_first_pts_callback(void);
31	static void bapp_seq_hdr_callback(void);
32	#include "bapp_settings.h"
33	#ifdef CONFIG_SCREENSAVER
34	#include "logo.c"
35	#endif
36
37	BDBG_MODULE(bapp); /* Register software module with debug interface */
38
39	#define BAPP_MAX_VOLUME 32
40
41	#define BAPP_VCHIP_TIMEOUT (7000) /* Milliseconds */
42	#define BAPP_RATINGS_EVAL_DELAY (500) /* Milliseconds */
43	#define BAPP_DIAG_TIMEOUT 3 /* Seconds */
44
45	#define BAPP_VCHIP_MSG BDBG_WRN
46	#define TIME_APP_DRAWING
47	static bgfx_font_t s_font[eFONT_SIZE_MAX];
48
49	static void bapp_eval_state(bapp_t *p_app,bapp_state_t new_state);
50	static int bapp_channel_hunt(bapp_t *p_app);
51	static void bapp_standby(bapp_t *p_app, bool power);
52	static void bapp_new_screen(bapp_t *p_app);
53
54	#ifdef CONFIG_8BIT_FONT
55	extern unsigned int g_FrancophilB_22_aa_size;
56	extern const unsigned char g_FrancophilB_22_aa[];
57	extern unsigned int g_FrancophilB_28_aa_size;
58	extern const unsigned char g_FrancophilB_28_aa[];
59	extern unsigned int g_FrancophilB_40_aa_size;
60	extern const unsigned char g_FrancophilB_40_aa[];
61	#else
62	extern unsigned int g_FrancophilB_22_mono_size;
63	extern const unsigned char g_FrancophilB_22_mono[];
64	extern unsigned int g_FrancophilB_28_mono_size;
65	extern const unsigned char g_FrancophilB_28_mono[];
66	extern unsigned int g_FrancophilB_40_mono_size;
67	extern const unsigned char g_FrancophilB_40_mono[];
68	#endif
69	extern int bscreen_eas_text_scrolling_info(bapp_t *p_app,
70	unsigned char *eas_pkt, unsigned int size);
71
72	/*
73	* Maps value in remote strap registers to bsettop_user_io.c remote type
74	*/
75	const static unsigned int s_remote_type_map[] =
76	{
77	5,
78	4,
79	6,
80	0
81	};
82
83	/*
84	* Global app reference used by a couple callbacks to reference the application.
85	*/
86
87	bapp_t *s_p_app = NULL;
88
89	static bscreen_t g_screens[] =
90	{ /* title_text_id desc_text_id help_text_id top_banner_height num_buttons idle_timeout p_button_array (* draw)() (* handle_event)() local_state */
91	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MENU_HELP1, 0, 0, 0, 0, 0, eSCREEN_NULL, 0, bscreen_banner_draw, screen_banner_event, (uint32_t)&g_banner_state},
92	{ eTEXT_MAIN_MENU, eTEXT_MAX, eTEXT_MENU_HELP1, eMENU_TITLE_AREA_HEIGHT_0_LINE, 0, 0, g_buttons_main_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_main, bscreen_default_draw, bscreen_default_event, 0},
93	{ eTEXT_PICTURE_MENU, eTEXT_PICTURE_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, g_buttons_hd_output_options_config_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_hd_output_options_config, bscreen_default_draw, screen_hd_output_options_config_event, 0},
94	{ eTEXT_SOUND_MENU, eTEXT_SOUND_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_sound_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_sound, bscreen_default_draw, screen_sound_event, 0},
95	{ eTEXT_AV_MENU, eTEXT_AV_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_av_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_av, bscreen_default_draw, bscreen_default_event, 0},
96	{ eTEXT_ANTENNA_MENU, eTEXT_ANTENNA_MENU_DESC, eTEXT_MENU_HELP6, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_antenna_draw, screen_antenna_event, 0},
97	{ eTEXT_CAPTIONS_MENU, eTEXT_CAPTIONS_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, g_buttons_captions_advanced_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_advanced, bscreen_default_draw, screen_captions_advanced_event, 0},
98	#if 0
99	{ eTEXT_CAPTIONS_ON_OFF_MENU, eTEXT_CAPTIONS_ON_OFF_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_on_off_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_on_off, bscreen_default_draw, screen_captions_on_off_event, 0},
100	{ eTEXT_CAPTIONS_BASIC_MENU, eTEXT_CAPTIONS_BASIC_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_basic_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_basic, bscreen_default_draw, screen_captions_basic_event, 0},
101	{ eTEXT_CAPTIONS_ADVANCED_MENU, eTEXT_CAPTIONS_ADVANCED_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_advanced_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_advanced, bscreen_default_draw, screen_captions_advanced_event, 0},
102	#endif
103	{ eTEXT_CAPTIONS_FONT_OPTIONS_MENU,eTEXT_CAPTIONS_FONT_OPTIONS_MENU_DESC,eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_font_options_num,SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_font_options,bscreen_default_draw, screen_captions_font_options_event, 0},
104	{ eTEXT_CAPTIONS_BACK_OPTIONS_MENU,eTEXT_CAPTIONS_BACK_OPTIONS_MENU_DESC,eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_back_options_num,SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_back_options,bscreen_default_draw, screen_captions_back_options_event, 0},
105	{ eTEXT_CAPTIONS_FONT_MENU, eTEXT_CAPTIONS_FONT_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_font_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_font, bscreen_default_draw, screen_captions_font_event, 0},
106	{ eTEXT_CAPTIONS_FONT_SIZE_MENU, eTEXT_CAPTIONS_FONT_SIZE_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_font_size_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_font_size, bscreen_default_draw, screen_captions_font_size_event, 0},
107	{ eTEXT_CAPTIONS_FONT_STYLE_MENU, eTEXT_CAPTIONS_FONT_STYLE_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_font_style_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_font_style, bscreen_default_draw, screen_captions_font_style_event, 0},
108	{ eTEXT_CAPTIONS_FONT_COLOR_MENU, eTEXT_CAPTIONS_FONT_COLOR_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_font_color_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_font_color, bscreen_default_draw, screen_captions_font_color_event, 0},
109	{ eTEXT_CAPTIONS_FONT_OPACITY_MENU,eTEXT_CAPTIONS_FONT_OPACITY_MENU_DESC,eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_opacity_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_font_opacity,bscreen_default_draw, screen_captions_font_opacity_event, 0},
110	{ eTEXT_CAPTIONS_BACK_COLOR_MENU, eTEXT_CAPTIONS_BACK_COLOR_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_color_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_color, bscreen_default_draw, screen_captions_back_color_event, 0},
111	{ eTEXT_CAPTIONS_BACK_OPACITY_MENU,eTEXT_CAPTIONS_BACK_OPACITY_MENU_DESC,eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_opacity_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_back_opacity,bscreen_default_draw, screen_captions_back_opacity_event, 0},
112	{ eTEXT_CAPTIONS_EDGE_COLOR_MENU ,eTEXT_CAPTIONS_EDGE_COLOR_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_edge_color_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_edge_color, bscreen_default_draw, screen_captions_edge_color_event, 0},
113	{ eTEXT_CAPTIONS_EDGE_TYPE_MENU ,eTEXT_CAPTIONS_EDGE_TYPE_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_edge_type_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_edge_type, bscreen_default_draw, screen_captions_edge_type_event, 0},
114	{ eTEXT_CAPTIONS_RESET_MENU, eTEXT_CAPTIONS_RESET_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_captions_reset_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_captions_reset, bscreen_default_draw, screen_captions_reset_event, 0},
115	{ eTEXT_LANGUAGE_MENU, eTEXT_LANGUAGE_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_language_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_language, bscreen_default_draw, screen_language_event, 0},
116	#ifdef CONFIG_EIA_708
117	{ eTEXT_SETUP_MENU, eTEXT_SETUP_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_2_LINE-4, 0, 0, g_buttons_setup_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_setup, bscreen_default_draw, screen_setup_event, 0},
118	#else
119	{ eTEXT_SETUP_MENU, eTEXT_SETUP_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, g_buttons_setup_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_setup, bscreen_default_draw, screen_setup_event, 0},
120	#endif
121	{ eTEXT_WIZ_CH_SCAN_MENU, eTEXT_WIZ_CH_SCAN_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_3_LINE, 0, 0, g_buttons_ch_scan_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ch_scan, bscreen_wiz_ch_scan_draw, screen_ch_scan_event, 0},
122	{ eTEXT_CH_SCAN_PROGRESS_MENU, eTEXT_CH_SCAN_PROGRESS_MENU_DESC, eTEXT_MENU_HELP4, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_ch_scan_progress_draw, screen_ch_scan_progress_event, 0},
123	{ eTEXT_RESET_MENU, eTEXT_RESET_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, g_buttons_reset_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_reset, bscreen_default_draw, screen_reset_event, 0},
124	{ eTEXT_WIZ_WELCOME_MENU, eTEXT_WIZ_WELCOME_MENU_DESC, eTEXT_MENU_HELP3, eMENU_TITLE_AREA_HEIGHT_3_LINE, 0, 0, g_buttons_wiz_welcome_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wiz_welcome, bscreen_wiz_welcome_draw, screen_wiz_welcome_event, 0},
125	{ eTEXT_WIZ_LANGUAGE_MENU, eTEXT_LANGUAGE_MENU_DESC, eTEXT_MENU_HELP8, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_wiz_language_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wiz_language, bscreen_default_draw, screen_wiz_language_event, 0},
126	{ eTEXT_WIZ_CH_SCAN_MENU, eTEXT_WIZ_CH_SCAN_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_3_LINE, 0, 0, g_buttons_wiz_ch_scan_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wiz_ch_scan, bscreen_wiz_ch_scan_draw, screen_wiz_ch_scan_event, 0},
127	{ eTEXT_WIZ_PIN_NEW_MENU, eTEXT_WIZ_PIN_NEW_MENU_DESC, eTEXT_MENU_HELP7, eMENU_TITLE_AREA_HEIGHT_4_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_pin_draw, screen_pin_event, 0},
128	{ eTEXT_PIN_CONFIRM_MENU, eTEXT_PIN_CONFIRM_MENU_DESC, eTEXT_MENU_HELP7, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_pin_draw, screen_pin_event, 0},
129	{ eTEXT_MISMATCHED_PINS_MENU, eTEXT_MISMATCHED_PINS_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_wiz_mismatched_pins_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wiz_mismatched_pins, bscreen_default_draw, screen_wrong_pin_event, 0},
130	{ eTEXT_WIZ_DONE_MENU, eTEXT_WIZ_DONE_MENU_DESC, eTEXT_MENU_HELP6, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, g_buttons_wiz_done_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wiz_done, bscreen_wiz_done_draw, screen_wiz_done_event, 0},
131	{ eTEXT_AUTO_POWER_MENU, eTEXT_AUTO_POWER_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_auto_power_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_auto_power, bscreen_auto_power_draw, screen_auto_power_event, 0},
132	{ eTEXT_RATINGS_MENU, eTEXT_RATINGS_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, g_buttons_ratings_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings, bscreen_default_draw, screen_ratings_event, 0},
133	{ eTEXT_RATINGS_LOCK_MENU, eTEXT_RATINGS_LOCK_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_ratings_lock_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings_lock, bscreen_default_draw, screen_ratings_lock_event, 0},
134	{ eTEXT_RATINGS_LIMITS_MENU, eTEXT_RATINGS_LIMITS_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, g_buttons_ratings_limits_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings_limits, bscreen_default_draw, screen_ratings_limits_event, 0},
135	{ eTEXT_RATINGS_TV_MENU, eTEXT_RATINGS_TV_MENU_DESC, eTEXT_MENU_HELP10,eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_ratings_tv_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings_tv, bscreen_default_draw, screen_ratings_tv_event, 0},
136	{ eTEXT_RATINGS_MOVIES_MENU, eTEXT_RATINGS_MOVIES_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_ratings_movies_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings_movies, bscreen_default_draw, screen_ratings_movies_event, 0},
137	{ eTEXT_RATINGS_RRT_DIM_MENU, eTEXT_RATINGS_RRT_DIM_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, MAX_RRT_DIM_BUTTONS, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings_rrt_dim, bscreen_rrt_dim_draw, screen_ratings_rrt_dim_event, 0},
138	{ eTEXT_RATINGS_RRT_VAL_MENU, eTEXT_RATINGS_RRT_VAL_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, MAX_RRT_VAL_BUTTONS, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings_rrt_val, bscreen_rrt_val_draw, screen_ratings_rrt_val_event, 0},
139	{ eTEXT_RATINGS_RRT_UPDATE_MENU, eTEXT_RATINGS_RRT_UPDATE_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_ratings_rrt_update_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_ratings_rrt_update, bscreen_default_draw, screen_ratings_rrt_update_event, 0},
140	{ eTEXT_PIN_ENTER_MENU, eTEXT_PIN_ENTER_MENU_DESC, eTEXT_MENU_HELP9, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_pin_draw, screen_pin_event, 0},
141	{ eTEXT_PIN_ENTER_MENU, eTEXT_PIN_ENTER_MENU_DESC, eTEXT_MENU_HELP7, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_pin_draw, screen_pin_event, 0},
142	{ eTEXT_PIN_ENTER_MENU, eTEXT_PIN_ENTER_MENU_DESC, eTEXT_MENU_HELP7, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_pin_draw, screen_pin_event, 0},
143	{ eTEXT_PIN_NEW_MENU, eTEXT_PIN_NEW_MENU_DESC, eTEXT_MENU_HELP7, eMENU_TITLE_AREA_HEIGHT_2_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_pin_draw, screen_pin_event, 0},
144	{ eTEXT_PIN_CONFIRM_MENU, eTEXT_PIN_CONFIRM_MENU_DESC, eTEXT_MENU_HELP7, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_pin_draw, screen_pin_event, 0},
145	{ eTEXT_WRONG_PIN_LIVE_MENU, eTEXT_WRONG_PIN_LIVE_MENU_DESC, eTEXT_MENU_HELP8, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_wrong_pin_live_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wrong_pin_live, bscreen_default_draw, screen_wrong_pin_event, 0},
146	{ eTEXT_WRONG_PIN_MENU_MENU, eTEXT_WRONG_PIN_MENU_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_wrong_pin_ratings_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wrong_pin_ratings, bscreen_default_draw, screen_wrong_pin_event, 0},
147	{ eTEXT_WRONG_PIN_MENU_MENU, eTEXT_WRONG_PIN_MENU_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_wrong_pin_reset_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_wrong_pin_reset, bscreen_default_draw, screen_wrong_pin_event, 0},
148	{ eTEXT_MISMATCHED_PINS_MENU, eTEXT_MISMATCHED_PINS_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_mismatched_pins_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_mismatched_pins, bscreen_default_draw, screen_wrong_pin_event, 0},
149	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, BANNER_SMALL_TIMEOUT, eSCREEN_NULL, 0, bscreen_banner_draw, screen_banner_event, (uint32_t)&g_banner_state},
150	{ eTEXT_GUIDE_TITLE, eTEXT_MAX, eTEXT_MENU_HELP11,eMENU_TITLE_AREA_HEIGHT_0_LINE, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_guide_draw, screen_guide_event, (uint32_t)&g_guide_state},
151	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, 0, eSCREEN_NULL, 0, bscreen_screensaver_draw, screen_screensaver_event, (uint32_t)&g_screensaver_state},
152	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, 0, eSCREEN_NULL, 0, bscreen_power_off_draw, screen_power_off_event, 0},
153	{ eTEXT_TIMEZONE_MENU, eTEXT_TIMEZONE_MENU_DESC, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_timezone_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, g_buttons_timezone, bscreen_default_draw, bscreen_timezone_event, 0},
154	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_NULL, 0, bscreen_status_draw, bscreen_status_event, 0},
155	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_diag_menu_draw, bscreen_diag_menu_event, 0},
156	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_sys_info_draw, bscreen_sys_info_event, 0},
157	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_dta_status_draw, bscreen_dta_status_event, 0},
158	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_mso_info_draw, bscreen_mso_info_event, 0},
159	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_tuner_status_draw, bscreen_tuner_status_event, 0},
160	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_ch_status_draw, bscreen_ch_status_event, 0},
161	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_ch_map_status_draw, bscreen_ch_map_status_event, 0},
162	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_msg_status_draw, bscreen_msg_status_event, 0},
163	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_code_objects_draw, bscreen_code_objects_event, 0},
164	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_code_download_draw, bscreen_code_download_event, 0},
165	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_decoder_status_draw, bscreen_decoder_status_event, 0},
166	// { eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, bscreen_status_draw, bscreen_status_event, 0},
167	{ eTEXT_VIDEO_OUTPUT_FORMAT_BUTTON, eTEXT_VIDEO_OUTPUT_FORMAT, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_video_output_format_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_BANNER, g_buttons_video_output_format, bscreen_default_draw, bscreen_video_format_event, 0},
168	{ eTEXT_VIDEO_OUTPUT_FORMAT_CONFIRM_BUTTON, eTEXT_VIDEO_OUTPUT_FORMAT_CONFIRM, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_video_output_format_confirm_num, SCREEN_DEFAULT_TIMEOUT, eSCREEN_BANNER, g_buttons_video_output_format_confirm, bscreen_default_draw, bscreen_confirm_change_event, 0},
169	#ifdef CONFIG_FACTORY_TEST
170	{ eTEXT_MAX, eTEXT_MAX, eTEXT_MAX, 0, 0, 0, 0, SCREEN_DEFAULT_TIMEOUT, eSCREEN_MAX, 0, factory_draw, factory_handle_event, 0},
171	#endif
172	{ eTEXT_SD_CONFIG_OPTIONS_BUTTON, eTEXT_SD_CONFIG_OPTIONS, eTEXT_MENU_HELP2, eMENU_TITLE_AREA_HEIGHT_1_LINE, 0, 0, g_buttons_sd_output_options_config_num,SCREEN_DEFAULT_TIMEOUT, eSCREEN_BANNER, g_buttons_sd_output_options_config, bscreen_default_draw, screen_sd_output_options_config_event, 0},
173	};
174
175	const unsigned char g_screens_num = sizeof(g_screens)/sizeof(g_screens[0]);
176
177	void bl_write(void)
178	{
179	}
180	static bgfx_io_t s_io =
181	{
182	bin_read,
183	bin_tell,
184	bin_set
185	};
186
187
188	#if defined(CONFIG_GFX_ARGB32) && !defined(SIMULATOR)
189	static bgfx_hw_t s_gfx_hw = {(BGFX_HW_FILL)bsurface_fill, (BGFX_HW_BLIT)bsurface_blit_surface, (BGFX_HW_SURFACE_CREATE)bsurface_create_surface};
190	static bgfx_hw_t *s_p_gfx_hw = &s_gfx_hw;
191	#else
192	static bgfx_hw_t *s_p_gfx_hw = NULL;
193	#endif
194
195	#ifdef BCM_DEBUG
196	static const char *s_chm_evt_str[] =
197	{
198	"CHM_EVT_CANCEL",
199	"CHM_EVT_DONE",
200	"CHM_EVT_REDRAW",
201	"CHM_EVT_PROGRESS",
202	"CHM_EVT_SIGNAL",
203	"CHM_EVT_DOWNLOAD",
204	"CHM_EVT_EAS",
205	"CHM_EVT_CA",
206	"CHM_EVT_NETWORK",
207	"CHM_EVT_STATUS",
208	"CHM_EVT_AV_MUTE",
209	"CHM_EVT_ACTIVATION",
210	"CHM_EVT_CONFIGURATION",
211	"CHM_EVT_VCT_ID",
212	"CHM_EVT_LOCATION",
213	"CHM_EVT_TIMEZONE",
214	"CHM_EVT_PHONENUMBER",
215	"CHM_EVT_RESET",
216	"CHM_EVT_SAVE",
217	"CHM_EVT_TIME",
218	"CHM_EVT_PAIRING",
219	"eCHM_EVT_RRT",
220	"eCHM_EVT_CAD",
221	"eCHM_EVT_BLOCK",
222	"eCHM_EVT_AMM",
223	"eCHM_EVT_SCC_AMM",
224	"eCHM_EVT_CAP_SERVICE",
225	"eCHM_EVT_SET_SCREEN",
226	};
227	#endif
228
229	/*
230	Summary:
231	Reset Site Error Count. This function will be used by other DIG section as well.
232	*/
233	void bapp_set_hd_configuration(bapp_t *p_app)
234	{
235	bdisplay_settings s;
236
237	bdisplay_get(p_app->display,&s);
238	if ((s.hd_options != p_app->settings.hd_config.hd_options) \|\|
239	(s.format != p_app->settings.hd_config.output_format)) {
240	s.format = p_app->settings.hd_config.output_format;
241	s.hd_options = p_app->settings.hd_config.hd_options;
242	// note that we also set sd options */
243	s.sd_options = p_app->settings.sd_options;
244	bdisplay_set(p_app->display,&s);
245	}
246	}
247
248	/*
249	Summary:
250	Set the LED mode based on the state and settings.
251	*/
252	void bapp_led_set_mode(bapp_t *p_app)
253	{
254	enum led_mode_t mode = led_off_mode;
255
256	if (!p_app->power)
257	{
258	mode = led_off_mode;
259	} else
260	{
261	switch (p_app->state)
262	{
263	case eAPP_STATE_HUNT: mode = led_hunt_mode; break;
264	case eAPP_STATE_PENDING: mode = led_pending_init_mode; break;
265	case eAPP_STATE_NORMAL: mode = led_on_mode; break;
266	case eAPP_STATE_DOWNLOAD: mode = led_download_mode; break;
267	case eAPP_STATE_FACTORY:
268	case eAPP_STATE_DEFAULT:
269	case eAPP_STATE_DONE:
270	break;
271	}
272	}
273
274	if (mode == p_app->led_mode)
275	{
276	return;
277	}
278
279	p_app->led_mode = mode;
280	led_set_mode(mode);
281	}
282
283	/*
284	* Flush cache
285	*/
286
287	void bapp_flush_screen(bapp_t *p_app)
288	{
289	#ifndef CONFIG_GFX_ARGB32
290	unsigned int *palette;
291	int width,height,pitch;
292	#endif
293	if (p_app->settings.av_mute && (p_app->screen_id != eSCREEN_POWER_OFF))
294	{
295	BDBG_WRN(("%s av_mute = %d, screen = %d\n",__FUNCTION__,p_app->settings.av_mute,p_app->screen_id ));
296	return;
297	}
298
299	if (bgraphics_sync(p_app->graphics, false) == berr_timeout)
300	{
301	BDBG_WRN(("bgraphics_sync timeout, try again.\n" ));
302	if (bgraphics_sync(p_app->graphics, false) == berr_timeout)
303	{
304	BDBG_ERR(("bgraphics_sync timeouted out again.\n" ));
305	}
306	}
307	#ifndef CONFIG_GFX_ARGB32
308	bgraphics_get_framebuffer(p_app->graphics,(void)&p_app->osd_mem,(unsigned int )&palette,&width,&height,&pitch);
309	p_app->osd_mem_size = pitch * height;
310	p_app->width = width;
311	p_app->height = height;
312	p_app->surf.surface.buf = p_app->osd_mem;
313	#endif
314	}
315
316	/*
317	* * flush SD or HD or both graphics
318	* */
319	void bapp_flush_screen_partial(bapp_t *p_app, int id)
320	{
321	#ifdef CONFIG_GFX_ARGB32
322	if (bgraphics_sync_partial(p_app->graphics, id, false) == berr_timeout) {
323	BDBG_WRN(("bgraphics_sync_hd timeout, try again"));
324	if (bgraphics_sync_partial(p_app->graphics, id, false) == berr_timeout) {
325	BDBG_ERR(("bgraphics_sync timeout again."));
326	}
327	}
328	#else
329	bapp_flush_screen(p_app);
330	#endif
331	}
332
333	/*
334	Summary:
335	Set volume level
336	Description:
337	Set Volume level (range 0(full) - s_volume_num)
338	*/
339	void bapp_set_audio_volume(bapp_t *p_app, uint8_t level)
340	{
341	baudio_decode_config config;
342
343	if (p_app->system_mute)
344	return;
345
346	if (level == p_app->audio_vol) return;
347
348	if (level > BAPP_MAX_VOLUME)
349	level = BAPP_MAX_VOLUME;
350
351	baudio_decode_get_config(p_app->audio, &config);
352	config.left_volume = config.right_volume = level;
353	baudio_decode_set_config(p_app->audio, &config);
354	p_app->audio_vol = level;
355	}
356
357	/*
358	Summary:
359	Mute audio
360	Description:
361	Mute audio when enable is non-zero.
362	*/
363	void bapp_audio_mute(bapp_t *p_app, int mute)
364	{
365	baudio_decode_config config;
366
367	if (p_app->system_mute)
368	return;
369
370	if ((mute && p_app->is_muted) \|\| (!mute && !p_app->is_muted) \|\| p_app->settings.av_mute \|\| (p_app->audio_mute && p_app->is_muted))
371	return;
372
373	baudio_decode_get_config(p_app->audio, &config);
374	config.mute = (mute == 0) ? false : true;
375	if (baudio_decode_set_config(p_app->audio, &config) != b_ok)
376	{
377	BDBG_WRN(("%s baudio_decode_set_config mute = %d failed\n",__FUNCTION__,config.mute));
378	}
379	else
380	p_app->is_muted = mute;
381	}
382
383	/*
384	Summary:
385	Mute video
386	Description:
387	Mute video only
388	*/
389	void bapp_video_mute(bapp_t *p_app, int mute)
390	{
391	bdecode_config cfg;
392
393	bdecode_get_config(p_app->decode,&cfg);
394	if (mute)
395	cfg.mute = 1;
396	else
397	cfg.mute = 0;
398
399	bdecode_set_config(p_app->decode,&cfg);
400	}
401
402	/*
403	Summary:
404	Mute both audio and video.
405	Description:
406	Mute both audio and video when enable is non-zero.
407	*/
408	void bapp_av_mute(bapp_t *p_app, int mute)
409	{
410	bapp_audio_mute(p_app,mute);
411	bapp_video_mute(p_app,mute);
412
413	if (mute)
414	{
415	bapp_sync(p_app);
416	bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
417	bapp_flush_screen(p_app);
418	}
419
420	/* 'reset' feature will invoke setup wizard. it shouldn't mute graphics. see screen_reset_event */
421	p_app->settings.av_mute = (mute==1)?mute:0;
422	p_app->settings_dirty \|= DIRTY_MISC;
423	}
424	/*
425	Summary:
426	Configure the video output mode.
427	Description:
428	Configure the video output mode.
429	*/
430	void bapp_output_mode(bapp_t *p_app, int widescreen)
431	{
432	#if 0 /* JPF TODO SET OUTPUT MODE- extend to HD */
433	bdecode_config cfg;
434	bdecode_get_config(p_app->decode,&cfg);
435	if (widescreen)
436	{
437	BDBG_WRN(("Widescreen (%d)\n", widescreen));
438	cfg.widescreen = widescreen;
439	} else
440	{
441	BDBG_WRN(("Full Screen...\n"));
442	cfg.widescreen = 0;
443	}
444	bdecode_set_config(p_app->decode,&cfg);
445	#endif
446	}
447
448	/*
449	Summary:
450	Apply the current settings.
451	Description:
452	Apply the current settings. Restart decode.
453	*/
454	static void bapp_apply_settings(bapp_t *p_app)
455	{
456	p_app->audio_vol = p_app->settings.audio_vol;
457	bapp_set_audio_volume(p_app, p_app->audio_vol);
458	}
459
460	/*
461	Summary:
462	Reset the closed captioning settings to the default values.
463	*/
464	void bapp_reset_hd_config_settings(bapp_t *p_app)
465	{
466	p_app->settings.hd_config.output_format = bdisplay_format_auto;
467	p_app->settings.hd_config.hd_options = bdisplay_hd_output_options_auto;
468	p_app->settings.hd_config.sharpness = 0; /* soft */
469
470	}
471
472	/*
473	Summary:
474	Reset the current user settings
475	Description:
476	Reset the current user settings. Note this does not change them in flash.
477	*/
478	void bapp_reset_settings(bapp_t *p_app)
479	{
480	memset(&p_app->settings, 0, sizeof(p_app->settings));
481
482	ch_map_init(&(p_app->settings.ch_map),&(p_app->ch_map_mutex));
483	p_app->settings.network_PID = CONFIG_NETWORK_PID;
484	p_app->settings.VCT_ID = CONFIG_DEF_VCT_ID;
485	p_app->settings.EMM_PID = CONFIG_DEF_EMM_PID;
486	/* this will make sure volume is reset to default from UI */
487	p_app->settings.audio_vol = BAPP_MAX_VOLUME;
488	p_app->audio_vol = BAPP_MAX_VOLUME;
489	p_app->settings.pin = DEFAULT_PIN;
490	p_app->settings.activated = 1;
491	p_app->settings.psi_scan = 1;
492	p_app->settings.wiz_completed = 1;
493	bapp_reset_hd_config_settings(p_app);
494	p_app->settings.sd_options = bdisplay_sd_output_options_full;
495	}
496
497	/*
498	Summary:
499	Load current settings from NVM
500	*/
501	static void bapp_load_settings(bapp_t *p_app)
502	{
503	int result = 0;
504
505	ch_map_init(&(p_app->settings.ch_map), &(p_app->ch_map_mutex));
506	ch_map_reset(&(p_app->settings.ch_map));
507	p_app->settings_dirty = 0;
508
509	if (bos_acquire_mutex(p_app->settings.ch_map.p_mutex, 45) == b_ok)
510	{
511	if (bos_acquire_mutex(&(s_p_app->flash_mutex), 250) == b_ok)
512	{
513	result = bast_channel_read(p_app);
514	if (0 == result)
515	{
516	result = bast_misc_read(p_app);
517	if (0 == result) {
518	result = bast_channel_map_read(p_app);
519	if (0 == result)
520	{
521	result = bast_phone_number_read(p_app);
522	if (0 == result)
523	{
524	result = bast_screen_read(p_app);
525	if (0 == result)
526	{
527	result = bast_eas_read(p_app);
528	}
529	}
530	}
531	}
532	}
533	bos_release_mutex(&(s_p_app->flash_mutex));
534	}
535	else
536	{
537	BDBG_WRN(("%s:%d mutex timeout", __FUNCTION__, __LINE__));
538	}
539
540	bos_release_mutex(p_app->settings.ch_map.p_mutex);
541	if (0 == result)
542	{
543	ch_output(bapp_cur_ch_map(p_app));
544	}
545	else
546	{
547	BDBG_WRN(("Error loading settings, resetting to default."));
548
549	bapp_reset_settings(p_app);
550	p_app->audio_vol = p_app->settings.audio_vol;
551	p_app->settings_dirty = DIRTY_CHANNEL \| DIRTY_MISC \| DIRTY_EAS \|
552	DIRTY_PHONE \| DIRTY_CHANNEL_MAP \| DIRTY_SCREEN;
553	bapp_save_settings(p_app);
554
555	}
556	}
557	return;
558	}
559
560	/*
561	Summary:
562	Save current settings to NVM
563	Description:
564	Save current settings to NVM
565	*/
566	void bapp_save_settings(bapp_t *p_app)
567	{
568	if (bos_acquire_mutex(&(s_p_app->flash_mutex), 250) != b_ok)
569	{
570	BDBG_WRN(("%s:%d mutex timeout\n", __FUNCTION__, __LINE__));
571	return;
572	}
573
574	if (0 != (p_app->settings_dirty & DIRTY_CHANNEL))
575	{
576	/* update unsaved settings */
577	p_app->settings.audio_vol = p_app->audio_vol;
578	bast_channel_save(p_app);
579	p_app->settings_dirty &= ~DIRTY_CHANNEL;
580	}
581
582	/* use MISC instead of having its own DB */
583	if (p_app->settings_dirty & DIRTY_HD_CONFIG) {
584	bdisplay_settings s;
585	bdisplay_get(p_app->display,&s);
586	p_app->settings.hd_config.output_format = s.format;
587	p_app->settings.hd_config.hd_options = s.hd_options;
588	p_app->settings.hd_config.sharpness = s.sharpness;
589	p_app->settings.sd_options = s.sd_options;
590	p_app->settings_dirty &= ~DIRTY_HD_CONFIG;
591	p_app->settings_dirty \|= DIRTY_MISC;
592	}
593
594	if (p_app->settings_dirty & DIRTY_DEBUG_CONFIG) {
595	p_app->settings_dirty &= ~DIRTY_DEBUG_CONFIG;
596	p_app->settings_dirty \|= DIRTY_MISC;
597	}
598
599	if (0 != (p_app->settings_dirty & DIRTY_MISC))
600	{
601	bast_misc_save(p_app);
602	p_app->settings_dirty &= ~DIRTY_MISC;
603	}
604
605	if (0 != (p_app->settings_dirty & DIRTY_EAS))
606	{
607	bast_eas_save(p_app);
608	p_app->settings_dirty &= ~DIRTY_EAS;
609	}
610
611	if (0 != (p_app->settings_dirty & DIRTY_PHONE))
612	{
613	bast_phone_number_save(p_app);
614	p_app->settings_dirty &= ~DIRTY_PHONE;
615	}
616
617	if (0 != (p_app->settings_dirty & DIRTY_SCREEN))
618	{
619	bast_screen_save(p_app);
620	p_app->settings_dirty &= ~DIRTY_SCREEN;
621	}
622
623	if (bos_acquire_mutex(p_app->settings.ch_map.p_mutex,45) == b_ok)
624	{
625	if (0 != (p_app->settings_dirty & DIRTY_CHANNEL_MAP))
626	{
627	bast_channel_map_save(p_app);
628	p_app->settings_dirty &= ~DIRTY_CHANNEL_MAP;
629	}
630	bos_release_mutex(p_app->settings.ch_map.p_mutex);
631	}
632	else
633	{
634	BDBG_WRN(("%s:%d mutex timeout", __FUNCTION__, __LINE__));
635	}
636	bos_release_mutex(&(s_p_app->flash_mutex));
637	}
638	/*
639	Summary:
640	Power down audio DAC and power off
641	*/
642	void bapp_do_poweroff(bapp_t *p_app)
643	{
644	/* JPF TODO Power OFF */
645	}
646
647	/*
648	Summary:
649	Initialize the main app structure.
650	Description:
651	Do necessary configuration of main app structure. Assumes
652	p_app is allocated and p_surf and palette are initialized.
653	*/
654	void bapp_init(bapp_t *p_app)
655	{
656
657	bapp_lang_t e_lang;
658	bgraphics_settings graphics_settings;
659	bresult rc;
660	unsigned int palette; / [out] address of palette */
661	int width; /* [out] width of the OSD surface */
662	int height; /* [out] height of the OSD surface */
663	int pitch; /* [out] pitch of the OSD surface */
664	bdecode_config cfg;
665
666	BDBG_MSG(("%s:%d\n",__FUNCTION__,__LINE__));
667	memset(p_app,0,sizeof(bapp_t));
668
669	s_p_app = p_app;
670	p_app->last_key_down = (bIR_codes_t)0xFFF;
671
672	p_app->last_screen_id = eSCREEN_MAX;
673
674	bsettop_init(0);
675
676	GETTIMEOFDAY(&p_app->timeout_tv);
677	p_app->user_io = buser_input_open(B_ID(USERIO_ID));
678	bast_init(p_app);
679
680	bgraphics_get(&graphics_settings);
681	graphics_settings.format = bgraphics_pixel_format_palette4;
682	bgraphics_set(&graphics_settings);
683
684	BDBG_WRN(("Open display...\n"));
685	p_app->display = bdisplay_open(B_ID(0));
686	BDBG_WRN(("Display opened %d\n",p_app->display));
687
688
689	BDBG_WRN(("Open decoder...\n"));
690	p_app->decode = bdecode_open(0);
691	BDBG_ASSERT(p_app->decode);
692
693	BDBG_WRN(("Decoder opened 0x%08x\n",p_app->decode));
694
695	smessage_init(NULL);
696
697	p_app->window[0] = bdecode_window_open(0, p_app->display);
698	p_app->window[1] = bdecode_window_open(1, p_app->display);
699
700	p_app->audio = baudio_decode_open(B_ID(0));
701	if (!p_app->audio)
702	{
703	BDBG_WRN(("baudio_decode_open failed\n"));
704	}
705	p_app->audio_mute = 0;
706
707	rc = bsettop_hdmi_open(&(p_app->hdmi),p_app->display,p_app->audio, NULL /* no hdcp authentication callback needed*/);
708	BDBG_ASSERT(rc == b_ok);
709
710	#if (BCHP_VER>=BCHP_VER_B0)
711	p_app->p_rfm = brfm_open(0);
712	#endif
713
714	bos_create_queue(&p_app->msg_queue, p_app->msg_event, MAX_MSG_EVENT);
715	BDBG_ASSERT(p_app->msg_queue);
716
717	rc = bos_create_mutex(&p_app->ch_map_mutex);
718	BDBG_ASSERT(rc == b_ok);
719
720	rc = bos_create_mutex(&p_app->flash_mutex);
721	BDBG_ASSERT(rc == b_ok);
722
723	ch_map_init(&(p_app->settings.ch_map),&(p_app->ch_map_mutex));
724
725	p_app->logo = (unsigned char *)s_logo;
726	p_app->logo_size = s_logo_size;
727
728	p_app->graphics = bgraphics_open(B_ID(0),p_app->display);
729
730	/* should after bgraphics_open, since bgraphics_open will overwrite some BVN TOP registers, e.g. AMOL */
731	chm_init(&p_app->chm,p_app);
732
733	p_app->yield_ms = APP_DEFAULT_YIELD;
734	p_app->lang = eLANG_ENGLISH;
735
736	bgraphics_get_framebuffer(p_app->graphics,(void)&p_app->osd_mem,(unsigned int )&palette,&width,&height,&pitch);
737	bapp_set_palette(p_app,ePALETTE_DEFAULT);
738	bgraphics_load_palette(p_app->graphics);
739	p_app->osd_mem_size = pitch * height;
740	p_app->width = width;
741	p_app->height = height;
742	BDBG_MSG(("%s:%d - Width = %d, Height = %d, Pitch = %d.\n",__FUNCTION__,__LINE__,width,height,pitch));
743
744	BDBG_MSG(("%s:%d - Initialize screens.\n",__FUNCTION__,__LINE__));
745
746	/* Default to NULL (empty) screen (TODO: goto factory test then setup wizard.) */
747	p_app->screen_id = eSCREEN_BANNER;
748
749	p_app->p_screens = g_screens;
750	p_app->num_screens = g_screens_num;
751
752	BDBG_MSG(("%s:%d - Initialize bgfx.\n",__FUNCTION__,__LINE__));
753	/* initialize bgfx */
754	bgfx_init(&s_io,NULL,s_p_gfx_hw);
755	#ifdef CONFIG_GFX_ARGB32
756	bgraphics_get_osd_params(p_app->graphics,(bsettop_surf_t)&(p_app->surf.surface.surf),(void*)&(p_app->osd_mem),NULL,NULL);
757	if (bgfx_create(&p_app->surf,p_app->width,p_app->height,(uint8_t*)p_app->osd_mem,
758	pitch,NULL,BGFX_SURF_BPP(32)\|BGFX_SURF_RGB\|BGFX_SURF_GRC) != 0)
759	{
760	BDBG_ASSERT(0);
761	}
762	#else
763	/* Create the OSD surface to use for all drawing */
764	if (bgfx_create(&p_app->surf,p_app->width,p_app->height,(uint8_t*)p_app->osd_mem,
765	pitch,&p_app->palette, BGFX_SURF_PRIMARY \| BGFX_SURF_BPP(4)) != 0)
766	{
767	BDBG_ASSERT(0);
768	}
769	#endif
770
771	bgfx_fill_rect(&p_app->surf,0,0,p_app->width,p_app->height,eCOLOR_CLEAR);
772
773	BDBG_MSG(("%s:%d - Load fonts.\n",__FUNCTION__,__LINE__));
774
775	memset(&s_font[eFONT_SIZE_SMALL],0,sizeof(bgfx_font_t) * 3);
776	p_app->br.cnt = 0;
777	#ifdef CONFIG_8BIT_FONT
778	p_app->br.data = (unsigned char*)g_FrancophilB_22_aa;
779	p_app->br.size = g_FrancophilB_22_aa_size;
780	#else
781	p_app->br.data = (unsigned char*)g_FrancophilB_22_mono;
782	p_app->br.size = g_FrancophilB_22_mono_size;
783	#endif
784	if (bgfx_load_font(&(s_font[eFONT_SIZE_SMALL]),&p_app->br) != 0)
785	{
786	BDBG_ASSERT(0);
787	}
788
789	p_app->br.cnt = 0;
790	#ifdef CONFIG_8BIT_FONT
791	p_app->br.data = (unsigned char*)g_FrancophilB_28_aa;
792	p_app->br.size = g_FrancophilB_28_aa_size;
793	#else
794	p_app->br.data = (unsigned char*)g_FrancophilB_28_mono;
795	p_app->br.size = g_FrancophilB_28_mono_size;
796	#endif
797	if (bgfx_load_font(&(s_font[eFONT_SIZE_MED]),&p_app->br) != 0)
798	{
799	BDBG_ASSERT(0);
800	}
801
802	p_app->br.cnt = 0;
803	#ifdef CONFIG_8BIT_FONT
804	p_app->br.data = (unsigned char*)g_FrancophilB_40_aa;
805	p_app->br.size = g_FrancophilB_40_aa_size;
806	#else
807	p_app->br.data = (unsigned char*)g_FrancophilB_40_mono;
808	p_app->br.size = g_FrancophilB_40_mono_size;
809	#endif
810	if (bgfx_load_font(&(s_font[eFONT_SIZE_LARGE]), &p_app->br) != 0)
811	{
812	BDBG_ASSERT(0);
813	}
814
815	for (e_lang = eLANG_ENGLISH; e_lang < eLANG_MAX; ++e_lang)
816	{
817	p_app->p_font[e_lang][eFONT_SIZE_SMALL] = &s_font[eFONT_SIZE_SMALL];
818	p_app->p_font[e_lang][eFONT_SIZE_MED] = &s_font[eFONT_SIZE_MED];
819	p_app->p_font[e_lang][eFONT_SIZE_LARGE] = &s_font[eFONT_SIZE_LARGE];
820	}
821
822	bapp_load_settings(p_app);
823
824	/* set HD configuration if not match default */
825	bapp_set_hd_configuration(p_app);
826
827	if (p_app->settings.activated)
828	{
829	if (((int)p_app->settings.timeout_cnt) >= 2)
830	{
831	p_app->settings.timeout_cnt -= 2;
832	} else
833	{
834	p_app->settings.activated = false;
835	p_app->settings_dirty \|= DIRTY_MISC;
836	}
837	}
838
839	#ifdef CONFIG_DTA_CABLE_TESTING
840	{
841	b_mutex_t *p_mutex = p_app->settings.ch_map.p_mutex;
842	extern const ch_map_t s_ch_map;
843	memcpy(&p_app->settings.ch_map,&s_ch_map, sizeof(s_ch_map));
844	p_app->settings.ch_map.p_mutex = p_mutex;
845	p_app->settings.activated = true;
846	}
847	#endif
848
849	bapp_apply_settings(p_app);
850
851	BDBG_WRN(("%s:%d - av_mute = %d\n",__FUNCTION__,__LINE__,p_app->settings.av_mute));
852	BDBG_WRN(("%s:%d - prev_state = %d\n",__FUNCTION__,__LINE__,p_app->settings.state));
853
854	#ifdef CONFIG_EIA_708
855	p_app->eia708 = bapp_eia708_open(p_app);
856	BAPP_ASSERT(p_app->eia708);
857
858	bdecode_get_config(p_app->decode, &cfg);
859	cfg.cc_callback = bapp_eia708_cb;
860	bdecode_set_config(p_app->decode, &cfg);
861	#endif
862
863	#ifdef CONFIG_DVB_SUBTITLE
864	p_app->dsub = bapp_dsub_open(p_app);
865	BAPP_ASSERT(p_app->dsub);
866	#endif
867
868	bapp_av_mute(p_app,0);
869	bapp_flush_screen(p_app);
870
871	if (p_app->settings.ch_map.vch_map.num_vch > 0)
872	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
873	else {
874	if (p_app->settings.activated == false) { /* system is not activated yet. launch welcom screen */
875	if (0 == p_app->settings.audio_vol) {
876	p_app->settings.audio_vol = BAPP_MAX_VOLUME;
877	bapp_apply_settings(p_app);
878	}
879	bapp_set_current_screen(p_app, eSCREEN_WIZ_WELCOME, eSCREEN_MAX);
880	}
881	else {
882	bapp_set_current_screen(p_app, eSCREEN_MAIN, eSCREEN_MAX);
883	}
884	}
885
886	bapp_new_screen(p_app);
887	p_app->power = 1;
888
889	/* Always enter pending state on hard power up. */
890	#ifdef CONFIG_DTA_CABLE_TESTING
891	p_app->settings.psi_scan = 1;
892	bapp_eval_state(p_app,eAPP_STATE_NORMAL);
893	#else
894	p_app->settings.activated = 1;
895	p_app->settings.psi_scan = 1;
896	if (p_app->settings.psi_scan)
897	bapp_eval_state(p_app,eAPP_STATE_NORMAL);
898	else
899	bapp_eval_state(p_app,eAPP_STATE_HUNT);
900	#endif
901
902	#ifdef BCM_DEBUG
903	BDBG_SetModuleLevel("bscreen",BDBG_eMsg);
904	timing_profile_init();
905	p_app->ptp_tune = timing_profile_get("Tune"); /* start tune to first pts */
906	p_app->ptp_psi = timing_profile_get("PSI"); /* profile psi (PAT/PMT) */
907	p_app->ptp_first_pts = timing_profile_get("PTS"); /* profile start decode to first PTS */
908	p_app->ptp_decode = timing_profile_get("Decode"); /* start tuner to first pts */
909	bdecode_get_config(p_app->decode,&cfg);
910	cfg.first_pts_callback = bapp_first_pts_callback;
911	cfg.seq_hdr_callback = bapp_seq_hdr_callback;
912
913	// AFD support
914	#if 0
915	cfg.afd_reset_callback = bdisplay_afd_reset;
916	cfg.afd_set_format_callback = bdisplay_afd_set_format;
917	#endif
918	bdecode_set_config(p_app->decode,&cfg);
919	#endif
920	}
921	/*
922	Summary:
923	Main app event handler.
924	Description:
925	Main application event handler.
926	*/
927	void bapp_handle_event(bapp_t p_app, bscreen_event_t p_event)
928	{
929	if (p_event && (p_event->type == eS_EVENT_IR) && (p_event->id >= eIR_CHMAP))
930	{
931	BDBG_WRN(("%s:%d - event_id = 0x%08x\n",__FUNCTION__,__LINE__,p_event->id));
932	switch (p_event->id)
933	{
934	case eIR_CHMAP: /* Output channel map on UART */
935	ch_output(bapp_cur_ch_map(p_app));
936	break;
937
938	case eIR_SCAN: /* Perform channel scan */
939	p_app->state = eAPP_STATE_NORMAL;
940	if (p_app->settings.psi_scan)
941	{
942	p_app->settings.activated = 1;
943	p_app->settings_dirty \|= DIRTY_MISC;
944	}
945	else {
946	chm_get_hunt_progress(&p_app->chm);
947	}
948	bapp_eval_state(p_app,eAPP_STATE_HUNT);
949
950	break;
951
952	case eIR_SETUP: /* Perform default setup */
953	p_app->state = eAPP_STATE_NORMAL;
954	bapp_eval_state(p_app,eAPP_STATE_DOWNLOAD);
955	break;
956
957	case eIR_EXIT: /* Exit to banner menu */
958	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
959	if (p_app->system_mute) {
960	bapp_audio_do_mute(p_app, false);
961	bapp_video_mute(p_app, false);
962	}
963	break;
964
965	default:
966	if ((p_event->id & eIR_SETCH) == eIR_SETCH)
967	{
968	/* TODO Tune to channel number */
969	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
970	}
971	break;
972	}
973	}
974	}
975
976	/*
977	Summary:
978	Main app idle time handler.
979	Description:
980	Main application idle time handler.
981	*/
982	void bapp_idle(bapp_t *p_app)
983	{
984	b_timeval end_tv;
985	unsigned int delta_hrs;
986	static chm_event_t evt;
987	static b_timeval last_tv = { 0, 0};
988	GETTIMEOFDAY(&end_tv);
989	/* PVT Monitor */
990	if (end_tv.tv_sec > (last_tv.tv_sec + 2))
991	{
992	bsettop_pvt();
993	last_tv = end_tv;
994	}
995
996	delta_hrs = (end_tv.tv_sec - p_app->timeout_tv.tv_sec)/(60 * 60);
997	if ((delta_hrs > 0) && (((int)p_app->settings.timeout_cnt) > 0))
998	{
999	p_app->settings.timeout_cnt--;
1000	BDBG_WRN(("%s decriment timeout counter %d\n",__FUNCTION__,p_app->settings.timeout_cnt));
1001	p_app->timeout_tv = end_tv;
1002	}
1003
1004	if ((p_app->state == eAPP_STATE_NORMAL) && p_app->settings.activated && !p_app->settings.psi_scan)
1005	{
1006	if (((int)p_app->settings.timeout_cnt) <= 0)
1007	{
1008	evt.id = 0;
1009	evt.type = eCHM_EVT_ACTIVATION;
1010	bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
1011	}
1012	}
1013
1014	if (p_app->check_poweron)
1015	{
1016	if (p_app->poweron_ms < bos_getticks())
1017	{
1018	p_app->check_poweron = false;
1019	}
1020	}
1021
1022	if ((p_app->state == eAPP_STATE_NORMAL) &&
1023	p_app->eas_timeout && (p_app->eas_timeout < end_tv.tv_sec))
1024	{
1025	p_app->eas_timeout = 0;
1026	if (p_app->eas_text)
1027	{
1028	p_app->eas_text = false;
1029	/* clear eas text scrolling screen */
1030	bapp_sync(p_app);
1031	screen_null_draw(p_app, NULL);
1032	bapp_flush_screen(p_app);
1033	}
1034	bapp_tune_prev(p_app);
1035	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1036	}
1037	#ifndef OLD_INFO_KEY_PROCESSING
1038	if (p_app->last_key_down == eIR_INFO)
1039	{
1040	BDBG_WRN(("%s: p_app->last_key_down == eIR_INFO \n",__FUNCTION__));
1041	b_timeval cur_tv;
1042	GETTIMEOFDAY(&cur_tv);
1043	if ((p_app->last_key_tv.tv_sec + BAPP_DIAG_TIMEOUT) <= cur_tv.tv_sec)
1044	{
1045	BDBG_WRN(("%s: DIAG_TIMEOUT \n",__FUNCTION__));
1046	bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
1047	bapp_new_screen(p_app);
1048	}
1049	}
1050	#endif
1051	}
1052	/*
1053	Summary:
1054	Wait for vsync.
1055	Description:
1056	Block waiting for vsync so drawing can by syncronized with screen refresh.
1057	*/
1058	void bapp_sync(bapp_t *p_app)
1059	{
1060	/* do nothing */
1061	}
1062
1063	/*
1064	Summary:
1065	Enable closed captioning.
1066	Description:
1067	Enable closed captioning and send clear characters.
1068	*/
1069	void bapp_enable_cc(bapp_t *p_app, int enable)
1070	{
1071	bdecode_config cfg;
1072	bdecode_get_config(p_app->decode,&cfg);
1073	if (cfg.cc_enabled != enable)
1074	{
1075	cfg.cc_enabled = (enable == 0) ? 0 : 1;
1076	bdecode_set_config(p_app->decode,&cfg);
1077	}
1078	}
1079	/*
1080	Summary:
1081	Handle new screen.
1082	Description:
1083	Block waiting for vsync so drawing can by syncronized with screen refresh.
1084	*/
1085	static void bapp_screen_redraw(bapp_t *p_app)
1086	{
1087	bscreen_event_t screen_event;
1088	screen_event.type = eS_EVENT_REDRAW;
1089	screen_event.id = 0;
1090	BDBG_MSG(("%s:%d - sending setup event to %d.\n",__FUNCTION__,__LINE__,p_app->screen_id));
1091	p_app->p_screens[p_app->screen_id].handle_event(p_app,(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event);
1092	}
1093
1094	/*
1095	Summary:
1096	Handle new screen.
1097	Description:
1098	Block waiting for vsync so drawing can by syncronized with screen refresh.
1099	*/
1100	static void bapp_new_screen(bapp_t *p_app)
1101	{
1102	bscreen_event_t screen_event;
1103	#ifdef TIME_APP_DRAWING
1104	b_timeval start_tv,end_tv,result_tv;
1105	unsigned int dt;
1106	#endif
1107	screen_event.type = 0;
1108	if (p_app->last_screen_id != (int)p_app->screen_id)
1109	{
1110	BDBG_MSG(("%s:%d - sending setup event to %d.\n",__FUNCTION__,__LINE__,p_app->screen_id));
1111	screen_event.type = eS_EVENT_SETUP;
1112	screen_event.id = 0;
1113	p_app->p_screens[p_app->screen_id].handle_event(p_app,(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event);
1114	}
1115
1116	p_app->last_screen_id = p_app->screen_id;
1117	#ifdef TIME_APP_DRAWING
1118	GETTIMEOFDAY(&start_tv);
1119	#endif
1120
1121	//BDBG_MSG(("%s:%d - drawing screen:%d.\n",__FUNCTION__,__LINE__,p_app->screen_id));
1122	bapp_sync(p_app);
1123	p_app->p_screens[p_app->screen_id].draw(p_app,(void*)&(p_app->p_screens[p_app->screen_id]));
1124	bapp_flush_screen(p_app);
1125
1126	#ifdef TIME_APP_DRAWING
1127	GETTIMEOFDAY(&end_tv);
1128	timeval_subtract(&result_tv,&end_tv,&start_tv);
1129	dt = result_tv.tv_sec * 1000 + result_tv.tv_usec/1000;
1130	BDBG_WRN(("Drawing screen %d took %d ms\n",p_app->screen_id,dt));
1131	#endif
1132
1133	/* send a setup done event to start any post drawing setup */
1134	if (screen_event.type == eS_EVENT_SETUP)
1135	{
1136	screen_event.type = eS_EVENT_SETUP_DONE;
1137	screen_event.id = 0;
1138	if (p_app->p_screens[p_app->screen_id].handle_event(p_app,(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event))
1139	{
1140	p_app->last_screen_id = p_app->screen_id;
1141	screen_event.type = eS_EVENT_SETUP;
1142	screen_event.id = 0;
1143	p_app->p_screens[p_app->screen_id].handle_event(p_app,(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event);
1144	#ifdef TIME_APP_DRAWING
1145	GETTIMEOFDAY(&start_tv);
1146	#endif
1147	bapp_sync(p_app);
1148	p_app->p_screens[p_app->screen_id].draw(p_app,(void*)&(p_app->p_screens[p_app->screen_id]));
1149	bapp_flush_screen(p_app);
1150
1151	#ifdef TIME_APP_DRAWING
1152	GETTIMEOFDAY(&end_tv);
1153	timeval_subtract(&result_tv,&end_tv,&start_tv);
1154	dt = result_tv.tv_sec * 1000 + result_tv.tv_usec/1000;
1155	BDBG_WRN(("Drawing took %d milliseconds\n",dt));
1156	#endif
1157	}
1158	}
1159	}
1160
1161	/*
1162	Summary:
1163	sets the current screen for display
1164	Description:
1165	sets the current screen for display.
1166	if id == eSCREEN_MAX then simply backup a screen
1167	if save_last == eSCREEN_MAX, also saves last screen id.
1168	*/
1169	void bapp_set_current_screen(bapp_t *p_app, bapp_screen_id_t id, bapp_screen_id_t save_last)
1170	{
1171	bscreen_t *p_screen = &(p_app->p_screens[p_app->screen_id]);
1172	bscreen_t *p_screen_new = &(p_app->p_screens[id]);
1173	#ifdef BCM_DEBUG
1174	unsigned int cur_screen = p_app->screen_id;
1175	#endif
1176	BDBG_WRN(("Attempt to change screen from %d to %d\n",cur_screen, id));
1177
1178	if (id == p_app->screen_id)
1179	return;
1180
1181	if (id == eSCREEN_MAX)
1182	{
1183	bapp_goto_last_screen(p_app);
1184	} else
1185	{
1186	if (save_last == eSCREEN_MAX)
1187	p_screen_new->last_screen_id = p_app->screen_id;
1188	else
1189	{
1190	p_screen_new->last_screen_id = save_last;
1191	p_screen->button_selection = 0; /* if we do not save the last screen, clear out focus history */
1192	}
1193
1194	if (id < eSCREEN_MAX)
1195	p_app->screen_id = id;
1196	}
1197
1198	if (p_app->screen_id == eSCREEN_MAX)
1199	{
1200	p_app->screen_id = eSCREEN_BANNER; /* Default to channel change screen */
1201	}
1202	BDBG_WRN(("Changing screen from %d to %d\n",cur_screen, p_app->screen_id));
1203
1204	}
1205
1206	/*
1207	Summary:
1208	sets the current screen for display to be the last screen
1209	Description:
1210	sets the current screen for display to be the last screen
1211	*/
1212	void bapp_goto_last_screen(bapp_t *p_app)
1213	{
1214	bscreen_t *p_screen = &(p_app->p_screens[p_app->screen_id]);
1215	p_app->screen_id = p_screen->last_screen_id;
1216	if (p_app->screen_id == eSCREEN_MAX)
1217	{
1218	p_app->screen_id = eSCREEN_BANNER; /* Default to channel change screen */
1219	}
1220	}
1221
1222	/* TODO: */
1223	void bapp_power(bapp_t *p_app, bool power)
1224	{
1225	bapp_standby(p_app, power);
1226	}
1227	/*
1228	Summary:
1229	Enter/exit standby
1230	*/
1231	static void bapp_standby(bapp_t *p_app, bool power)
1232	{
1233	if (!power && p_app->check_poweron)
1234	{
1235	return;
1236	}
1237
1238	if (power)
1239	{
1240	/* turning power on */
1241	BDBG_ERR(("######## Turn ON ########\n"));
1242	bapp_av_mute(p_app, 0);
1243	} else
1244	{
1245
1246	bapp_av_mute(p_app,1);
1247
1248	/* turning power off */
1249	}
1250
1251	p_app->power = power;
1252	}
1253	/*
1254	Summary:
1255	Handle diag events.
1256	*/
1257	#ifdef OLD_INFO_KEY_PROCESSING
1258	static bool bapp_enter_diag(bapp_t *p_app,bIR_codes_t code)
1259	{
1260	bool result = false;
1261	switch (code)
1262	{
1263	case eIR_INFO:
1264	bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
1265	bapp_new_screen(p_app);
1266	result = true;
1267	break;
1268	default:
1269	break;
1270	}
1271	return result;
1272	}
1273	#endif
1274	/*
1275	Summary:
1276	Handle user events.
1277	*/
1278	static void bapp_handle_user_event(bapp_t *p_app,
1279	buser_input_event *p_event
1280	)
1281	{
1282	bscreen_event_t screen_event;
1283	bool key_up = (p_event->code & 0x40000000) ? true : false;
1284	bIR_codes_t code = (bIR_codes_t)(p_event->code & ~0x40000000);
1285
1286	#ifdef OLD_INFO_KEY_PROCESSING
1287	b_timeval cur_tv;
1288	#endif
1289
1290	BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,code,(key_up) ? "up" : "down"));
1291
1292	switch (code)
1293	{
1294	case eIR_POWER:
1295	if (key_up && !p_app->check_poweron) {
1296	if (p_app->settings.auto_power_off) {
1297	p_app->chm_cmd.cmd_id = eCHM_INFO;
1298	chm_cmd(&p_app->chm, &p_app->chm_cmd);
1299	}
1300	bapp_standby(p_app, !p_app->power);
1301	}
1302	break;
1303	case 0x71:
1304	case 0x72:
1305	case eIR_RFM:
1306	if (key_up)
1307	{
1308
1309	}
1310	break;
1311	default:
1312	if (!p_app->power)
1313	break;
1314	/* Test to see if we should enter the diagnostic state */
1315	#ifdef OLD_INFO_KEY_PROCESSING
1316	if (key_up && (p_app->last_key_down == code) && !p_app->settings.av_mute)
1317	{
1318	GETTIMEOFDAY(&cur_tv);
1319	if ((p_app->last_key_tv.tv_sec + BAPP_DIAG_TIMEOUT) <= cur_tv.tv_sec)
1320	{
1321	if (bapp_enter_diag(p_app,code))
1322	break;
1323	}
1324	}
1325	#endif
1326	if ((p_app->state != eAPP_STATE_NORMAL) && (p_app->screen_id == eSCREEN_BANNER))
1327	break;
1328
1329	screen_event.type = eS_EVENT_IR;
1330	screen_event.id = p_event->code;
1331	if (p_app->p_screens[p_app->screen_id].handle_event(p_app,
1332	(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event))
1333	{
1334	BDBG_MSG(("%s:%d screen_id %d\n",__FUNCTION__,__LINE__,p_app->screen_id));
1335	/* Wait for vsync then do screen drawing */
1336	bapp_new_screen(p_app);
1337	} else
1338	{
1339	bapp_handle_event(p_app,&screen_event);
1340	}
1341	}
1342
1343	if (p_app->state != eAPP_STATE_FACTORY)
1344	{
1345	}
1346
1347	if (!key_up)
1348	{
1349	BDBG_WRN(("%s: !key_up \n",__FUNCTION__));
1350	p_app->last_key_down = code;
1351	GETTIMEOFDAY(&p_app->last_key_tv);
1352	}
1353	#ifndef OLD_INFO_KEY_PROCESSING
1354	else
1355	{
1356	BDBG_WRN(("%s: key_up \n",__FUNCTION__));
1357	p_app->last_key_down = (bIR_codes_t)0xFFF; /* key up */
1358	}
1359	#endif
1360	}
1361	/*
1362	Summary:
1363	Handle rrt events.Need requirements to implement correct handling.
1364	*/
1365	static bapp_state_t bapp_handle_set_screen_event(bapp_t *p_app,
1366	chm_event_t *p_event)
1367
1368	{
1369	bapp_set_current_screen(p_app, p_event->id, eSCREEN_MAX);
1370	bapp_new_screen(p_app);
1371	return eAPP_STATE_NORMAL;
1372	}
1373
1374	/*
1375	Summary:
1376	Handle channel manager events.
1377	*/
1378	static bapp_state_t bapp_handle_chm_event(bapp_t *p_app)
1379	{
1380	bscreen_event_t screen_event;
1381	chm_event_t *p_event;
1382	b_timeval start_tv;
1383	unsigned short cur_ch;
1384	static int scan_ch_cnt = 0;
1385	bapp_state_t new_state = p_app->state;
1386
1387	/* Check for notification events */
1388	if ((p_event = (chm_event_t*)bos_pend_event(p_app->msg_queue,0)) != NULL)
1389	{
1390	screen_event.type = eS_EVENT_MAX;
1391	screen_event.id = p_event->id;
1392	if (p_event->type != eCHM_EVT_SIGNAL)
1393	{
1394	BDBG_MSG(("%s (%s)\n",__FUNCTION__,s_chm_evt_str[p_event->type]));
1395	}
1396	switch (p_event->type)
1397	{
1398	case eCHM_EVT_SET_SCREEN: /* set current screen event */
1399	new_state = bapp_handle_set_screen_event(p_app,p_event);
1400	break;
1401	case eCHM_EVT_CANCEL: screen_event.type = eS_EVENT_CANCEL; break;
1402	case eCHM_EVT_DONE: screen_event.type = eS_EVENT_DONE; break;
1403	case eCHM_EVT_REDRAW: screen_event.type = eS_EVENT_REDRAW; break;
1404	case eCHM_EVT_PROGRESS: screen_event.type = eS_EVENT_PROGRESS; break;
1405	case eCHM_EVT_SIGNAL:
1406	{
1407	chm_signal_event_t p_sig = (chm_signal_event_t)p_event;
1408	p_app->lock = (p_sig->lock) ? true : false;
1409	p_app->power_level = p_sig->power;
1410	p_app->tuned_freq = p_sig->freq_hz;
1411	p_app->snr = p_sig->SNR;
1412
1413	if (p_app->screen_id == eSCREEN_ANTENNA) {
1414	screen_event.type = eS_EVENT_PROGRESS;
1415	screen_event.id = p_app->power_level;
1416	}
1417	//p_app->qam_b_mode = p_sig->qam_b_mode;
1418	}
1419	break;
1420	case eCHM_EVT_DOWNLOAD:
1421	new_state = eAPP_STATE_DOWNLOAD;
1422	break;
1423	case eCHM_EVT_EAS:
1424	BDBG_MSG(("%s:%d EAS TIMER STARTED)\n",__FUNCTION__,__LINE__));
1425	if (p_app->state == eAPP_STATE_NORMAL)
1426	{
1427	GETTIMEOFDAY(&start_tv);
1428	if (ch_map_set(bapp_cur_ch_map(p_app),p_event->id && 0xFFFF))
1429	{
1430	/* if 0, don't timeout */
1431	if (p_event->id >> 16)
1432	p_app->eas_timeout = start_tv.tv_sec + (p_event->id >> 16);
1433	else
1434	p_app->eas_timeout = 0;
1435	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1436	bapp_tune(p_app);
1437
1438	/* use a local buffer to avoid conflict when eas getting other data and while text scrolling in progress*/
1439	if (BERR_SUCCESS == bscreen_eas_text_scrolling_info(p_app, p_app->eas_buf, p_app->eas_buf_size))
1440	{
1441	p_app->eas_text = true;
1442	}
1443	}
1444	}
1445	break;
1446	case eCHM_EVT_CA:
1447	{
1448	chm_ca_event_t p_ca_evt = (chm_ca_event_t)p_event;
1449	if ((p_app->settings.CA_System_ID != p_ca_evt->CA_System_ID) \|\|
1450	(p_app->settings.EMM_PID != p_ca_evt->EMM_PID))
1451	{
1452	p_app->settings.CA_System_ID = p_ca_evt->CA_System_ID;
1453	p_app->settings.EMM_Provider_ID = p_ca_evt->EMM_Provider_ID;
1454	p_app->settings.SCP_operating_mode = p_ca_evt->SCP_operating_mode;
1455	p_app->settings.EMM_PID = p_ca_evt->EMM_PID;
1456	p_app->settings.has_CAT = true;
1457	// p_app->settings.turn_on_freq_khz = p_ca_evt->freq_khz;
1458	p_app->settings_dirty \|= DIRTY_MISC;
1459	}
1460	}
1461	break;
1462	case eCHM_EVT_NETWORK:
1463	p_app->settings.network_PID = p_event->id;
1464	p_app->settings_dirty \|= DIRTY_MISC;
1465	break;
1466	case eCHM_EVT_STATUS:
1467	switch (p_event->id)
1468	{
1469	case eCHM_STATUS_HUNT: /* HUNT MODE */
1470	if (p_app->screen_id == eSCREEN_CH_SCAN_PROGRESS) {
1471	scan_ch_cnt = 0;
1472	}
1473
1474	BDBG_WRN(("eCHM_STATUS_HUNT\n"));
1475	break;
1476	case eCHM_STATUS_PENDING_INIT: /* Pending Init MODE */
1477	BDBG_WRN(("eCHM_STATUS_PENDING_INIT\n"));
1478	new_state = eAPP_STATE_PENDING;
1479	break;
1480	case eCHM_STATUS_CHMAP:
1481	BDBG_WRN(("eCHM_STATUS_CHMAP flags = 0x%08x\n",p_event->ticks));
1482	if ( ((ch_map_cmp(&(p_app->settings.ch_map),&(p_app->chm.ch_map)) & p_event->ticks)) \|\|
1483	((p_event->ticks == 0x82) &&
1484	ch_map_cmp_vch_with_pid(&(p_app->settings.ch_map.vch_map),&(p_app->chm.ch_map.vch_map))!=0))
1485	{
1486	BDBG_WRN(("Channel map changed 0x%08x\n",p_event->ticks));
1487	cur_ch = p_app->settings.ch_map.cur_ch;
1488	ch_map_copy(&(p_app->settings.ch_map),&(p_app->chm.ch_map),p_event->ticks);
1489	p_app->settings.ch_map.cur_ch = cur_ch;
1490	#ifdef BCM_DEBUG
1491	ch_output(bapp_cur_ch_map(p_app));
1492	#endif
1493	p_app->settings_dirty \|= DIRTY_CHANNEL_MAP;
1494	}
1495	else
1496	{
1497	BDBG_WRN(("Channel map NOT changed\n"));
1498	}
1499
1500	if (p_app->settings.psi_scan)
1501	{
1502	p_app->settings.activated = 1;
1503	p_app->settings.timeout_cnt = 8;
1504	p_app->settings_dirty \|= DIRTY_MISC;
1505	memset(&p_app->cur_vch,0,sizeof(p_app->cur_vch));
1506	bapp_save_settings(p_app);
1507	bapp_load_settings(p_app);
1508	}
1509
1510	if (p_app->settings.activated)
1511	{
1512	if ((p_app->state == eAPP_STATE_NORMAL) && p_app->settings_dirty)
1513	{
1514	bapp_save_settings(p_app);
1515	/* if just scanned and have channnels, force to tune first channel */
1516	if (p_app->settings.ch_map.vch_map.num_vch)
1517	{
1518	p_app->chm.force_tune = true;
1519	bapp_tune(p_app);
1520	}
1521	}
1522	else
1523	{
1524	new_state = eAPP_STATE_NORMAL;
1525	}
1526	}
1527	else
1528	{
1529	BDBG_WRN(("### ERROR recieve new channel map while still not activated - return to Hunt Mode\n"));
1530	new_state = eAPP_STATE_HUNT;
1531	}
1532	break;
1533
1534	case eCHM_STATUS_PAT:
1535	p_app->has_PAT = true;
1536	if (p_app->screen_id == eSCREEN_CH_SCAN_PROGRESS) {
1537	scan_ch_cnt++;
1538	}
1539	#if 0
1540	if (ch_map_cmp(&(p_app->settings.ch_map),&(p_app->chm.ch_map)) & p_event->ticks)
1541	{
1542	BDBG_WRN(("Channel map changed 0x%08x\n",p_event->ticks));
1543	cur_ch = p_app->settings.ch_map.cur_ch;
1544	ch_map_copy(&(p_app->settings.ch_map),&(p_app->chm.ch_map),p_event->ticks);
1545	p_app->settings.ch_map.cur_ch = cur_ch;
1546	#ifdef BCM_DEBUG
1547	ch_output(bapp_cur_ch_map(p_app));
1548	#endif
1549	p_app->settings_dirty \|= DIRTY_CHANNEL_MAP;
1550	}
1551	else
1552	{
1553	BDBG_WRN(("Channel map NOT changed\n"));
1554	}
1555	#endif
1556	break;
1557	case eCHM_STATUS_NOPAT:
1558	if (p_app->screen_id == eSCREEN_CH_SCAN_PROGRESS) {
1559	if (p_event->ticks != 0) {
1560	screen_event.type = eS_EVENT_PROGRESS;
1561	screen_event.id = p_event->ticks;
1562	screen_event.data = &scan_ch_cnt;
1563	}
1564	}
1565	p_app->has_PAT = false;
1566	break;
1567	case eCHM_STATUS_TUNE_MS: p_app->tune_ms = p_event->ticks; break;
1568	case eCHM_STATUS_SI_MS: p_app->si_ms = p_event->ticks; break;
1569	}
1570
1571	break;
1572	case eCHM_EVT_AV_MUTE:
1573	bapp_standby(p_app,!p_event->id);
1574	break;
1575	case eCHM_EVT_ACTIVATION:
1576	{
1577	bool current_activation = p_app->settings.activated;
1578	p_app->settings.activated = p_event->id;
1579	if (p_app->settings.activated != current_activation)
1580	{
1581	p_app->settings_dirty \|= DIRTY_MISC;
1582	if (!p_app->settings.activated)
1583	{
1584	p_app->settings.deactivated = 1;
1585	new_state = eAPP_STATE_HUNT;
1586	}
1587	else
1588	{
1589	p_app->settings.deactivated = 0;
1590	if (p_app->settings.timeout_policy == 1)
1591	{
1592	p_app->settings.timeout_cnt = p_app->settings.timeout;
1593	}
1594	#ifdef BCM_DEBUG
1595	/* Some default value to prevent immediate de-activation in lab environments */
1596	else if (p_app->settings.timeout == 0)
1597	{
1598	p_app->settings.timeout_cnt += 4;
1599	}
1600	#endif
1601	}
1602	}
1603	}
1604	break;
1605	case eCHM_EVT_VCT_ID:
1606	{
1607	unsigned short current_vct_id = p_app->settings.VCT_ID;
1608	p_app->settings.VCT_ID = p_event->id;
1609
1610	if ((p_app->settings.VCT_ID != current_vct_id) && (CONFIG_DEF_VCT_ID != 0xFFFF))
1611	{
1612	BDBG_WRN(("%s:%d Configuration VCT_ID %d does not match current value %d\n",
1613	__FUNCTION__,__LINE__,p_app->settings.VCT_ID,current_vct_id));
1614	p_app->settings.activated = false;
1615	new_state = eAPP_STATE_PENDING;
1616	}
1617	p_app->settings_dirty \|= DIRTY_MISC;
1618	}
1619	break;
1620	case eCHM_EVT_CONFIGURATION:
1621	{
1622	chm_config_event_t p_cfg_evt = (chm_config_event_t)p_event;
1623	unsigned short current_vct_id = p_app->settings.VCT_ID;
1624	p_app->settings.VCT_ID = p_cfg_evt->VCT_ID;
1625	p_app->settings.timeout = p_cfg_evt->timeout;
1626	p_app->settings.timeout_policy = p_cfg_evt->timeout_policy;
1627	p_app->settings.max_location_errors = p_cfg_evt->max_location_errors;
1628
1629	if (p_app->settings.timeout_policy == 0)
1630	{
1631	p_app->settings.timeout_cnt = p_cfg_evt->timeout;
1632	}
1633	p_app->settings.location = p_cfg_evt->location;
1634	if (p_app->have_time)
1635	{
1636	p_app->settings.message_time = p_app->system_time;
1637	} else
1638	{
1639	BDBG_WRN(("%s:%d Need system time before configuration can be processed\n",__FUNCTION__,__LINE__));
1640	break;
1641	}
1642
1643	if ((p_app->settings.VCT_ID != current_vct_id) && (CONFIG_DEF_VCT_ID != 0xFFFF))
1644	{
1645	BDBG_WRN(("%s:%d Configuration VCT_ID %d does not match current value %d\n",
1646	__FUNCTION__,__LINE__,p_app->settings.VCT_ID,current_vct_id));
1647	p_app->settings.activated = false;
1648	new_state = eAPP_STATE_PENDING;
1649	}
1650	p_app->settings_dirty \|= DIRTY_MISC;
1651	}
1652	break;
1653	case eCHM_EVT_LOCATION:
1654	if(p_app->settings.psi_scan)
1655	break;
1656	p_app->location = p_event->id;
1657	if (p_app->settings.location != p_event->id)
1658	{
1659	if (p_app->settings.location_errors > p_app->settings.max_location_errors)
1660	{
1661	p_app->settings.activated = false;
1662	new_state = eAPP_STATE_HUNT;
1663	}
1664	else
1665	{
1666	p_app->settings.location_errors++;
1667	p_app->settings_dirty \|= DIRTY_MISC;
1668	}
1669	}
1670	else
1671	{
1672	if (p_app->settings.timeout_policy == 0)
1673	{
1674	p_app->settings.timeout_cnt = p_app->settings.timeout;
1675	}
1676	}
1677	break;
1678
1679	case eCHM_EVT_TIME:
1680	{
1681	chm_time_event_t p_time_evt = (chm_time_event_t)p_event;
1682	p_app->system_time = p_time_evt->system_time;
1683	p_app->system_offset = p_time_evt->system_offset;
1684	//p_app->settings.utc_offset = (int)p_time_evt->utc_offset;
1685	p_app->have_time = true;
1686	}
1687	break;
1688
1689	case eCHM_EVT_TIMEZONE:
1690	{
1691	chm_tz_event_t p_tz_evt = (chm_tz_event_t)p_event;
1692	if (p_tz_evt->utc_offset & 0x10000)
1693	p_app->settings.utc_offset = (int)((0xFFFF & p_tz_evt->utc_offset) \| 0xFFFF0000);
1694	else
1695	p_app->settings.utc_offset = (int)(0xFFFF & p_tz_evt->utc_offset);
1696	p_app->settings.dst_delta = p_tz_evt->dst_delta;
1697	p_app->settings.dst_entry = p_tz_evt->dst_entry;
1698	p_app->settings.dst_exit = p_tz_evt->dst_exit;
1699	p_app->settings_dirty \|= DIRTY_MISC;
1700	}
1701	break;
1702	case eCHM_EVT_PHONENUMBER:
1703	if (strcmp((char*)&(p_app->settings.phonenumber),p_event->data) != 0)
1704	{
1705	if (strlen(p_event->data) > MAX_PHONE_LEN)
1706	p_event->data[MAX_PHONE_LEN-1] = 0;
1707	strcpy((char*)&(p_app->settings.phonenumber),p_event->data);
1708	p_app->settings_dirty \|= DIRTY_PHONE;
1709	}
1710	break;
1711	case eCHM_EVT_RESET:
1712	switch (p_event->id)
1713	{
1714	default:
1715	case 0: /* nop */
1716	break;
1717	case 1: /* reset */
1718	bapp_do_poweroff(p_app);
1719	break;
1720	case 2: /* reset some */
1721	bapp_reset_settings(p_app);
1722	/* save everything */
1723	p_app->settings_dirty = DIRTY_ALL;
1724	bapp_save_settings(p_app);
1725	bapp_do_poweroff(p_app);
1726	break;
1727	case 3: /* reset full */
1728	bapp_reset_settings(p_app);
1729	/* save everything */
1730	p_app->settings_dirty = DIRTY_ALL;
1731	bapp_save_settings(p_app);
1732	/* Erase downloaded firmware here */
1733	bapp_do_poweroff(p_app);
1734
1735	break;
1736	}
1737	break;
1738	case eCHM_EVT_SAVE:
1739	/* Must be careful of when this is done if running from flash */
1740	if ((p_app->settings.audio_vol != p_app->audio_vol) \|\| p_app->settings_dirty)
1741	{
1742	p_app->settings.audio_vol = p_app->audio_vol;
1743	bapp_save_settings(p_app);
1744	}
1745	break;
1746	default:
1747	BDBG_WRN(("%s:%d CHM EVENT = %d NOT HANDLED\n",__FUNCTION__,__LINE__,p_event->type));
1748	break;
1749	}
1750	BDBG_MSG(("%s:%d CHM EVENT = %d)\n",__FUNCTION__,__LINE__,p_event->type));
1751
1752	if (p_app->p_screens[p_app->screen_id].handle_event(p_app,
1753	(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event))
1754	{
1755	BDBG_WRN(("%s:%d screen_id %d\n",__FUNCTION__,__LINE__,p_app->screen_id));
1756	/* Wait for vsync then do screen drawing */
1757	bapp_new_screen(p_app);
1758	} else
1759	{
1760	bapp_handle_event(p_app,&screen_event);
1761	}
1762	}
1763	return new_state;
1764	}
1765
1766	/*
1767	Summary:
1768	Main event loop when in normal operation mode.
1769	*/
1770	static bapp_state_t bapp_run_main(bapp_t *p_app)
1771	{
1772	buser_input_event event;
1773	unsigned event_cnt;
1774	bscreen_event_t screen_event;
1775
1776	/* Check for UI event */
1777	if (buser_input_get_event(p_app->user_io,&event,1,&event_cnt) == b_ok)
1778	{
1779	if (event_cnt > 0)
1780	{
1781	p_app->last_keypress_tick = bos_getticks();
1782	bapp_handle_user_event(p_app,&event);
1783	}
1784	}
1785
1786	/* Yield control */
1787	bos_sleep(p_app->yield_ms);
1788
1789	if (!p_app->power) return p_app->state;
1790
1791	screen_event.type = eS_EVENT_IDLE;
1792	screen_event.id = 0;
1793	/* Give screen idle time to handle menu timeouts, etc */
1794	if (p_app->p_screens[p_app->screen_id].handle_event(p_app,
1795	(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event))
1796	{
1797	/* Wait for vsync then do screen drawing */
1798	bapp_new_screen(p_app);
1799	}
1800
1801	/* Do application idle time processing */
1802	bapp_idle(p_app);
1803
1804	return p_app->state;
1805	}
1806
1807	#if 0
1808	/*
1809	Summary:
1810	Main event loop when in normal operation mode.
1811	*/
1812	static bapp_state_t bapp_pending(bapp_t *p_app)
1813	{
1814	bscreen_event_t screen_event;
1815	unsigned short num_vch, num_st;
1816	unsigned char num_freq ;
1817	buser_input_event event;
1818	unsigned event_cnt;
1819
1820	/* Check for UI event */
1821	if (buser_input_get_event(p_app->user_io,&event,1,&event_cnt) == b_ok)
1822	{
1823	if (event_cnt > 0)
1824	{
1825	p_app->last_keypress_tick = bos_getticks();
1826	bapp_handle_user_event(p_app,&event);
1827	}
1828	}
1829
1830	screen_event.type = eS_EVENT_IDLE;
1831	screen_event.id = 0;
1832	/* Give screen idle time to handle menu timeouts, etc */
1833	if (p_app->p_screens[p_app->screen_id].handle_event(p_app,
1834	(void*)&(p_app->p_screens[p_app->screen_id]),&screen_event))
1835	{
1836	/* Wait for vsync then do screen drawing */
1837	bapp_new_screen(p_app);
1838	}
1839
1840	/* Yield control */
1841	bos_sleep(p_app->yield_ms);
1842
1843	/* Check to see if there is a channel map */
1844	ch_map_get_counts(bapp_cur_ch_map(p_app),&num_vch,&num_st,&num_freq);
1845
1846	#if 0
1847	if ((num_vch > 0) && (p_app->settings.activated \|\| (p_app->settings.VCT_ID == 0)))
1848	{
1849	BDBG_WRN(("%s:%d Switch to NORMAL State(%d,%d,%d)\n",__FUNCTION__,__LINE__,
1850	num_vch,p_app->settings.activated,p_app->settings.VCT_ID));
1851	return eAPP_STATE_NORMAL;
1852	}
1853	#endif
1854	return p_app->state;
1855	}
1856	#endif
1857
1858	/*
1859	Summary:
1860	Main event loop when in normal operation mode.
1861	*/
1862	static bapp_state_t bapp_downloading(bapp_t *p_app)
1863	{
1864
1865	/* Yield control */
1866	bos_sleep(p_app->yield_ms);
1867	return(p_app->chm.cmd == eCHM_DOWNLOAD) ? eAPP_STATE_DOWNLOAD : eAPP_STATE_NORMAL;
1868	}
1869
1870
1871	/*
1872	Summary:
1873	Perform a channel hunt (for cable ).
1874	*/
1875	static int bapp_channel_hunt(bapp_t *p_app)
1876	{
1877	p_app->chm_cmd.cmd_id = eCHM_HUNT;
1878	chm_cmd(&p_app->chm,&p_app->chm_cmd);
1879	return 0;
1880	}
1881
1882	/*
1883	Summary:
1884	Main app loop.
1885	Description:
1886	Main application event loop.
1887	*/
1888	#ifdef BCM_DEBUG
1889	static const char *s_app_state_name[] = { "DEFAULT","HUNTING","PENDING","NORMAL","DOWNLOAD","FACTORY","DONE"};
1890	#endif
1891
1892	static void bapp_eval_state(bapp_t *p_app,bapp_state_t new_state)
1893	{
1894	bapp_led_set_mode(p_app);
1895	led_update(APP_DEFAULT_YIELD);
1896	if (p_app->state == new_state)
1897	return;
1898
1899	BDBG_WRN(("from %s to %s\n",s_app_state_name[p_app->state], s_app_state_name[new_state] ));
1900
1901	/* Handle exiting current state */
1902	switch (p_app->state)
1903	{
1904	case eAPP_STATE_PENDING:
1905	if ((new_state == eAPP_STATE_NORMAL) && p_app->settings_dirty)
1906	{
1907	bapp_save_settings(p_app);
1908	}
1909	p_app->last_screen_id = eSCREEN_MAX;
1910	memset(&p_app->cur_vch,0,sizeof(p_app->cur_vch));
1911	break;
1912	case eAPP_STATE_HUNT:
1913	bapp_screen_redraw(p_app);
1914	bos_sleep(250); /* must display full progress bar for at least 250ms before proceding */
1915	case eAPP_STATE_DOWNLOAD:
1916	case eAPP_STATE_NORMAL:
1917	case eAPP_STATE_FACTORY:
1918	case eAPP_STATE_DEFAULT:
1919	case eAPP_STATE_DONE:
1920	break;
1921	}
1922
1923	/* Handle entering new state */
1924	switch (new_state)
1925	{
1926	case eAPP_STATE_HUNT:
1927	if (p_app->screen_id != eSCREEN_CH_SCAN_PROGRESS)
1928	// if (p_app->screen_id < eSCREEN_DIAG_MENU)
1929	{
1930	if (p_app->power)
1931	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1932	else
1933	bapp_set_current_screen(p_app, eSCREEN_POWER_OFF, eSCREEN_MAX);
1934	bapp_new_screen(p_app);
1935	}
1936	bapp_channel_hunt(p_app);
1937	break;
1938	case eAPP_STATE_NORMAL:
1939	if ((p_app->screen_id != eSCREEN_CH_SCAN_PROGRESS) && (p_app->screen_id != eSCREEN_GUIDE) &&
1940	(p_app->settings.ch_map.vch_map.num_vch > 0))
1941	// if (p_app->screen_id < eSCREEN_DIAG_MENU)
1942	{
1943	if (p_app->power) {
1944	/* in wizard mode, don't change the screen through eval_state*/
1945	if (p_app->settings.wiz_completed)
1946	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1947	}
1948	else
1949	bapp_set_current_screen(p_app, eSCREEN_POWER_OFF, eSCREEN_MAX);
1950	}
1951	bapp_new_screen(p_app);
1952	bapp_tune(p_app);
1953	break;
1954	case eAPP_STATE_DOWNLOAD:
1955	if (p_app->screen_id < eSCREEN_DIAG_MENU)
1956	{
1957	if (p_app->power)
1958	bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1959	else
1960	bapp_set_current_screen(p_app, eSCREEN_POWER_OFF, eSCREEN_MAX);
1961	bapp_new_screen(p_app);
1962	}
1963	p_app->chm_cmd.cmd_id = eCHM_DOWNLOAD;
1964	chm_cmd(&p_app->chm,&p_app->chm_cmd);
1965	break;
1966	case eAPP_STATE_FACTORY:
1967	bapp_set_current_screen(p_app, eSCREEN_STATUS, eSCREEN_MAX);
1968	bapp_new_screen(p_app);
1969	break;
1970	case eAPP_STATE_PENDING:
1971	case eAPP_STATE_DEFAULT:
1972	case eAPP_STATE_DONE:
1973	break;
1974	}
1975
1976	/* Make new state the current state */
1977	p_app->state = new_state;
1978	switch (new_state)
1979	{
1980	case eAPP_STATE_PENDING:
1981	bapp_screen_redraw(p_app);
1982	break;
1983	default:
1984	break;
1985	}
1986
1987	}
1988	/*
1989	Summary:
1990	Main app loop.
1991	Description:
1992	Main application event loop.
1993	*/
1994	void bapp_run(bapp_t *p_app)
1995	{
1996	bapp_state_t new_state;
1997	BDBG_WRN(("%s:%d - Start running.\n",__FUNCTION__,__LINE__));
1998
1999	while (p_app->state != eAPP_STATE_DONE)
2000	{
2001	new_state = p_app->state;
2002	switch (p_app->state)
2003	{
2004	case eAPP_STATE_HUNT:
2005	case eAPP_STATE_PENDING:
2006	// new_state = bapp_pending(p_app);
2007	// break;
2008	case eAPP_STATE_NORMAL:
2009	case eAPP_STATE_FACTORY:
2010	new_state = bapp_run_main(p_app);
2011	break;
2012	case eAPP_STATE_DOWNLOAD:
2013	new_state = bapp_downloading(p_app);
2014	break;
2015	case eAPP_STATE_DEFAULT:
2016	case eAPP_STATE_DONE:
2017
2018	/* Yield control */
2019	bos_sleep(p_app->yield_ms);
2020	break;
2021	}
2022
2023	/* Check for chm event */
2024	if (new_state == p_app->state)
2025	new_state = bapp_handle_chm_event(p_app);
2026
2027	bapp_eval_state(p_app,new_state);
2028	}
2029
2030	/* finish */
2031	bsettop_uninit();
2032	}
2033
2034	/*
2035	Summary:
2036	Return current application channel map.
2037	*/
2038	ch_map_t bapp_cur_ch_map(bapp_t p_app)
2039	{
2040	return &(p_app->settings.ch_map);
2041	}
2042
2043	/*
2044	Summary:
2045	Tune to the current frequency and get the VCT.
2046	Description:
2047	Tune to the current frequency and get the VCT. Returns non-zero on failure.
2048	*/
2049	int bapp_change_channel(bapp_t *p_app, int ch_up, int tune)
2050	{
2051	int retval = -1;
2052	bool result;
2053
2054	BDBG_MSG(("%s (%d,%d)\n",__FUNCTION__,ch_up,tune));
2055
2056	if (ch_up)
2057	{
2058	result = ch_map_set_next(bapp_cur_ch_map(p_app));
2059	} else
2060	{
2061	result = ch_map_set_prev(bapp_cur_ch_map(p_app));
2062	}
2063
2064	if (!result)
2065	{
2066	BDBG_ERR(("%s (%d,%d) failed \n",__FUNCTION__,ch_up,tune));
2067	return retval;
2068	}
2069
2070	if (tune)
2071	{
2072	retval = bapp_tune(p_app);
2073
2074	p_app->settings_dirty \|= DIRTY_CHANNEL;
2075	} else
2076	{
2077	retval = 0;
2078	}
2079	return retval;
2080	}
2081
2082	/*
2083	Summary:
2084	Tune to the specified channel.
2085	Description:
2086	Tune to the specified channel or nearest to the channel. Returns non-zero on failure.
2087	*/
2088	int bapp_set_channel(bapp_t *p_app, int channel)
2089	{
2090	int retval = -1;
2091	vch_t cur_vch;
2092	st_t cur_st;
2093	freq_t cur_freq;
2094	BDBG_WRN(("%s (%d)\n",__FUNCTION__,channel));
2095
2096	if (!ch_map_get_current(bapp_cur_ch_map(p_app),&cur_vch,&cur_st,&cur_freq))
2097	{
2098	BDBG_WRN(("%s Invalid current channel or map.\n",__FUNCTION__));
2099	return 0;
2100	}
2101	#if 1
2102	if (!ch_map_is_channel_visible(bapp_cur_ch_map(p_app),(unsigned short)channel))
2103	{
2104	BDBG_WRN(("%s Hidden channel %d\n",__FUNCTION__,channel));
2105	return 0;
2106	}
2107	#endif
2108	if (ch_map_set_ch(bapp_cur_ch_map(p_app),(unsigned short)channel))
2109	{
2110	p_app->settings_dirty \|= DIRTY_CHANNEL;
2111	retval = bapp_tune(p_app);
2112	}
2113
2114	return retval;
2115	}
2116
2117	/*
2118	Summary:
2119	Tune to the current channel.
2120	*/
2121	int bapp_tune(bapp_t *p_app)
2122	{
2123	vch_t new_vch;
2124	st_t new_st;
2125	freq_t new_freq;
2126
2127	if (p_app->settings.av_mute)
2128	return 0;
2129
2130	p_app->prev_vch = p_app->cur_vch;
2131
2132	/* check to see if the current channel info has changed */
2133	if (p_app->decoding)
2134	{
2135	if (!ch_map_get_current(bapp_cur_ch_map(p_app),&new_vch,&new_st,&new_freq))
2136	{
2137	BDBG_WRN(("%s Invalid current channel or map.\n",__FUNCTION__));
2138	return 0;
2139	}
2140	if ((new_freq.freq_khz == p_app->cur_freq.freq_khz) && (new_vch.program_num == p_app->cur_vch.program_num))
2141	{
2142	BDBG_WRN(("%s Channel info did not change skip re tune.\n",__FUNCTION__));
2143	return 0;
2144	}
2145	BDBG_WRN(("%s Channel Navigation Changed - Retune\n",__FUNCTION__));
2146	}
2147
2148	p_app->lock = false;
2149	p_app->power_level = 0;
2150
2151	p_app->tune_cmd.cmd_id = eCHM_TUNE;
2152	p_app->tune_cmd.type = eCHM_CURRENT;
2153	chm_cmd(&p_app->chm,(chm_cmd_event_t*)&p_app->tune_cmd);
2154	p_app->decoding = true;
2155	p_app->last_tune_tick = bos_getticks();
2156	if (!ch_map_get_current(bapp_cur_ch_map(p_app),&p_app->cur_vch,&p_app->cur_st,&p_app->cur_freq))
2157	{
2158	BDBG_WRN(("%s Invalid current channel or map.\n",__FUNCTION__));
2159	return 0;
2160	}
2161	return 0;
2162	}
2163	/*
2164	Summary:
2165	Tune to the current channel.
2166	*/
2167	int bapp_tune_prev(bapp_t *p_app)
2168	{
2169	return bapp_set_channel(p_app,p_app->prev_vch.ch_num);
2170	}
2171
2172	/*
2173	Summary:
2174	Restart audio decode (after SAP swap audio PID)
2175	*/
2176	int bapp_rotate_audio_sap(bapp_t *p_app)
2177	{
2178	// unsigned int flags;
2179	vch_t vch;
2180	st_t st;
2181	freq_t freq;
2182
2183	if (p_app->settings.av_mute \|\| !p_app->decoding)
2184	return 0;
2185
2186	if (!ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq))
2187	{
2188	BDBG_WRN(("%s Invalid current channel or map.\n",__FUNCTION__));
2189	return 0;
2190	}
2191
2192	if (vch.num_audio <= 1)
2193	return 0;
2194
2195	vch.cur_audio++;
2196	if ( vch.cur_audio >= vch.num_audio)
2197	{
2198	vch.cur_audio = 0;
2199	}
2200
2201	if (!ch_map_vch_update(bapp_cur_ch_map(p_app),&vch))
2202	{
2203	BDBG_WRN(("%s Error updating channel map.\n",__FUNCTION__));
2204	return 0;
2205	}
2206
2207	p_app->chm_cmd.cmd_id = eCHM_SAP;
2208	chm_cmd(&p_app->chm,&p_app->chm_cmd);
2209	return 0;
2210	}
2211	int bapp_rotate_dsub(bapp_t *p_app)
2212	{
2213	#ifdef CONFIG_DVB_SUBTITLE
2214	vch_t vch;
2215	st_t st;
2216	freq_t freq;
2217	uint16_t cur_pid;
2218
2219	if (!ch_map_get_current(bapp_cur_ch_map(p_app), &vch, &st, &freq))
2220	{
2221	BDBG_WRN(("%s Invalid current channel or map.", __FUNCTION__));
2222	return 0;
2223	}
2224
2225	if (vch.num_dsub <= 1)
2226	return 0;
2227
2228	cur_pid = vch.dsub_pid[vch.cur_dsub];
2229	vch.cur_dsub++;
2230	if (vch.cur_dsub >= vch.num_dsub)
2231	vch.cur_dsub = 0;
2232
2233	if (!ch_map_vch_update(bapp_cur_ch_map(p_app), &vch))
2234	{
2235	BDBG_WRN(("%s Error updating channel map", __FUNCTION__));
2236	return 0;
2237	}
2238
2239	if (cur_pid != vch.dsub_pid[vch.cur_dsub]) {
2240	p_app->chm_cmd.cmd_id = eCHM_DSUB;
2241	chm_cmd(&p_app->chm, &p_app->chm_cmd);
2242	}
2243	#endif
2244	return 0;
2245	}
2246
2247	/*
2248	Summary:
2249	set CLUT
2250	*/
2251	void bapp_set_palette(bapp_t *p_app, bapp_palette_t palette)
2252	{
2253	#ifndef CONFIG_GFX_ARGB32
2254	unsigned int clut; / [out] address of palette */
2255	int width; /* [out] width of the OSD surface */
2256	int height; /* [out] height of the OSD surface */
2257	int pitch; /* [out] pitch of the OSD surface */
2258	unsigned int *p_palette;
2259	unsigned int size;
2260	bgraphics_get_framebuffer(p_app->graphics,(void)&p_app->osd_mem,(unsigned int )&clut,&width,&height,&pitch);
2261
2262	switch (palette)
2263	{
2264	case ePALETTE_SCREENSAVER:
2265	if (p_app->logo)
2266	{
2267	bcm_raw_8_t p_header = (bcm_raw_8_t )p_app->logo;
2268	uint8_t p_clut = (uint8_t )p_header;
2269	p_clut += sizeof(bcm_raw_8_t);
2270	memcpy(clut, p_clut, p_header->clut_size*sizeof(unsigned int));
2271	}
2272	else if (bapp_palette_get(ePALETTE_LOGO, &p_palette, &size) == b_ok)
2273	{
2274	BKNI_Memcpy(clut, p_palette, size*sizeof(p_palette[0]));
2275	}
2276	bgraphics_load_palette(p_app->graphics);
2277	break;
2278	case ePALETTE_DEFAULT:
2279	default:
2280	if (bapp_palette_get(palette,&p_palette,&size) == b_ok) {
2281	BKNI_Memcpy(clut,p_palette,size*sizeof(p_palette[0]));
2282	bgraphics_load_palette(p_app->graphics);
2283	}
2284	break;
2285	}
2286	#endif
2287	}
2288
2289	/*
2290	Summary:
2291	returns true is sufficient signal strength, false otherwise
2292	always returns true for TUNE_DURATION msecs after tuning begins.
2293	*/
2294	bool bapp_get_signal_status(bapp_t *p_app)
2295	{
2296	static bool first_call = true;
2297	static bool good_signal = true;
2298	static uint32_t last_video_pts = 0;
2299	static uint32_t last_video_pts_ticks = 0;
2300	static uint32_t last_audio_pts = 0;
2301	vch_t vch;
2302	st_t st;
2303	freq_t freq;
2304	bdecode_config cfg;
2305
2306	static bdecode_status status;
2307	static baudio_decode_status audio_status;
2308
2309	uint32_t current_ticks = bos_getticks();
2310
2311	/* If the decode is stopped dont report bad signal */
2312	if (p_app->decoding == false)
2313	return true;
2314
2315	/* check for tune duration timeout - this is used to restrict display of the 'no signal'
2316	popup for a period of time (TUNE_DURATION) after tuning */
2317	if (current_ticks < (p_app->last_tune_tick + MS_TO_TICKS(TUNE_DURATION)))
2318	return true;
2319
2320	if (!ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq))
2321	return false;
2322
2323	/* if first time calling function get baseline video pts
2324	* then wait 500msecs and continue. since we require 2 samples
2325	* of decoder status at least 500msecs apart to determine signal
2326	* status, we need to "prime the pump" on the very first call only
2327	*/
2328	if (first_call)
2329	{
2330	first_call = false;
2331	bdecode_get_status(p_app->decode,&status);
2332	baudio_decode_get_status(p_app->audio, &audio_status);
2333	last_video_pts = status.video_pts;
2334	last_video_pts_ticks = current_ticks;
2335	bos_sleep(500);
2336	current_ticks = bos_getticks();
2337
2338	last_audio_pts = audio_status.pts;
2339	}
2340
2341	/* make sure video pts is changing - indicates successful decoding.
2342	* only check every 500msecs or so
2343	*/
2344	if ((current_ticks - last_video_pts_ticks) > MS_TO_TICKS(500))
2345	{
2346	bdecode_get_status(p_app->decode,&status);
2347	baudio_decode_get_status(p_app->audio, &audio_status);
2348
2349	/* if pts is changing, we are decoding properly */
2350	good_signal = (last_video_pts != status.video_pts);
2351
2352	if (good_signal == false)
2353	{
2354	good_signal = (last_audio_pts != audio_status.pts);
2355	}
2356	last_audio_pts = audio_status.pts;
2357	BDBG_MSG(("good_signal:%d vpts:0x%08x last_vpts:0x%08x ticks:%d", good_signal, status.video_pts, last_video_pts, current_ticks));
2358
2359	last_video_pts = status.video_pts;
2360	last_video_pts_ticks = current_ticks;
2361	}
2362
2363	bdecode_get_config(p_app->decode,&cfg);
2364	if (!good_signal)
2365	{
2366	if (cfg.channel_change != 0)
2367	{
2368	bapp_audio_mute(p_app, 1);
2369	cfg.mute = 1;
2370	cfg.channel_change = 0;
2371	bdecode_set_config(p_app->decode,&cfg);
2372	}
2373	} else
2374	{
2375	if (cfg.channel_change != 2)
2376	{
2377	bapp_audio_mute(p_app, 0);
2378	cfg.mute = 0;
2379	cfg.channel_change = 2;
2380	bdecode_set_config(p_app->decode,&cfg);
2381	}
2382	}
2383
2384	return good_signal;
2385	}
2386
2387	/*
2388	Summary:
2389	Return the current screen.
2390	*/
2391
2392	bscreen_t * bapp_get_current_screen(bapp_t *p_app)
2393	{
2394	return &p_app->p_screens[p_app->screen_id];
2395	}
2396
2397	void ram_start()
2398	{
2399	static bapp_t app;
2400	bapp_init(&app);
2401	bapp_run(&app);
2402	}
2403
2404
2405	/*
2406	Summary:
2407	Mute audio
2408	Description:
2409	Mute audio when enable is non-zero.
2410	*/
2411	void bapp_audio_do_mute(bapp_t *p_app, int mute)
2412	{
2413	baudio_decode_config config;
2414
2415	BDBG_WRN(("%s mute = %d, audo_vol = %d, is_muted = %d...\n",__FUNCTION__,mute,p_app->audio_vol,p_app->is_muted));
2416	if (p_app->is_muted && !mute)
2417	{
2418	p_app->system_mute = (mute == 0)?false:true;
2419	return;
2420	}
2421
2422	baudio_decode_get_config(p_app->audio, &config);
2423
2424	if (mute != config.mute)
2425	{
2426	config.mute = mute;
2427	baudio_decode_set_config(p_app->audio, &config);
2428	}
2429	p_app->system_mute = (mute== 0) ? false : true;
2430	}
2431
2432	/*
2433	* Callback to process first pts timing profiling
2434	*/
2435	static void bapp_first_pts_callback(void)
2436	{
2437	BDBG_WRN(("##### timing profile ####"));
2438	timing_profile_stop(s_p_app->ptp_first_pts);
2439	}
2440
2441	/*
2442	* Callback to process first pts timing profiling
2443	*/
2444	static void bapp_seq_hdr_callback(void)
2445	{
2446	BDBG_WRN(("##### timing profile ####"));
2447	timing_profile_stop(s_p_app->ptp_decode);
2448	}
2449
2450	bool bapp_get_block_status(bapp_t *p_app)
2451	{
2452	return false;
2453	}
2454	/* select primary output path to enable deinterlacer
2455	* mode : 1 for HD path, 2 for SD path
2456	*/
2457	void bapp_select_primary_output(bapp_t *p_app, int mode)
2458	{
2459	if (!p_app) p_app = s_p_app;
2460
2461	bdisplay_set_deinterlacer(p_app->display,(mode==2)?1:0, true);
2462	}
2463
2464	/* select SCL's coefficient index
2465	* val : 1- 26 (1: soft -> 26: sharp
2466	*/
2467	void bapp_select_scaler_coefficient(bapp_t *p_app, bool horizontal, int output, int coeff_idx)
2468	{
2469	if (!p_app) p_app = s_p_app;
2470	if (coeff_idx < 1 \|\| coeff_idx > 26)
2471	{
2472	BDBG_WRN(("Invalid SCL coefficient index : %d", coeff_idx));
2473	return;
2474	}
2475	bdisplay_set_coefficient_index(p_app->display, horizontal, output, coeff_idx);
2476	}
2477
2478	#ifdef OOB_TUNER_SUPPORT
2479
2480	/*
2481	* Set OOB flag so that the message filter will get message from OOB input instead
2482	*/
2483	void bapp_set_oob_flag(int oob)
2484	{
2485	}
2486	#endif
2487	void bapp_get_avl_settings(int target, int low, int *boost)
2488	{
2489	baudio_decode_config aconfig;
2490	bapp_t p_app = (bapp_t )s_p_app;
2491	baudio_decode_get_config(p_app->audio, &aconfig);
2492	*target = aconfig.avl_target/100;
2493	*low = aconfig.avl_lowerbound/100;
2494	*boost = aconfig.avl_fixedboost/100;
2495	}
2496
2497	void bapp_set_avl_settings(int target, int low, int boost)
2498	{
2499	baudio_decode_config aconfig;
2500	bapp_t p_app = (bapp_t )s_p_app;
2501
2502	baudio_decode_get_config(p_app->audio, &aconfig);
2503	aconfig.avl_fixedboost = boost*100;
2504	aconfig.avl_target = target*100;
2505	aconfig.avl_lowerbound = low*100;
2506	baudio_decode_set_config(p_app->audio, &aconfig);
2507	}
2508

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/trunk/newcon3bcm2_21bu/dta/src/app/nanotv/bapp.c @ 29

Download in other formats: