source: svn/newcon3bcm2_21bu/dta/src/app/ntia/bscreen_status.c @ 43

Last change on this file since 43 was 43, checked in by megakiss, 11 years ago

광주방송 OTC 주파수 369Mhz로 변경
  • Property svn:executable set to *
File size: 30.0 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 "bsettop_display.h"
24#include "bstd.h"
25#include "bapp_util.h"
26#include "ministd.h"
27#include "bgfx.h"
28#include "chan_mgr.h"
29#include "bscreen_status_str.c"
30#include "bscreen.h"
31
32BDBG_MODULE(bscreen_status);             /* Register software module with debug interface */
33
34extern bool g_disable_fcc; 
35
36static bool scan_channels = false;      /* whether scan the channels or not */
37
38#define MAX_TSTR_LEN    128
39typedef enum dbg_layout_t
40{
41        eINFO_X                    = eSCREEN_ACTION_SAFE_X,
42        eINFO_STATUS_X     = eSCREEN_ACTION_SAFE_X + 20,
43        eINFO_STATUS_Y     = eSCREEN_ACTION_SAFE_Y,
44        eINFO_COL_WIDTH    = eSCREEN_ACTION_SAFE_WIDTH/2,
45        eINFO_COL_LABEL_WIDTH  = eINFO_COL_WIDTH,
46        eINFO_ROW_HEIGHT   = 24,
47        eINFO_HELP_Y       = (eSCREEN_ACTION_SAFE_HEIGHT + eSCREEN_ACTION_SAFE_Y - eINFO_ROW_HEIGHT),
48        eCH_MAP_START_X    = eSCREEN_ACTION_SAFE_X,
49        eCH_MAP_START_Y    = eSCREEN_ACTION_SAFE_Y,
50        eCH_MAP_HDR_Y      = (eSCREEN_ACTION_SAFE_Y + eINFO_ROW_HEIGHT),
51        eCH_MAP_ROW_Y      = eCH_MAP_HDR_Y,
52        eCH_MAP_COL_WIDTH  = (eSCREEN_ACTION_SAFE_WIDTH/6),
53        eCH_MAP_ROW_HEIGHT = 24,
54        eCH_MAP_NUM_ROW    = (((eSCREEN_ACTION_SAFE_HEIGHT - 3*eINFO_ROW_HEIGHT)/eCH_MAP_ROW_HEIGHT) - 1),
55        eDIAG_ROW_HEIGHT   = 24,
56        eDIAG_START_X      = eSCREEN_ACTION_SAFE_X,
57        eDIAG_MENU_X       = (eDIAG_START_X + 20),
58        eDIAG_START_Y      = eSCREEN_ACTION_SAFE_Y,
59        eDIAG_HELP_Y       = (eSCREEN_ACTION_SAFE_Y + eSCREEN_ACTION_SAFE_HEIGHT - eDIAG_ROW_HEIGHT),
60        eDIAG_COL_WIDTH    = (eSCREEN_ACTION_SAFE_WIDTH),
61
62        /* customize frequencies support */
63        eMENU_FREQUENCY_X =                    (eMENU_TITLE_TEXT_X),
64        eMENU_FREQUENCY_Y =                    (eMENU_TITLE_DESC_TEXT_Y+40),
65        eMENU_FREQUENCY_WIDTH =                300,
66        eMENU_FREQUENCY_HEIGHT=                33,
67        eMENU_FREQ_ROW_START_Y=                (eMENU_FREQUENCY_Y+45),
68        eMENU_FREQ_COLUMN_HEIGHT=              30,
69        eMENU_FREQ_COLUMN_WIDTH=               (eSCREEN_ACTION_SAFE_WIDTH-eMENU_TITLE_TEXT_X)/5,
70
71}dbg_layout_t;
72
73typedef enum sys_info_state_t
74{
75        eSYS_CODE_0,
76        eSYS_CODE_1,
77        eSYS_CODE_2,
78        eSYS_CODE_MAX,
79}sys_info_state_t;
80
81typedef struct sys_info_t
82{
83        sys_info_state_t state;
84        unsigned int code;
85}sys_info_t;
86
87static sys_info_t s_sys_info = { eSYS_CODE_0, 0};
88
89static char ts_str[MAX_TSTR_LEN + 1];
90
91/*
92Summary:
93        Handle special debug commands for test purposes or diagnostics.
94*/
95
96static void bscreen_sys_info_handler(bapp_t *p_app,bscreen_t *p_screen, bIR_codes_t code)
97{
98        static unsigned int s_timeout = 0;
99
100        BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
101        if (s_timeout < bos_getticks())
102        {
103                s_sys_info.code = 0;
104                s_sys_info.state = 0;
105        }
106        s_sys_info.code |= (code & 0xFF) << (8 * s_sys_info.state);
107        s_sys_info.state++;
108        BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
109        s_timeout = bos_getticks() + MS_TO_TICKS(BANNER_10_KEY_TIMEOUT);
110#ifdef BCM_DEBUG
111        if (s_sys_info.state == eSYS_CODE_MAX)
112        {
113                switch (s_sys_info.code)
114                {
115                        default:
116                                break;
117                }
118                s_sys_info.state = eSYS_CODE_0;
119                s_sys_info.code = 0;
120        }
121#endif
122}
123
124/*
125Summary:
126        Return status strings.
127*/
128
129static void bscreen_general_info_str(bapp_t *p_app,
130          bscreen_t *p_screen,
131          int text_id,                          /* Text id */
132          unsigned int *p_uni_str,      /* Buffer to put UNI string into */
133          unsigned int *str_len,        /* On input the max length in words on output the actual size in characters. */
134          void *data                            /* User data */
135         )
136{
137        *str_len = 0;
138
139        switch (text_id)
140        {
141                case 0: 
142                        strcpy(ts_str,DEF_VENDOR_NAME);
143                        *str_len = strlen(ts_str);
144                        break;
145                case 1: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",DEF_VENDOR_ID); break;
146                case 2: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d.%d.%d",MAJOR_VERSION,MINOR_VERSION,SUB_VERSION); break;
147                case 3: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s", __DATE__); break;
148        }
149        if (*str_len)
150        {
151                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
152        }
153}
154
155/*
156Summary:
157        Return tunre status strings for diagnostic
158*/
159
160static void bscreen_tuner_status_str(bapp_t *p_app,
161        bscreen_t *p_screen,
162        int text_id,                            /* Text id */
163        unsigned int *p_uni_str,        /* Buffer to put UNI string into */
164        unsigned int *str_len,          /* On input the max length in words on output the actual size in characters. */
165        void *data                                      /* User data */
166        )
167{
168        uint32_t freq_mhz, freq_fraction;
169        bapp_ch_t *pch;
170
171        *str_len = 0;
172
173        if (NULL == (pch = bapp_is_channel_valid(p_app))) {
174                BDBG_WRN(("No tuner information"));
175                return;
176        }
177
178        freq_mhz = pch->frequency_khz / 1000;
179        freq_fraction = (pch->frequency_khz % 1000);
180
181        switch (text_id)
182        {
183        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%03d.%03d", freq_mhz, freq_fraction); break;
184        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s", p_app->tuner_status.lock ? "yes" : "no"); break;
185        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d%", p_app->power_level); break;
186        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d (%d.%d dB)", p_app->tuner_status.snr, p_app->tuner_status.snr/256, ((p_app->tuner_status.snr % 256) * 100)/256); break;
187        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d%", p_app->tuner_status.PreRS); break;
188        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d", p_app->tuner_status.agcIntLevel); break;
189        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d", p_app->tuner_status.correctedCount); break;
190        default:
191                break;
192        }
193
194        if (*str_len)
195        {
196                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
197        }
198}
199
200/*
201Summary:
202        Return status strings.
203*/
204
205static void bscreen_ch_status_str(bapp_t *p_app,
206          bscreen_t *p_screen,
207          int text_id,                          /* Text id */
208          unsigned int *p_uni_str,      /* Buffer to put UNI string into */
209          unsigned int *str_len,        /* On input the max length in words on output the actual size in characters. */
210          void *data                            /* User data */
211         )
212{
213        bapp_ch_t *pch;
214
215        *str_len = 0;
216
217        if (NULL == (pch = bapp_is_channel_valid(p_app))) {
218                BDBG_WRN(("No channel status inforamtion"));
219                return;
220        }
221
222        switch (text_id)
223        {
224        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d.%d",pch->major, pch->minor); break;
225        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",pch->psi ? "PSI" : "VCT"); break;
226        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04x", pch->pcr_pid); break;
227        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04x", pch->video_pid); break;
228        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",pch->hidden ? "yes" : "no"); break;
229        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d", pch->program_num); break;
230
231        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",pch->num_audio); break;
232        case 7: 
233                         if (pch->audio_lang[0][0]) {
234                                 *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X [%c%c%c] %s", pch->audio_pid[0],
235                                         pch->audio_lang[0][0], pch->audio_lang[0][1], pch->audio_lang[0][2],
236                                         (pch->cur_audio == 0) ? "*" : " ");
237                         }
238                         else {
239                                 *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X %s", pch->audio_pid[0],
240                                        (pch->cur_audio == 0) ? "*" : " ");
241                         }
242                         break;
243        case 8: 
244                         if (pch->audio_lang[1][0]) {
245                                 *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X [%c%c%c] %s",pch->audio_pid[1],
246                                         pch->audio_lang[1][0], pch->audio_lang[1][1], pch->audio_lang[1][2],
247                                         (pch->cur_audio == 1) ? "*" : " ");
248                         }
249                         else {
250                                 *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X %s", pch->audio_pid[1],
251                                        (pch->cur_audio == 1) ? "*" : " ");
252                         }
253                         break; 
254        case 9: 
255                         if (MAX_AUDIO_PIDS > 2) {
256                                 if (pch->audio_lang[2][0]) {
257                                         *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X [%c%c%c] %s",pch->audio_pid[2],
258                                                         pch->audio_lang[2][0], pch->audio_lang[2][1], pch->audio_lang[2][2],
259                                                         (pch->cur_audio == 2) ? "*" : " ");
260                                 }
261                                 else {
262                                         *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X %s", pch->audio_pid[2],
263                                                         (pch->cur_audio == 2) ? "*" : " ");
264                                 }
265                         }
266                         break;
267        case 10:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s", p_app->is_muted ? "yes" : "no"); break;
268        default:
269                          break;
270        }
271        if (*str_len)
272        {
273                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
274        }
275}
276
277/*
278Summary:
279Use the this function to get a UNI string.
280*/
281
282static void bscreen_decoder_status_str(bapp_t *p_app,
283                bscreen_t *p_screen,
284                int text_id,                            /* Text id */
285                unsigned int *p_uni_str,        /* Buffer to put UNI string into */
286                unsigned int *str_len,  /* On input the max length in words on output the actual size in characters. */
287                void *data)
288{
289        static bdecode_status status;
290        static baudio_decode_status     audio_status;
291
292        if (NULL == bapp_is_channel_valid(p_app)) {
293                return;
294        }
295
296        *str_len = 0;
297        memset(&status, 0, sizeof(status));
298        memset(&audio_status, 0, sizeof(audio_status));
299        bdecode_get_status(p_app->decode,&status);
300        baudio_decode_get_status(p_app->audio, &audio_status);
301
302        switch (text_id)
303        {
304                case 0: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X, 0x%04X, 0x%04X",status.vPID,audio_status.pid,status.pcrPID); break;
305                case 1: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",status.video_stc,status.video_pts); break;
306                case 2: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",audio_status.stc,audio_status.pts); break;
307                case 3: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)audio_status.pts - (int)status.video_pts); break;
308                case 4: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)audio_status.stc-(int)audio_status.pts); break;
309                case 5: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)status.video_stc-(int)status.video_pts);  break;
310                case 6: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d,%d/%d",audio_status.fifo_depth,audio_status.fifo_size,status.video_fifo_depth,status.video_fifo_size); break;
311                case 7: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d:%d(%s,%d)",status.source_width,status.source_height,(status.bStreamProgressive ? "P" : "I"),status.video_aspect_ratio); break;
312                case 8: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->tune_ms); break;
313                case 9: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d/%d",p_app->si_ms,TICKS_TO_MS(status.seq_ticks),TICKS_TO_MS(status.first_pts_ticks)); break;
314                case 10: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s", "stereo"); break;
315                default:
316                                 break;
317        }
318
319        if (*str_len)
320        {
321                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
322        }
323}
324
325/*
326Summary:
327Status screen drawing function.
328*/
329static void bscreen_diag_list_draw(bapp_t *p_app, 
330                bscreen_t *p_screen,
331                const unsigned char *p_title_str,
332                const unsigned char *p_label_str[],
333                get_str_t get_str_fcn,
334                bool track_selection
335                )
336{
337        uint16_t x,y,y_off;
338        unsigned int num_chars = 0;
339        bcolor_idx_t text_color;
340        int i;
341
342        x = eINFO_STATUS_X;
343        y = eINFO_STATUS_Y;
344
345        i = 0;
346
347        y += eINFO_ROW_HEIGHT + 6;
348
349        while (*(p_label_str[i]) != '\0')
350        {
351                text_color = eCOLOR_WHITE;
352                y_off = y + (i * eINFO_ROW_HEIGHT);
353                if ((y_off + eINFO_ROW_HEIGHT) >= eHEIGHT)
354                {
355                        BDBG_WRN(("%s too many rows %d, y = %d\n",__FUNCTION__,i,y_off));
356                        break;
357                }
358                bgfx_fill_rect(&p_app->surf,x,y_off,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
359                num_chars = strlen(p_label_str[i]);
360                num_chars = c_to_uni_str((unsigned char*)p_label_str[i],p_app->tmp_str,num_chars);
361
362                if (track_selection && (i == p_screen->local_state))
363                {
364                        text_color = eCOLOR_DK_YELLOW;
365                }
366                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
367                                x, y_off, eINFO_COL_LABEL_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, text_color,0);
368
369                num_chars = SCREEN_MAX_STR_WIDTH;
370                get_str_fcn(p_app,p_screen,i,p_app->tmp_str, &num_chars,NULL);
371                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
372                                x + eINFO_COL_LABEL_WIDTH, y_off, eWIDTH - x - eINFO_COL_WIDTH, eINFO_ROW_HEIGHT, 
373                                p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
374                i++;
375        }
376}
377
378/*
379Summary:
380Status screen drawing function.
381*/
382static void bscreen_diag_draw(bapp_t *p_app, 
383                bscreen_t *p_screen,
384                const unsigned char *p_title_str,
385                const unsigned char *p_help_str,
386                const unsigned char *p_label_str[],
387                get_str_t get_str_fcn,
388                bool track_selection
389                )
390{
391        uint16_t x,y;
392        unsigned int num_chars = 0;
393        int page;
394
395        page = p_screen->local_state;
396        x = eINFO_X;
397        y = eINFO_STATUS_Y;
398
399        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
400
401        bgfx_fill_rect(&p_app->surf,x,y,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
402        num_chars = strlen(p_title_str);
403        num_chars = c_to_uni_str((unsigned char*)p_title_str,p_app->tmp_str,num_chars);
404        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
405                        x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
406
407        bscreen_diag_list_draw(p_app,p_screen,p_title_str,p_label_str,get_str_fcn,track_selection);
408
409        num_chars = strlen(p_help_str);
410        num_chars = c_to_uni_str((unsigned char*)p_help_str,p_app->tmp_str,num_chars);
411        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
412                        x, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
413}
414
415int bscreen_diag_event(bapp_t *p_app, bscreen_t *p_screen, 
416                bscreen_event_t *p_event,
417                void (*draw_fcn)(void *v_app, void *v_screen),
418                int refresh)
419{
420        int result = 0;
421        static int cnt = 0;
422
423        switch (p_event->type)
424        {
425                case eS_EVENT_SETUP:
426                        p_screen->local_state = 0;
427                        bapp_enable_cc(p_app, false);
428                        bapp_audio_do_mute(p_app, true);
429                        bapp_video_mute(p_app, true);
430                        scan_channels = false;
431                        result = 1;
432                        break;
433
434                case eS_EVENT_SETUP_DONE:
435                        if (eSCREEN_TUNER_STATUS == p_app->screen_id) {
436                                p_app->chm_cmd.cmd_id = eCHM_CHECK_SIGNAL;
437                                chm_cmd(&p_app->chm,&p_app->chm_cmd);
438                                p_app->check_signal = true;
439                        }
440                        result = 1;
441                        break;
442
443                case eS_EVENT_IDLE:
444                        if (refresh <= 0)
445                                break;
446                        if (cnt++ == 20)
447                        {
448                                cnt = 0;
449                                draw_fcn(p_app,p_screen);
450                                result = 1;
451                        }
452                        break;
453
454                case eS_EVENT_IR:
455                        {
456                                BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
457                                switch (p_event->id)
458                                {
459                                        case eIR_INFO:
460                                                if (eSCREEN_TUNER_STATUS == p_app->screen_id) {
461                                                        p_app->chm_cmd.cmd_id = eCHM_INFO;
462                                                        chm_cmd(&p_app->chm,&p_app->chm_cmd);
463                                                        p_app->check_signal = false;
464                                                }
465                                                /* only set screen if there is signal, otherwise there will be a flash of video before entering to no signal screen */
466                                                if (bapp_get_signal_status(p_app)) {
467                                                        bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
468                                                        bapp_enable_cc(p_app, true);
469                                                        bapp_audio_do_mute(p_app, false);
470                                                        bapp_video_mute(p_app, false);
471                                                }
472                                                result = 1;
473                                                break;
474                                        case eIR_MENU:
475                                                if (eSCREEN_TUNER_STATUS == p_app->screen_id) {
476                                                        p_app->chm_cmd.cmd_id = eCHM_CANCEL;
477                                                        chm_cmd(&p_app->chm,&p_app->chm_cmd);
478                                                        p_app->check_signal = false;
479                                                }
480                                                bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
481                                                result = 1;
482                                                break;
483                                        default:
484                                                break;
485                                }
486                                break;
487                        }
488                        break;
489                default:
490                        result = bscreen_default_event(p_app,p_screen,p_event);
491                        break;
492        }
493        return result; /* always handle event */
494}
495/*
496Summary:
497Status screen drawing function.
498 */
499void bscreen_sys_info_draw(void *v_app, void *v_screen)
500{
501        bapp_t *p_app = (bapp_t*)v_app;
502        bscreen_t *p_screen = (bscreen_t*)v_screen;
503        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_GENERAL_INFO],
504                        (unsigned char *)s_diag_help_simple,s_general_info_str,
505                        (get_str_t)bscreen_general_info_str,false);
506}
507
508/*
509Summary:
510Status screen event handling function.
511 */
512int bscreen_sys_info_event(void *v_app, void *v_screen, bscreen_event_t *p_event)
513{
514        bapp_t *p_app = (bapp_t*)v_app;
515        bscreen_t *p_screen = (bscreen_t*)v_screen;
516        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_sys_info_draw,-1);
517}
518
519/*
520Summary:
521Status screen drawing function.
522 */
523void bscreen_tuner_status_draw(void *v_app, void *v_screen)
524{
525        bapp_t *p_app = (bapp_t*)v_app;
526        bscreen_t *p_screen = (bscreen_t*)v_screen;
527        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_TUNER_STATUS],
528                        (unsigned char *)s_diag_help_default,s_tuner_status_str,
529                        (get_str_t)bscreen_tuner_status_str,false);
530}
531
532/*
533Summary:
534Status screen event handling function.
535 */
536int bscreen_tuner_status_event(void *v_app, void *v_screen, bscreen_event_t *p_event)
537{
538        bapp_t *p_app = (bapp_t*)v_app;
539        bscreen_t *p_screen = (bscreen_t*)v_screen;
540        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_tuner_status_draw,1);
541}
542
543/*
544Summary:
545Status screen drawing function.
546 */
547void bscreen_decoder_status_draw(void *v_app, void *v_screen)
548{
549        bapp_t *p_app = (bapp_t*)v_app;
550        bscreen_t *p_screen = (bscreen_t*)v_screen;
551        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_DECODER_STATUS],
552                        (unsigned char *)s_diag_help_simple,s_decoder_status_str,
553                        (get_str_t)bscreen_decoder_status_str,false);
554}
555/*
556Summary:
557Status screen event handling function.
558 */
559int bscreen_decoder_status_event(void *v_app, void *v_screen, bscreen_event_t *p_event)
560{
561        bapp_t *p_app = (bapp_t*)v_app;
562        bscreen_t *p_screen = (bscreen_t*)v_screen;
563        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_decoder_status_draw,1);
564}
565
566/*
567Summary:
568Status screen drawing function.
569 */
570void bscreen_ch_status_draw(void *v_app, void *v_screen)
571{
572        bapp_t *p_app = (bapp_t*)v_app;
573        bscreen_t *p_screen = (bscreen_t*)v_screen;
574        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_CH_STATUS],
575                        (unsigned char *)s_diag_help_in_use,s_ch_status_str,
576                        (get_str_t)bscreen_ch_status_str,false);
577}
578/*
579Summary:
580Status screen event handling function.
581 */
582int bscreen_ch_status_event(void *v_app, void *v_screen, bscreen_event_t *p_event)
583{
584        bapp_t *p_app = (bapp_t*)v_app;
585        bscreen_t *p_screen = (bscreen_t*)v_screen;
586        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_ch_status_draw,1);
587}
588
589int bscreen_diag_menu_event(void *v_app, void *v_screen, bscreen_event_t *p_event)
590{
591        bapp_t *p_app = (bapp_t*)v_app;
592        bscreen_t *p_screen = (bscreen_t*)v_screen;
593        int result = 0;
594
595        switch (p_event->type)
596        {
597                case eS_EVENT_SETUP:
598                        // Don't reset so we return with same item selectd p_screen->local_state = 0;
599                        s_sys_info.state = eSYS_CODE_0;
600                        bapp_enable_cc(p_app, 0);
601                        bapp_audio_do_mute(p_app, true);
602                        bapp_video_mute(p_app, true);
603                        result = 1;
604                        break;
605                case eS_EVENT_IDLE:
606                        {
607                                /* Do anything that requires periodic action here */
608                        }
609                        break;
610
611                case eS_EVENT_IR:
612                        {
613                                BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
614                                switch (p_event->id)
615                                {
616                                        case eIR_CH_UP:
617                                        case eIR_UP:
618                                                p_screen->local_state--;
619                                                if ((int)p_screen->local_state <= 0)
620                                                        p_screen->local_state = eMM_IDX_NUM - 1;
621                                                result = 1;
622                                                break;
623                                        case eIR_CH_DOWN:
624                                        case eIR_DOWN:
625                                                p_screen->local_state++;
626                                                if (p_screen->local_state >= eMM_IDX_NUM)
627                                                        p_screen->local_state = 0;
628                                                result = 1;
629                                                break;
630                                        case eIR_SELECT:
631                                                switch (p_screen->local_state)
632                                                {
633                                                        case 0:
634                                                                bapp_set_current_screen(p_app, eSCREEN_SYS_INFO, eSCREEN_MAX);
635                                                                result = 1;
636                                                                break;
637                                                        case 1:
638                                                                bapp_set_current_screen(p_app, eSCREEN_TUNER_STATUS, eSCREEN_MAX);
639                                                                result = 1;
640                                                                break;
641                                                        case 2:
642                                                                bapp_set_current_screen(p_app, eSCREEN_CH_STATUS, eSCREEN_MAX);
643                                                                result = 1;
644                                                                break;
645                                                        case 3:
646                                                                bapp_set_current_screen(p_app, eSCREEN_DECODER_STATUS, eSCREEN_MAX);
647                                                                result = 1;
648                                                                break;
649                                                        case 4:
650                                                                bapp_set_current_screen(p_app, eSCREEN_FREQUENCY_CONFIGURE, eSCREEN_MAX);
651                                                                result = 1;
652                                                                break;
653                                                }
654                                                break;
655                                        case eIR_INFO:
656                                                if (scan_channels) {
657                                                        if (p_app->scan_in_progress) {
658                                                                bos_sleep(1000);
659                                                        }
660                                                        p_app->chm.force_tune = true;
661                                                        bapp_tune(p_app);
662                                                }
663                                                bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
664                                                bapp_audio_do_mute(p_app, false);
665                                                bapp_video_mute(p_app, false);
666                                                bapp_enable_cc(p_app, true);
667                                                result = 1;
668                                                break;
669                                        case eIR_0:
670                                        case eIR_1:
671                                        case eIR_2:
672                                        case eIR_3:
673                                        case eIR_4:
674                                        case eIR_5:
675                                        case eIR_6:
676                                        case eIR_7:
677                                        case eIR_8:
678                                        case eIR_9:
679                                                bscreen_sys_info_handler(p_app,p_screen,p_event->id);
680                                                break;
681                                }
682                        }
683                        break;
684
685                default:
686                        result = bscreen_default_event(v_app,v_screen,p_event);
687                        break;
688        }
689        return result; /* always handle event */
690}
691
692/*
693Summary:
694Diag menu screen drawing function
695 */
696
697void bscreen_diag_menu_draw(void *v_app, void *v_screen)
698{
699        bapp_t *p_app = (bapp_t*)v_app;
700        bscreen_t *p_screen = (bscreen_t*)v_screen;
701        unsigned int num_chars;
702        int yoff,row,i;
703
704        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
705        num_chars = strlen(s_menu_title);
706        num_chars = c_to_uni_str((unsigned char*)s_menu_title,p_app->tmp_str,num_chars);
707        yoff = eDIAG_START_Y;
708        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
709                        eDIAG_START_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
710
711        yoff += 6;
712        for (row = 0; row < eMM_IDX_NUM; ++row)
713        {
714                yoff += eDIAG_ROW_HEIGHT;
715
716                num_chars = strlen(s_main_menu[row]);
717                num_chars = c_to_uni_str((unsigned char*)s_main_menu[row],p_app->tmp_str,num_chars);
718                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
719                                eDIAG_MENU_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, (row == p_screen->local_state ? eCOLOR_LT_YELLOW : eCOLOR_WHITE) ,0);
720        }
721        num_chars = strlen(s_menu_help);
722        num_chars = c_to_uni_str((unsigned char*)s_menu_help,p_app->tmp_str,num_chars);
723
724        /* substitute [1234] to up,down,left or right if any */
725        for (i = 0; i < num_chars; ++i)
726        {
727                if (p_app->tmp_str[i] == 0x00000031)
728                {
729                        p_app->tmp_str[i] = 0x2593;/* up */
730                }
731                else if (p_app->tmp_str[i] == 0x00000032)
732                {
733                        p_app->tmp_str[i] = 0x2502;/* down */
734                }
735                else if (p_app->tmp_str[i] == 0x00000033)
736                {
737                        p_app->tmp_str[i] = 0x2591;/* left */
738                }
739                else if (p_app->tmp_str[i] == 0x00000034)
740                {
741                        p_app->tmp_str[i] = 0x2592;/* right */
742                }
743        }
744
745        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
746                        eDIAG_START_X, eDIAG_HELP_Y, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
747}
748
749static unsigned int s_user_defined_freq[MAX_USER_FREQ];
750static unsigned int s_user_defined_freq_num;
751static int tmp_cnt, freq_low;
752
753void add_user_defined_frequency(int freq_high, int freq_low, int cnt)
754{
755        int i;
756        int add_index=MAX_USER_FREQ, del_index=MAX_USER_FREQ;
757        unsigned int freq = 0, r=1;
758
759        freq = freq_high*1000;
760        if (cnt>0) {
761                for (i=0; i<(3-cnt); i++) r *= 10;
762                freq += freq_low*r;
763        }       
764
765        for (i=0; i<MAX_USER_FREQ; i++) {
766                if (add_index == MAX_USER_FREQ && s_user_defined_freq[i] == 0) {
767                        add_index = i;
768                }
769                if (del_index == MAX_USER_FREQ && s_user_defined_freq[i] == freq) {
770                        /* delete the entry */
771                        s_user_defined_freq_num--;
772                        s_user_defined_freq[i] = 0;
773                        return;
774                }
775        }
776        s_user_defined_freq_num++;
777        s_user_defined_freq[add_index] = freq;
778}
779
780int screen_frequency_event(void *v_app, void *v_screen, bscreen_event_t *p_event)
781{
782        bapp_t *p_app = (bapp_t *)v_app;
783        int result = 0, i, cnt;
784        static unsigned int freq_high=0;
785        unsigned int tmp_freq_table[MAX_USER_FREQ];
786
787        if (p_event->type == eS_EVENT_SETUP) 
788        {
789                p_app->tmp_value = 0;
790                tmp_cnt = -1;
791
792                freq_low = -1;
793                freq_high = 0;
794
795                bscreen_default_setup(v_app, v_screen);
796        } 
797        else if (p_event->type == eS_EVENT_IR) 
798        {
799                switch(p_event->id)
800                {
801                        case eIR_LEFT:
802                                /* delete */
803                                result = 1;
804                                if (freq_low == -1) {
805                                        if (p_app->tmp_value > 0 && p_app->tmp_value<10) {
806                                                freq_high = 1;
807                                        } else if (p_app->tmp_value == 0) {
808                                                freq_high = 0;
809                                        }
810                                        else {
811                                                freq_high--;
812                                        }
813                                        p_app->tmp_value /= 10;
814                                } else {
815                                        if (freq_low == 0) {
816                                                freq_low = -1;
817                                                tmp_cnt = -1;
818                                        } else {
819                                                tmp_cnt /= 10;
820                                                freq_low--;
821                                        }
822                                }
823                                break;
824                                /* RCA IR remote doesn't have Last button, so use ARROW UP button instead */
825                        //case eIR_PRECH:
826                        case eIR_UP:
827                                result = 1;
828                                for (i=0, cnt=0; i<MAX_USER_FREQ; i++) {
829                                        if (s_user_defined_freq[i] != 0) {
830                                                tmp_freq_table[cnt] = s_user_defined_freq[i];
831                                                cnt++;
832                                        }
833                                }
834                                memset(s_user_defined_freq, 0, sizeof(unsigned int)*MAX_USER_FREQ);
835                                for (i=0; i<s_user_defined_freq_num; i++) {
836                                        s_user_defined_freq[i] = tmp_freq_table[i];
837                                }
838
839                                p_app->settings.num_channels = 0;
840                                p_app->cur_ch_num = 0;
841                                p_app->settings_dirty = DIRTY_CHANNEL|DIRTY_CHANNEL_MAP|DIRTY_SCREEN;
842                                bapp_save_settings(p_app);
843
844                                scan_channels = true;
845                                p_app->chm.fe_type = eFREQ_TABLE_USER_DEFINED;
846                                bapp_channel_scan(p_app);
847                                /* !!! pass through */
848
849                        case eIR_MENU:
850                                result = 1;
851                                bapp_goto_last_screen(p_app);
852                                break;
853
854                        case eIR_SELECT:
855                                result = 1;     
856                                add_user_defined_frequency(p_app->tmp_value, tmp_cnt, freq_low);
857                                freq_low = -1;
858                                freq_high = 0;
859                                tmp_cnt = -1;
860                                p_app->tmp_value = 0;
861                                break;
862                        case eIR_0:
863                        case eIR_1:
864                        case eIR_2:
865                        case eIR_3:
866                        case eIR_4:
867                        case eIR_5:
868                        case eIR_6:
869                        case eIR_7:
870                        case eIR_8:
871                        case eIR_9:
872                                result = 1;
873                                if (freq_low == -1) {
874                                        if (freq_high>4) break;
875                                        p_app->tmp_value = p_app->tmp_value*10 + p_event->id;
876                                        if (p_app->tmp_value>0) freq_high++;
877                                }
878                                else {
879                                        if (freq_low>=3) break;
880                                        tmp_cnt = tmp_cnt*10 + p_event->id;
881                                        freq_low++;
882                                }
883                                break;
884                        case eIR_DOT:
885                        case eIR_RIGHT:
886                                result = 1;
887                                if (freq_low == -1) {
888                                        freq_low = 0;
889                                        tmp_cnt = 0;
890                                }
891                                break;
892                        default:
893                                result = bscreen_default_event(v_app, v_screen,p_event);
894                                break;
895                }
896        }
897        else 
898        {
899                result = bscreen_default_event(v_app, v_screen, p_event);
900        }
901
902        return result;
903}
904
905void bscreen_frequency_draw(void *v_app, void *v_screen)
906{
907        bapp_t *p_app = (bapp_t *)v_app;
908        bscreen_t *p_screen = (bscreen_t *)v_screen;
909        unsigned int num_chars;
910        unsigned char buf[20];
911        uint16_t x, y, width, height;
912        unsigned int i, remainder, r, cnt, row, column;
913
914        bgfx_fill_rect(&p_app->surf, 0, 0, eWIDTH, eHEIGHT, eCOLOR_BLACK_65);
915
916        /* draw title */
917        num_chars = SCREEN_MAX_STR_WIDTH;
918        num_chars = c_to_uni_str((unsigned char *)s_frequency, p_app->tmp_str, num_chars);
919        text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_LARGE],
920                        eMENU_TITLE_TEXT_X, eMENU_TITLE_TEXT_Y, eMENU_TITLE_TEXT_WIDTH, eMENU_TITLE_TEXT_HEIGHT,p_app->tmp_str,
921                        num_chars, eCOLOR_WHITE, eCOLOR_BLACK_65, eMENU_TEXT_DROPSHADOW, eMENU_TITLE_TEXT_HEIGHT);
922
923        /* draw description */
924        num_chars = SCREEN_MAX_STR_WIDTH;
925        num_chars = c_to_uni_str((unsigned char *)s_frequency_desc, p_app->tmp_str, num_chars);
926        bapp_str_get(p_app->lang,p_screen->desc_text_id, p_app->tmp_str, &num_chars);
927        text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
928                        eMENU_TITLE_DESC_TEXT_X, eMENU_TITLE_DESC_TEXT_Y,
929                        eMENU_TITLE_DESC_TEXT_WIDTH, eMENU_TITLE_DESC_TEXT_HEIGHT,  p_app->tmp_str,
930                        num_chars, eCOLOR_WHITE,eCOLOR_BLACK_65, eMENU_TEXT_DROPSHADOW ,eMENU_TITLE_DESC_TEXT_SPACING);
931
932        num_chars = strlen("Frequency");
933        num_chars = c_to_uni_str("Frequency", p_app->tmp_str, num_chars);
934        text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_MED],
935                        eMENU_FREQUENCY_X, eMENU_FREQUENCY_Y, eMENU_FREQUENCY_WIDTH, eMENU_FREQUENCY_HEIGHT, p_app->tmp_str,
936                        num_chars, eCOLOR_WHITE, eCOLOR_BLACK_65, eMENU_TEXT_DROPSHADOW, 0);
937
938        /* draw user's input */
939        num_chars = SCREEN_MAX_STR_WIDTH;
940        memset(buf, 0, 20);
941        if (freq_low>0) {
942                num_chars = snprintf(buf, 20, "%d.", p_app->tmp_value);
943                for (r=1,i=0; i<(freq_low-1); i++) r = r*10;
944
945                remainder = tmp_cnt;   
946                for (i=0;i<(freq_low-1); i++) {
947                        buf[num_chars] = '0'+remainder/r;
948                        num_chars++;
949                        remainder = remainder % r;
950                        r /= 10;
951                }
952                buf[num_chars] = '0'+remainder;
953                num_chars++;
954        } else if (freq_low == 0) {
955                snprintf(buf, 20, "%d.", p_app->tmp_value);
956        } else {
957                snprintf(buf, 20, "%d", p_app->tmp_value);
958        }
959        num_chars = strlen(buf);
960        num_chars = c_to_uni_str(buf, p_app->tmp_str, num_chars);
961
962        x = eMENU_FREQUENCY_X+eMENU_FREQUENCY_WIDTH/2;
963        y = eMENU_FREQUENCY_Y;
964        width = eMENU_FREQUENCY_WIDTH/2;
965        height = eMENU_FREQUENCY_HEIGHT;
966
967        bgfx_draw_text_box_ex(&p_app->surf, &x, &y, &width, &height,
968                        p_app->tmp_str, num_chars, p_app->p_font[p_app->lang][eFONT_SIZE_MED], eCOLOR_WHITE, eCOLOR_BLACK_65, eCOLOR_WHITE,
969                        0, 0, 0, 2, 1);
970
971        num_chars = strlen("MHz");
972        num_chars = c_to_uni_str("MHz", p_app->tmp_str, num_chars);
973        text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_MED],
974                        eMENU_FREQUENCY_X+eMENU_FREQUENCY_WIDTH, eMENU_FREQUENCY_Y + 2, 100, eMENU_FREQUENCY_HEIGHT, p_app->tmp_str,
975                        num_chars, eCOLOR_WHITE, eCOLOR_BLACK_65, eMENU_TEXT_DROPSHADOW, 0);
976
977        /* draw user-defined frequency table */
978        for (row=0,cnt=0,i=0; i<MAX_USER_FREQ; i++) {
979                if (s_user_defined_freq[i] != 0) {
980                        column = cnt%5;
981                        row = cnt/5;
982
983                        x = eMENU_FREQUENCY_X + column*eMENU_FREQ_COLUMN_WIDTH;
984                        y = eMENU_FREQ_ROW_START_Y + row*eMENU_FREQ_COLUMN_HEIGHT;
985                        width = eMENU_FREQ_COLUMN_WIDTH;
986                        height = eMENU_FREQ_COLUMN_HEIGHT;
987
988                        num_chars = snprintf(buf, SCREEN_MAX_STR_WIDTH, "%d.%03d", s_user_defined_freq[i]/1000, s_user_defined_freq[i]%1000);
989                        num_chars = strlen(buf);
990                        num_chars = c_to_uni_str(buf, p_app->tmp_str, num_chars);
991
992                        bgfx_draw_text_box_ex(&p_app->surf, &x, &y, &width, &height,
993                                        p_app->tmp_str, num_chars, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
994                                        eCOLOR_WHITE, eCOLOR_BLACK_65, eCOLOR_WHITE,
995                                        0, 0, 0, 2, 1);
996                        cnt++;
997                }       
998        }
999
1000        num_chars = strlen(s_frequency_help);
1001        num_chars = c_to_uni_str((unsigned char*)s_frequency_help,p_app->tmp_str,num_chars);
1002        for (i = 0; i < num_chars; ++i)
1003        {
1004                if (p_app->tmp_str[i] == 0x00000031)
1005                {
1006                        p_app->tmp_str[i] = 0x2593;/* up */
1007                }
1008                else if (p_app->tmp_str[i] == 0x00000032)
1009                {
1010                        p_app->tmp_str[i] = 0x2502;/* down */
1011                }
1012                else if (p_app->tmp_str[i] == 0x00000033)
1013                {
1014                        p_app->tmp_str[i] = 0x2591;/* left */
1015                }
1016                else if (p_app->tmp_str[i] == 0x00000034)
1017                {
1018                        p_app->tmp_str[i] = 0x2592;/* right */
1019                }
1020        }
1021        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1022                        eINFO_X, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1023}
1024
1025void bapp_user_freq_table_get(bapp_t *p_app, unsigned int *freq_table[], unsigned int *num_freq)
1026{
1027        *num_freq = s_user_defined_freq_num;
1028        *freq_table = s_user_defined_freq;
1029}
1030
Note: See TracBrowser for help on using the repository browser.