source: svn/trunk/zasc/app_c/DST_DB.c @ 30

Last change on this file since 30 was 30, checked in by phkim, 10 years ago
  1. phkim
  2. app_c
  3. 변경내용
    • 플래시 저장 간격을 0.5 -> 5초로 변경
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 SUPPORT_CHANNEL_EDIT
21void DST_DB_SetSkipChannel(int major, int minor, 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].major == 0) continue;
30                if (db_skip_list[i].minor != minor) continue;
31                if (db_skip_list[i].major != major) 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].major != 0) continue;
39                        db_skip_list[i].minor = minor;
40                        db_skip_list[i].major = major;
41                        break;
42                }
43        }
44        CT_ChMapUpdate(); // Skip ¸®½ºÆ®¿¡ µû¸¥ ä³Î ¾÷´Ù¿î ¸ñ·ÏÀ» °»½ÅÇÑ´Ù.
45//      DeleteCDB(&db);
46}
47#endif // SUPPORT_CHANNEL_EDIT
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 SUPPORT_CHANNEL_EDIT
391        memset(&db_skip_list, 0, sizeof(_DB_SKIP_LIST_)*DB_SKIP_LIST_MAX);
392#endif // SUPPORT_CHANNEL_EDIT
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()*5) 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                memcpy(&strFlash[nPos], &db_tvct, sizeof(_DB_TVCT_) * DB_TVCT_MAX);
461                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
462                memcpy(&strFlash[nPos], &db_tvct_sub, sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
463                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
464#if SUPPORT_CHANNEL_EDIT
465                memcpy(&strFlash[nPos], &db_skip_list, sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
466                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
467#endif // SUPPORT_CHANNEL_EDIT
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        g_nFlashDBSize += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
486        g_nFlashDBSize += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
487#if SUPPORT_CHANNEL_EDIT
488        g_nFlashDBSize += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
489#endif
490
491//      DST_Printf("nFlashDBSize4K = %d nFlashDBSize = %d\n", nFlashDBSize4K, (int)g_nFlashDBSize);
492        DS_U32 nFlashDBSize4K = ((g_nFlashDBSize+4096-1)/4096)*4096;
493        g_nFlashDBAddress[0] = FLASH_CH_MAP_POS;
494        g_nFlashDBAddress[1] = g_nFlashDBAddress[0] + nFlashDBSize4K;
495       
496        strFlash = DHL_Flash_Read(g_nFlashDBAddress[0], g_nFlashDBSize);
497        int i;
498        for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
499        DS_U32 version = *(DS_U32 *)&strFlash[0];
500        DS_U32 crc = *(DS_U32 *)&strFlash[4];
501        bool bValidDB = true;
502        if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) //DB0 is broken
503        {
504                if (strFlash) DST_OS_Free(&strFlash);
505                strFlash = DHL_Flash_Read(g_nFlashDBAddress[1], g_nFlashDBSize);
506                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
507                DS_U32* buff32 = (DS_U32*)strFlash;
508                version = buff32[0];
509                crc = buff32[1];
510                if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) // DB1 is broken
511                {
512                        bValidDB = false;
513                        DST_Factory_Reset();
514                }       
515        }
516        if (bValidDB == true)
517        {
518                int nPos = 8;
519                memcpy(&db_config, &strFlash[nPos], sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
520                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
521                memcpy(&db_pat, &strFlash[nPos],  sizeof(_DB_PAT_) * DB_PAT_MAX);
522                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
523                memcpy(&db_pmt, &strFlash[nPos], sizeof(_DB_PMT_) * DB_PMT_MAX);
524                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
525                memcpy( &db_tvct, &strFlash[nPos], sizeof(_DB_TVCT_) * DB_TVCT_MAX);
526                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
527                memcpy(&db_tvct_sub, &strFlash[nPos], sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
528                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
529#if SUPPORT_CHANNEL_EDIT
530                memcpy(&db_skip_list, &strFlash[nPos], sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
531                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
532#endif         
533                int i;
534                for (i = 0; i < DB_CONFIG_MAX; i++)
535                {
536                        if (strlen(db_config[i].name) == 0) continue;
537                        DST_Printf("%s | %d\n", db_config[i].name, db_config[i].value);
538                }
539        }
540        DST_OS_SpawnTask( (void(*) (void *))tDB_Sync, (char*)"tDB_Sync", APP_TASK_PRIO_EEPROM_SYNC, WIN_MGR_TASK_STACKSIZE,  0);
541}
542
543int DST_DB_GetRF(int major, int *minor, bool* bFound)
544{
545        *bFound = true;
546        int i;
547        int min_rf = 10000;
548        int min_minor = 10000;
549        int nPos = -1;
550        DBLock(true); 
551        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
552        {
553                if (db_channel_db[i].program_number == 0) continue;
554                if (db_channel_db[i].major != major) continue;
555                if (db_channel_db[i].minor != *minor) continue;
556                if (db_channel_db[i].rf <  min_rf)
557                {
558                        min_rf = db_channel_db[i].rf;
559                        nPos = i;
560                }
561        }
562        if (nPos >=0) 
563        {
564                *minor = db_channel_db[nPos].minor;
565                int ret = db_channel_db[nPos].rf;
566                DBLock(false); 
567                return ret;
568        }
569
570        min_rf = 10000;
571        min_minor = 10000;
572        nPos = -1;
573
574        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
575        {
576                if (db_channel_db[i].program_number == 0) continue;
577                if (db_channel_db[i].major != major) continue;
578//              if (db_channel_db[i].minor != minor) continue;
579                if (db_channel_db[i].minor < min_minor)
580                {
581                        min_minor = db_channel_db[i].minor;
582                        nPos = i;
583                }
584        }
585        if (nPos >= 0)
586        {
587                nPos = -1;
588                for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
589                {
590                        if (db_channel_db[i].program_number == 0) continue;
591                        if (db_channel_db[i].major != major) continue;
592                        if (db_channel_db[i].minor != min_minor) continue;
593                        if (db_channel_db[i].rf <  min_rf)
594                        {
595                                min_rf = db_channel_db[i].rf;
596                                nPos = i;
597                        }
598                }       
599        }
600        if (nPos >=0) 
601        {
602                *minor = db_channel_db[nPos].minor;
603                int ret = db_channel_db[nPos].rf;
604                DBLock(false); 
605                return ret;
606        }
607        *bFound = false;
608        DBLock(false); 
609        return 0;
610}
611
612int DST_DB_AvailableChannelCount(int major)
613{
614        if (major == 0) return 0;
615        int i;
616        int nCount = 0;
617        DBLock(true); 
618        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
619        {
620                if (db_channel_db[i].program_number == 0) continue;
621                if ((db_channel_db[i].major == major) || 
622                        (db_channel_db[i].major/10 == major) ||
623                        (db_channel_db[i].major/100 == major) ||
624                        (db_channel_db[i].major/1000 == major) ||
625                        (db_channel_db[i].major/10000 == major))
626                {
627                        nCount++;
628                }       
629        }
630        DBLock(false); 
631        return nCount;
632}
633
634bool DST_DB_PresentMatchChannel(int rf, int major, int minor)
635{
636        int i;
637        DBLock(true); 
638        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
639        {
640                if (db_channel_db[i].program_number == 0) continue;
641                if (db_channel_db[i].rf != rf) continue;
642                if (db_channel_db[i].major != major) continue;
643                if (minor != 0) if (db_channel_db[i].minor != minor) continue;
644                DBLock(false); 
645                return true;
646        }
647        DBLock(false); 
648        return false;
649}
650
651// ÁÖÆļö ¼³Á¤¿¡¼­ Á¦¿ÜµÈ ä³ÎÀÎÁö?
652// ÀԷ°ªÀº rfÀÇ index °ªÀÌ´Ù
653int DST_DB_IsExceptRF(int rf)
654{
655        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF()) return 0;
656        if (rf < DST_EEPROM_GetMinRF()) return 1;
657        if (rf > DST_EEPROM_GetMaxRF()) return 1;
658        return 0;
659}
660
661// ¸î°³ÀÇ Ã¤³ÎÀÌ Á¦¿ÜµÇ¾ú´ÂÁö?
662int DST_DB_GetExceptRFCount()
663{
664        return (DST_EEPROM_GetMinRF() - DST_MinRF()) + (DST_MaxRF() - DST_EEPROM_GetMaxRF());
665}
666
667static int GetNextRF(int rf)
668{
669        if (rf >= DST_MaxRF()) return 0;
670        return rf+1;
671}
672// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
673// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
674int DST_DB_GetNextUnexceptRF(int rf)
675{
676        int i=0;
677        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
678        {
679                return GetNextRF(rf);
680        }
681        int curRF = rf;
682        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
683        {
684                curRF = GetNextRF(curRF); 
685                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
686        }       
687        return 0;
688}
689
690static int GetPrevRF(int rf)
691{
692        if (rf <= DST_MinRF()) return DST_MaxRF();
693        return rf-1;
694}
695// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
696// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
697int DST_DB_GetPrevUnexceptRF(int rf)
698{
699        int i=0;
700        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
701        {
702                return GetPrevRF(rf);
703        }
704        int curRF = rf;
705        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
706        {
707                curRF = GetPrevRF(curRF); 
708                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
709        }       
710        return 0;
711}
712
713int DST_DB_GetUnexceptedFirstRF()
714{
715        int i=0;
716        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
717        {
718                if (DST_DB_IsExceptRF(i) == 0) return i;
719        }
720        return DST_MinRF();     
721}
722
723int DST_DB_GetUnexceptedLastRF()
724{
725        int i=0;
726        for (i = DST_MaxRF(); i >= DST_MinRF(); i--)
727        {
728                if (DST_DB_IsExceptRF(i) == 0) return i;
729        }
730        return DST_MaxRF();     
731}
Note: See TracBrowser for help on using the repository browser.