source: svn/zasc/app_c/DST_DB.c @ 76

Last change on this file since 76 was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
File size: 18.7 KB
Line 
1#include "DST_DB.h"
2//#include "sqlite3.h"
3#include "DST_CommonAPI.h"
4#include "DST_ChannelTune.h"
5#include "DST_HostInterface.h"
6#include "DST_DB_Engine.h"
7#include "DST_MemoryDB.h"
8
9//int CT_DB_GetTSID(DS_U8 RF);
10DS_U32* DST_UTF82Uni(DS_U8 *utf);
11void CT_DB_GetVideoPid(DS_U8 RF, DS_U16 sID,DS_U16* pcr, DS_U16* pid, DS_U8* type);
12void CT_ChMapUpdate();
13int CT_ChMapCount();
14//char* CDBStringAdd(char*strText, const char* strSQL, ...);
15//
16//#ifdef SQLITE_ZERO_MALLOC
17//static void sqlite3MemSetDefault(void);
18//#endif
19
20#if CHANNEL_EDIT_SUPPORT
21void DST_DB_SetSkipChannel(int rf, int program_number, bool bAdd)
22{
23//      CDB db; NewCDB(&db);
24//      db.Query(&db, "delete from skip_list where rf=%d and program_number=%d",rf, program_number);
25//      if(bAdd) db.Query(&db, "INSERT INTO skip_list  VALUES (%d, %d)",rf, program_number);
26        int i;
27        for (i=0; i < DB_SKIP_LIST_MAX; i++)
28        {
29                if (db_skip_list[i].program_number == 0) continue;
30                if (db_skip_list[i].rf != rf) continue;
31                if (db_skip_list[i].program_number != program_number) continue;
32                memset(&db_skip_list[i], 0, sizeof(_DB_SKIP_LIST_));
33        }
34        if(bAdd)
35        {
36                for (i=0; i < DB_SKIP_LIST_MAX; i++)
37                {
38                        if (db_skip_list[i].program_number != 0) continue;
39                        db_skip_list[i].rf = rf;
40                        db_skip_list[i].program_number = program_number;
41                        break;
42                }
43        }
44        CT_ChMapUpdate(); // Skip ¸®½ºÆ®¿¡ µû¸¥ ä³Î ¾÷´Ù¿î ¸ñ·ÏÀ» °»½ÅÇÑ´Ù.
45//      DeleteCDB(&db);
46}
47#endif // CHANNEL_EDIT_SUPPORT
48
49bool DST_DB_PresentChMap()
50{
51        return (CT_ChMapCount() > 0);
52}
53
54int DST_DB_GetMajor(DS_U8 RF, DS_U16 program_number)
55{
56//      CDB db; NewCDB(&db);
57//      db.GetTable(&db, "select major from channel_db where rf=%d and program_number=%d", RF, program_number);
58//      int result = (db.GetRow(&db) < 1) ? 0 : dst_atoi(db.GetResult(&db, 1));
59//      DeleteCDB(&db);
60//      return result;
61        int i;
62        DBLock(true);
63        for (i=0; i < DB_CHANNEL_DB_MAX; i++)
64        {
65                if (db_channel_db[i].program_number == 0) continue;
66                if (db_channel_db[i].rf != RF) continue;
67                if (db_channel_db[i].program_number != program_number) continue;
68                int ret = db_channel_db[i].major;
69                DBLock(false);
70                return ret;
71        }
72        DBLock(false);
73        return 0;
74}
75
76int DST_DB_GetMinor(DS_U8 RF, DS_U16 program_number)
77{
78//      CDB db; NewCDB(&db);
79//      db.GetTable(&db, "select minor from channel_db where rf=%d and program_number=%d", RF, program_number);
80//      int result = (db.GetRow(&db) < 1) ? 0 : dst_atoi(db.GetResult(&db, 1));
81//      DeleteCDB(&db);
82//      return result;
83        int i;
84        DBLock(true);
85        for (i=0; i < DB_CHANNEL_DB_MAX; i++)
86        {
87                if (db_channel_db[i].program_number == 0) continue;
88                if (db_channel_db[i].rf != RF) continue;
89                if (db_channel_db[i].program_number != program_number) continue;
90                int ret = db_channel_db[i].minor;
91                DBLock(false);
92                return ret;
93        }
94        DBLock(false);
95        return 0;
96}
97
98void DST_DB_ChannelUpDn(bool bUp)
99{
100        T();
101        int rf = DST_EEPROM_GetRF();
102        int program_number = DST_EEPROM_GetProgramNumber();
103        int nCount = 0;
104        int nPos = -1;
105        int i;
106        DBLock(true);
107        for (i =0; i < DB_CHANNEL_UPDN_MAX; i++)
108        {
109                if (db_channel_updn[i].program_number == 0) continue; 
110                nCount++;
111                if (db_channel_updn[i].rf != rf) continue;
112                if (db_channel_updn[i].program_number != program_number) continue;
113                nPos = i;
114        }
115        if (nCount == 0) 
116        {
117                DBLock(false);
118                return;
119        }
120        if (nCount == 1) 
121        {
122                DST_UI_ChannelTune(db_channel_updn[0].rf, db_channel_updn[0].program_number);
123                DBLock(false);
124                return;
125        }
126        if (nPos < 0) // ÇöÀçä³ÎÀÌ Ã¤³Î¸Ê¿¡ ¾ø´Â ä³ÎÀÎ °æ¿ì
127        {
128                if (bUp)
129                {
130                        DST_UI_ChannelTune(db_channel_updn[0].rf, db_channel_updn[0].program_number);
131                }
132                else
133                {
134                        DST_UI_ChannelTune(db_channel_updn[nCount-1].rf, db_channel_updn[nCount-1].program_number);
135                }
136                DBLock(false);
137                return; 
138        }
139        if (bUp)
140        {
141                nPos = (nPos >= nCount-1) ? 0 : nPos+1;
142        }
143        else
144        {
145                nPos = (nPos == 0) ? nCount-1 : nPos-1;
146        }
147        rf = db_channel_updn[nPos].rf;
148        program_number = db_channel_updn[nPos].program_number;
149        DBLock(false);
150        DST_UI_ChannelTune(rf, program_number);
151}
152
153ChannelMap* DST_DB_GetChannelMapForChEdit(int *nChannels)
154{
155        DBLock(true);
156        *nChannels = CT_ChMapCount();
157        if (*nChannels == 0) 
158        {
159                DBLock(false);
160                return 0;
161        }
162        ChannelMap* chMap = (ChannelMap *)DST_OS_Calloc(sizeof(ChannelMap), *nChannels);
163        int i;
164        int nPos = 0;
165        for (i=0; i < DB_CHANNEL_DB_MAX; i++)
166        {
167                if (db_channel_db[i].program_number == 0) continue;
168                chMap[nPos].rf = db_channel_db[i].rf;
169                chMap[nPos].major = db_channel_db[i].major;
170                chMap[nPos].minor = db_channel_db[i].minor;
171                strcpy((char*)chMap[nPos].name, db_channel_db[i].name);
172                chMap[nPos].number = db_channel_db[i].program_number;
173                sprintf(chMap[nPos].num, "%d-%d", chMap[nPos].major, chMap[nPos].minor);
174                if (chMap[nPos].minor == 0) sprintf(chMap[nPos].num, "%d", chMap[nPos].major);
175                nPos++;
176                if (nPos >= *nChannels) break;
177        }
178        if (*nChannels > 1)
179        {
180                // major, minor, rf ¼ø¼­·Î Á¤·Ä
181                for (i=0; i < *nChannels-1; i++)
182                {
183                        int j;
184                        for (j = i+1; j < *nChannels; j++)
185                        {
186                                if (chMap[i].major < chMap[j].major) continue;
187                                if (chMap[i].minor < chMap[j].minor) continue;
188                                if (chMap[i].rf < chMap[j].rf) continue;
189                                ChannelMap tmp = chMap[i];
190                                chMap[i] = chMap[j];
191                                chMap[j] = tmp;
192                        }
193                }
194        }
195        DBLock(false);
196        return chMap;
197}
198
199int DST_DB_GetChannelCount()
200{
201        return CT_ChMapCount();
202}
203
204bool DST_DB_GetCurrentChannelInfo(char* chNum, DS_U32* chName, int *num)
205{
206        if (chNum) chNum[0] = 0;
207        if (chName) chName[0] = 0;
208
209#if 0           
210        DS_U8 RF= DST_EEPROM_GetRF();
211        DS_U16 program_number = DST_EEPROM_GetProgramNumber();
212#else
213        DS_U8  RF= 0;
214        DS_U16 program_number = 0;
215        DST_GetAVState(&RF, &program_number, 0);
216#endif
217       
218        if (program_number == 0)
219        {
220                if (num) *num = DST_GetFrequencyNumberbyIndex(RF);
221                if (chNum) sprintf(chNum,"%d", DST_GetFrequencyNumberbyIndex(RF));
222                return false;
223        }
224//      CDB db; NewCDB(&db);
225//      db.GetTable(&db, "select major, minor, name from channel_db where rf =%d and program_number=%d", RF, program_number);
226        int major = 0;
227        int minor = 0;
228        int i;
229        int nPos = -1;
230        DBLock(true);
231        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
232        {
233                if (db_channel_db[i].program_number == 0) continue;
234                if (db_channel_db[i].rf != RF) continue;
235                if (db_channel_db[i].program_number != program_number) continue;
236                major = db_channel_db[i].major;
237                minor = db_channel_db[i].minor;
238                nPos = i;
239                break;
240        }
241       
242        if (nPos < 0)
243        {
244                if (num) *num = DST_GetFrequencyNumberbyIndex(RF);
245                if (chNum) sprintf(chNum,"%d", DST_GetFrequencyNumberbyIndex(RF));
246//              DeleteCDB(&db);
247                DBLock(false);
248                return false;
249        }
250       
251//      int major = dst_atoi(db.GetResult(&db, 3));
252//      int minor = dst_atoi(db.GetResult(&db, 4));
253        if (chName)
254        {
255                DS_U32 *strText32 = DST_UTF82Uni((DS_U8*)db_channel_db[nPos].name);
256                if (strText32) strcpy32(chName, strText32);
257        }
258        if (minor == 0)
259        {
260                sprintf(chNum,"%d (%d) ", major, DST_GetFrequencyNumberbyIndex(RF));
261        }
262        else
263        {
264                sprintf(chNum,"%d-%d(%d) ", major, minor, DST_GetFrequencyNumberbyIndex(RF));
265        }
266//      DeleteCDB(&db);
267        DBLock(false);
268        return true;
269}
270
271// ºÎÆà ÈÄ È¤Àº ¿ÀÅä ½ºÄµ ÈÄ È£Ã⠵ȴÙ.
272void DST_DB_TuneFirstChannel()
273{
274        DBLock(true);
275        if (DST_DB_PresentChMap() == false)
276        {
277                DST_UI_ChannelTune(DST_DB_GetUnexceptedFirstRF(), 0);
278                DBLock(false);
279                return;
280        }
281        // RF ¹øÈ£¿Í ÇÁ·Î±×·¥³Ñ¹ö ÀÏÄ¡Çϴ ä³ÎÀ» ã´Â´Ù.
282        int rf = DST_EEPROM_GetRF();
283        int program_number = DST_EEPROM_GetProgramNumber();
284        int i;
285        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
286        {
287                if (db_channel_db[i].program_number == 0) continue;
288                if (db_channel_db[i].rf != rf) continue;
289                if (db_channel_db[i].program_number != program_number) continue;
290                DST_UI_ChannelTune(rf, program_number);
291                DBLock(false);
292                return;
293        }
294        // RF ¹øÈ£ ÀÏÄ¡Çϴ ä³ÎÀ» ã´Â´Ù.
295        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
296        {
297                if (db_channel_db[i].program_number == 0) continue;
298                if (db_channel_db[i].rf != rf) continue;
299                DST_UI_ChannelTune(rf, db_channel_db[i].program_number);
300                DBLock(false);
301                return;
302        }
303        // ù¹ø° ä³Î
304        if (db_channel_updn[0].program_number)
305        {
306                DST_UI_ChannelTune(db_channel_updn[0].rf, db_channel_updn[0].program_number);
307                DBLock(false);
308                return;
309        }
310        DST_UI_ChannelTune(DST_MinRF(), 0);
311        DBLock(false); 
312}
313
314int DST_DB_GetProgramNumber(int major, int minor)
315{
316        int i;
317        DBLock(true); 
318        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
319        {
320                if (db_channel_db[i].program_number == 0) continue;
321                if (db_channel_db[i].major != major) continue;
322                if (db_channel_db[i].minor != minor) continue;
323                int ret = db_channel_db[i].program_number;
324                DBLock(false); 
325                return ret;
326        }
327        if (minor != 0) 
328        {
329                DBLock(false); 
330                return 0;
331        }
332        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
333        {
334                if (db_channel_db[i].program_number == 0) continue;
335                if (db_channel_db[i].major != major) continue;
336                //if (db_channel_db[i].minor != minor) continue;
337                int ret = db_channel_db[i].program_number;
338                DBLock(false); 
339                return ret;
340        }
341        DBLock(false); 
342        return 0;
343}
344
345int DST_DB_GetProgramNumberbyRFNumber(int rf)
346{
347        int i;
348        int program_number = 0;
349        int min_minor = 10000;
350        DBLock(true); 
351        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
352        {
353                if (db_channel_db[i].program_number == 0) continue;
354                if (db_channel_db[i].rf != rf) continue;
355                if (db_channel_db[i].minor < min_minor)
356                {
357                        program_number = db_channel_db[i].program_number;
358                        min_minor = db_channel_db[i].minor;
359                }
360        }
361        DBLock(false); 
362        return program_number;
363}
364
365void DST_DB_Del()
366{
367        DBLock(true); 
368#if EPG_SUPPORT
369        int i;
370        for (i =0 ; i < DB_EIT_SUB_MAX; i++)
371        {
372                if (db_eit_sub[i].title) DST_OS_Free(&db_eit_sub[i].title);
373                memset(&db_eit_sub[i], 0, sizeof(_DB_EIT_SUB_));
374        }
375        for (i =0 ; i < DB_ETT_MAX; i++)
376        {
377                if (db_ett[i].title) DST_OS_Free(&db_ett[i].title);
378                memset(&db_ett[i], 0, sizeof(_DB_ETT_));
379        }
380        memset(&db_eit, 0, sizeof(_DB_EIT_)*DB_EIT_MAX);
381#endif
382        memset(&db_pat, 0, sizeof(_DB_PAT_)*DB_PAT_MAX);
383        memset(&db_pmt, 0, sizeof(_DB_PMT_)*DB_PMT_MAX);
384        memset(&db_tvct, 0, sizeof(_DB_TVCT_)*DB_TVCT_MAX);
385        memset(&db_tvct_sub, 0, sizeof(_DB_TVCT_SUB_)*DB_TVCT_SUB_MAX);
386#if CVCT_SUPPORT
387        memset(&db_cvct, 0, sizeof(_DB_CVCT_)*DB_CVCT_MAX);
388        memset(&db_cvct_sub, 0, sizeof(_DB_CVCT_SUB_)*DB_CVCT_SUB_MAX);
389#endif
390#if CHANNEL_EDIT_SUPPORT
391        memset(&db_skip_list, 0, sizeof(_DB_SKIP_LIST_)*DB_SKIP_LIST_MAX);
392#endif // CHANNEL_EDIT_SUPPORT
393        CT_ChMapUpdate();
394        DBLock(false); 
395}
396
397// FLASH ¸Þ¸ð¸® ÀúÀå
398
399DS_U32 DST_CRC32(DS_U8 *data, int len)
400{
401        static DS_U32 crcTable[256];
402        static bool bFirst=true;
403        if (bFirst)
404        {
405                bFirst = false;
406                int i;
407                for ( i=0; i<256; i++) {
408                        DS_U32 crc = 0;
409                        int j;
410                        for ( j=7; j>=0; j--) {
411                                if (((i >> j) ^ (crc >> 31)) & 1) crc=(crc<<1)^0x04C11DB7;
412                                else crc<<=1;
413                        }
414                        crcTable[i] = crc;
415                }
416        }
417        DS_U32 crc = 0xFFFFFFFF;
418        int i;
419        for ( i = 0; i < len; ++i) crc = (crc << 8) ^ crcTable[(crc >> 24) ^ (*data++)];
420        return crc;
421}
422
423// FLASH MEMORY LOW LEVEL ACCESS FUNCTION
424static DS_U8 *strFlash = 0;
425static DS_U32 g_nFlashDBSize = 0;
426static DS_U32 g_nFlashDBAddress[2] = {0, 0};
427
428static DS_U32 g_sync_request_time = 0;
429static DS_U32 g_Sync_finish_time = 0;
430
431void DST_DB_Sync()
432{
433        g_sync_request_time = DST_OS_GetTickCount();
434}
435
436bool DST_DB_IsSync()
437{
438        return (g_Sync_finish_time < g_sync_request_time) ? false : true;
439}
440
441static void tDB_Sync()
442{
443        while (1)
444        {
445                //T();
446                DST_OS_Delay(1000);
447                if (DST_g_KeyPressTime > DST_OS_GetTickCount()) DST_g_KeyPressTime = DST_OS_GetTickCount();
448                if (DST_OS_GetTickCount() - DST_g_KeyPressTime < DST_OS_GetTicksPerSecond()/2) continue;
449                if (DST_DB_IsSync()) continue;
450                //T();
451                DS_U32 *version = (DS_U32 *)&strFlash[0];
452                DS_U32 *crc = (DS_U32 *)&strFlash[4];
453                int nPos = 8;
454                memcpy(&strFlash[nPos], &db_config, sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
455                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
456                memcpy(&strFlash[nPos], &db_pat, sizeof(_DB_PAT_) * DB_PAT_MAX);
457                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
458                memcpy(&strFlash[nPos], &db_pmt, sizeof(_DB_PMT_) * DB_PMT_MAX);
459                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
460#if CHANNEL_EDIT_SUPPORT
461                memcpy(&strFlash[nPos], &db_skip_list, sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
462                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
463#endif // CHANNEL_EDIT_SUPPORT
464                memcpy(&strFlash[nPos], &db_tvct, sizeof(_DB_TVCT_) * DB_TVCT_MAX);
465                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
466                memcpy(&strFlash[nPos], &db_tvct_sub, sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
467                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
468                *version = FLASH_VERSION;
469                *crc =  DST_CRC32(&strFlash[8], g_nFlashDBSize-8);
470                int i;
471                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
472                DHL_Flash_Write(g_nFlashDBAddress[0], g_nFlashDBSize, strFlash);
473                DHL_Flash_Write(g_nFlashDBAddress[1], g_nFlashDBSize, strFlash);
474                g_Sync_finish_time = DST_OS_GetTickCount();
475        }
476}
477
478void DST_DB_Open()
479{
480        if (strFlash) DST_OS_Free(&strFlash);
481        g_nFlashDBSize = 8; //version, crc
482        g_nFlashDBSize += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
483        g_nFlashDBSize += sizeof(_DB_PAT_) * DB_PAT_MAX;
484        g_nFlashDBSize += sizeof(_DB_PMT_) * DB_PMT_MAX;
485#if CHANNEL_EDIT_SUPPORT
486        g_nFlashDBSize += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
487#endif
488        g_nFlashDBSize += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
489        g_nFlashDBSize += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
490//      DST_Printf("nFlashDBSize4K = %d nFlashDBSize = %d\n", nFlashDBSize4K, (int)g_nFlashDBSize);
491        DS_U32 nFlashDBSize4K = ((g_nFlashDBSize+4096-1)/4096)*4096;
492        g_nFlashDBAddress[0] = FLASH_CH_MAP_POS;
493        g_nFlashDBAddress[1] = g_nFlashDBAddress[0] + nFlashDBSize4K;
494       
495        strFlash = DHL_Flash_Read(g_nFlashDBAddress[0], g_nFlashDBSize);
496        int i;
497        for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
498        DS_U32 version = *(DS_U32 *)&strFlash[0];
499        DS_U32 crc = *(DS_U32 *)&strFlash[4];
500        bool bValidDB = true;
501        if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) //DB0 is broken
502        {
503                if (strFlash) DST_OS_Free(&strFlash);
504                strFlash = DHL_Flash_Read(g_nFlashDBAddress[1], g_nFlashDBSize);
505                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
506                DS_U32* buff32 = (DS_U32*)strFlash;
507                version = buff32[0];
508                crc = buff32[1];
509                if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) // DB1 is broken
510                {
511                        bValidDB = false;
512                        DST_Factory_Reset();
513                }       
514        }
515        if (bValidDB == true)
516        {
517                int nPos = 8;
518                memcpy(&db_config, &strFlash[nPos], sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
519                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
520                memcpy(&db_pat, &strFlash[nPos],  sizeof(_DB_PAT_) * DB_PAT_MAX);
521                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
522                memcpy(&db_pmt, &strFlash[nPos], sizeof(_DB_PMT_) * DB_PMT_MAX);
523                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
524#if CHANNEL_EDIT_SUPPORT
525                memcpy(&db_skip_list, &strFlash[nPos], sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
526                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
527#endif
528                memcpy( &db_tvct, &strFlash[nPos], sizeof(_DB_TVCT_) * DB_TVCT_MAX);
529                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
530                memcpy(&db_tvct_sub, &strFlash[nPos], sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
531                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
532                int i;
533                for (i = 0; i < DB_CONFIG_MAX; i++)
534                {
535                        if (strlen(db_config[i].name) == 0) continue;
536                        DST_Printf("%s | %d\n", db_config[i].name, db_config[i].value);
537                }
538        }
539        DST_OS_SpawnTask( (void(*) (void *))tDB_Sync, (char*)"tDB_Sync", APP_TASK_PRIO_EEPROM_SYNC, WIN_MGR_TASK_STACKSIZE,  0);
540}
541
542int DST_DB_GetRF(int major, int *minor, bool* bFound)
543{
544        *bFound = true;
545        int i;
546        int min_rf = 10000;
547        int min_minor = 10000;
548        int nPos = -1;
549        DBLock(true); 
550        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
551        {
552                if (db_channel_db[i].program_number == 0) continue;
553                if (db_channel_db[i].major != major) continue;
554                if (db_channel_db[i].minor != *minor) continue;
555                if (db_channel_db[i].rf <  min_rf)
556                {
557                        min_rf = db_channel_db[i].rf;
558                        nPos = i;
559                }
560        }
561        if (nPos >=0) 
562        {
563                *minor = db_channel_db[nPos].minor;
564                int ret = db_channel_db[nPos].rf;
565                DBLock(false); 
566                return ret;
567        }
568
569        min_rf = 10000;
570        min_minor = 10000;
571        nPos = -1;
572
573        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
574        {
575                if (db_channel_db[i].program_number == 0) continue;
576                if (db_channel_db[i].major != major) continue;
577//              if (db_channel_db[i].minor != minor) continue;
578                if (db_channel_db[i].minor < min_minor)
579                {
580                        min_minor = db_channel_db[i].minor;
581                        nPos = i;
582                }
583        }
584        if (nPos >= 0)
585        {
586                nPos = -1;
587                for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
588                {
589                        if (db_channel_db[i].program_number == 0) continue;
590                        if (db_channel_db[i].major != major) continue;
591                        if (db_channel_db[i].minor != min_minor) continue;
592                        if (db_channel_db[i].rf <  min_rf)
593                        {
594                                min_rf = db_channel_db[i].rf;
595                                nPos = i;
596                        }
597                }       
598        }
599        if (nPos >=0) 
600        {
601                *minor = db_channel_db[nPos].minor;
602                int ret = db_channel_db[nPos].rf;
603                DBLock(false); 
604                return ret;
605        }
606        *bFound = false;
607        DBLock(false); 
608        return 0;
609}
610
611int DST_DB_AvailableChannelCount(int major)
612{
613        if (major == 0) return 0;
614        int i;
615        int nCount = 0;
616        DBLock(true); 
617        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
618        {
619                if (db_channel_db[i].program_number == 0) continue;
620                if ((db_channel_db[i].major == major) || 
621                        (db_channel_db[i].major/10 == major) ||
622                        (db_channel_db[i].major/100 == major) ||
623                        (db_channel_db[i].major/1000 == major) ||
624                        (db_channel_db[i].major/10000 == major))
625                {
626                        nCount++;
627                }       
628        }
629        DBLock(false); 
630        return nCount;
631}
632
633bool DST_DB_PresentMatchChannel(int rf, int major, int minor)
634{
635        int i;
636        DBLock(true); 
637        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
638        {
639                if (db_channel_db[i].program_number == 0) continue;
640                if (db_channel_db[i].rf != rf) continue;
641                if (db_channel_db[i].major != major) continue;
642                if (minor != 0) if (db_channel_db[i].minor != minor) continue;
643                DBLock(false); 
644                return true;
645        }
646        DBLock(false); 
647        return false;
648}
649
650// ÁÖÆļö ¼³Á¤¿¡¼­ Á¦¿ÜµÈ ä³ÎÀÎÁö?
651// ÀԷ°ªÀº rfÀÇ index °ªÀÌ´Ù
652int DST_DB_IsExceptRF(int rf)
653{
654        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF()) return 0;
655        if (rf < DST_EEPROM_GetMinRF()) return 1;
656        if (rf > DST_EEPROM_GetMaxRF()) return 1;
657        return 0;
658}
659
660// ¸î°³ÀÇ Ã¤³ÎÀÌ Á¦¿ÜµÇ¾ú´ÂÁö?
661int DST_DB_GetExceptRFCount()
662{
663        return (DST_EEPROM_GetMinRF() - DST_MinRF()) + (DST_MaxRF() - DST_EEPROM_GetMaxRF());
664}
665
666static int GetNextRF(int rf)
667{
668        if (rf >= DST_MaxRF()) return 0;
669        return rf+1;
670}
671// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
672// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
673int DST_DB_GetNextUnexceptRF(int rf)
674{
675        int i=0;
676        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
677        {
678                return GetNextRF(rf);
679        }
680        int curRF = rf;
681        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
682        {
683                curRF = GetNextRF(curRF); 
684                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
685        }       
686        return 0;
687}
688
689static int GetPrevRF(int rf)
690{
691        if (rf <= DST_MinRF()) return DST_MaxRF();
692        return rf-1;
693}
694// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
695// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
696int DST_DB_GetPrevUnexceptRF(int rf)
697{
698        int i=0;
699        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
700        {
701                return GetPrevRF(rf);
702        }
703        int curRF = rf;
704        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
705        {
706                curRF = GetPrevRF(curRF); 
707                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
708        }       
709        return 0;
710}
711
712int DST_DB_GetUnexceptedFirstRF()
713{
714        int i=0;
715        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
716        {
717                if (DST_DB_IsExceptRF(i) == 0) return i;
718        }
719        return DST_MinRF();     
720}
721
722int DST_DB_GetUnexceptedLastRF()
723{
724        int i=0;
725        for (i = DST_MaxRF(); i >= DST_MinRF(); i--)
726        {
727                if (DST_DB_IsExceptRF(i) == 0) return i;
728        }
729        return DST_MaxRF();     
730}
Note: See TracBrowser for help on using the repository browser.