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

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

수동 스캔 후 빠져나오면 비디오 화면과 채널정보가 맞지 않는 문제로 수정
수동 스캔 메뉴에서 나올때 해당 RF의 첫번째 채널로 튜닝 시도하는 코두 추가
File size: 19.1 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
314// ¸Å´º¾ó ½ºÄµ ÈÄ ÇØ´ç RFÀÇ Ã¹¹ø° ä³Î·Î °£´Ù.
315void DST_DB_TuneFirstChannelinRF(int rf)
316{
317        int i;
318        if (DST_DB_PresentChMap() == false) return;
319        DBLock(true);
320        // RF ¹øÈ£ ÀÏÄ¡Çϴ ä³ÎÀ» ã´Â´Ù.
321        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
322        {
323                if (db_channel_db[i].program_number == 0) continue;
324                if (db_channel_db[i].rf != rf) continue;
325                DST_UI_ChannelTune(rf, db_channel_db[i].program_number);
326                DBLock(false);
327                return;
328        }
329        DST_UI_ChannelTune(rf, 0);
330        DBLock(false); 
331}
332
333
334int DST_DB_GetProgramNumber(int major, int minor)
335{
336        int i;
337        DBLock(true); 
338        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
339        {
340                if (db_channel_db[i].program_number == 0) continue;
341                if (db_channel_db[i].major != major) continue;
342                if (db_channel_db[i].minor != minor) continue;
343                int ret = db_channel_db[i].program_number;
344                DBLock(false); 
345                return ret;
346        }
347        if (minor != 0) 
348        {
349                DBLock(false); 
350                return 0;
351        }
352        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
353        {
354                if (db_channel_db[i].program_number == 0) continue;
355                if (db_channel_db[i].major != major) continue;
356                //if (db_channel_db[i].minor != minor) continue;
357                int ret = db_channel_db[i].program_number;
358                DBLock(false); 
359                return ret;
360        }
361        DBLock(false); 
362        return 0;
363}
364
365int DST_DB_GetProgramNumberbyRFNumber(int rf)
366{
367        int i;
368        int program_number = 0;
369        int min_minor = 10000;
370        DBLock(true); 
371        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
372        {
373                if (db_channel_db[i].program_number == 0) continue;
374                if (db_channel_db[i].rf != rf) continue;
375                if (db_channel_db[i].minor < min_minor)
376                {
377                        program_number = db_channel_db[i].program_number;
378                        min_minor = db_channel_db[i].minor;
379                }
380        }
381        DBLock(false); 
382        return program_number;
383}
384
385void DST_DB_Del()
386{
387        DBLock(true); 
388#if EPG_SUPPORT
389        int i;
390        for (i =0 ; i < DB_EIT_SUB_MAX; i++)
391        {
392                if (db_eit_sub[i].title) DST_OS_Free(&db_eit_sub[i].title);
393                memset(&db_eit_sub[i], 0, sizeof(_DB_EIT_SUB_));
394        }
395        for (i =0 ; i < DB_ETT_MAX; i++)
396        {
397                if (db_ett[i].title) DST_OS_Free(&db_ett[i].title);
398                memset(&db_ett[i], 0, sizeof(_DB_ETT_));
399        }
400        memset(&db_eit, 0, sizeof(_DB_EIT_)*DB_EIT_MAX);
401#endif
402        memset(&db_pat, 0, sizeof(_DB_PAT_)*DB_PAT_MAX);
403        memset(&db_pmt, 0, sizeof(_DB_PMT_)*DB_PMT_MAX);
404        memset(&db_tvct, 0, sizeof(_DB_TVCT_)*DB_TVCT_MAX);
405        memset(&db_tvct_sub, 0, sizeof(_DB_TVCT_SUB_)*DB_TVCT_SUB_MAX);
406#if CVCT_SUPPORT
407        memset(&db_cvct, 0, sizeof(_DB_CVCT_)*DB_CVCT_MAX);
408        memset(&db_cvct_sub, 0, sizeof(_DB_CVCT_SUB_)*DB_CVCT_SUB_MAX);
409#endif
410#if SUPPORT_CHANNEL_EDIT
411        memset(&db_skip_list, 0, sizeof(_DB_SKIP_LIST_)*DB_SKIP_LIST_MAX);
412#endif // SUPPORT_CHANNEL_EDIT
413        CT_ChMapUpdate();
414        DBLock(false); 
415}
416
417// FLASH ¸Þ¸ð¸® ÀúÀå
418
419DS_U32 DST_CRC32(DS_U8 *data, int len)
420{
421        static DS_U32 crcTable[256];
422        static bool bFirst=true;
423        if (bFirst)
424        {
425                bFirst = false;
426                int i;
427                for ( i=0; i<256; i++) {
428                        DS_U32 crc = 0;
429                        int j;
430                        for ( j=7; j>=0; j--) {
431                                if (((i >> j) ^ (crc >> 31)) & 1) crc=(crc<<1)^0x04C11DB7;
432                                else crc<<=1;
433                        }
434                        crcTable[i] = crc;
435                }
436        }
437        DS_U32 crc = 0xFFFFFFFF;
438        int i;
439        for ( i = 0; i < len; ++i) crc = (crc << 8) ^ crcTable[(crc >> 24) ^ (*data++)];
440        return crc;
441}
442
443// FLASH MEMORY LOW LEVEL ACCESS FUNCTION
444static DS_U8 *strFlash = 0;
445static DS_U32 g_nFlashDBSize = 0;
446static DS_U32 g_nFlashDBAddress[2] = {0, 0};
447
448static DS_U32 g_sync_request_time = 0;
449static DS_U32 g_Sync_finish_time = 0;
450
451void DST_DB_Sync()
452{
453        g_sync_request_time = DST_OS_GetTickCount();
454}
455
456bool DST_DB_IsSync()
457{
458        return (g_Sync_finish_time < g_sync_request_time) ? false : true;
459}
460
461static void tDB_Sync()
462{
463        while (1)
464        {
465                //T();
466                DST_OS_Delay(1000);
467                if (DST_g_KeyPressTime > DST_OS_GetTickCount()) DST_g_KeyPressTime = DST_OS_GetTickCount();
468                if (DST_OS_GetTickCount() - DST_g_KeyPressTime < DST_OS_GetTicksPerSecond()*5) continue;
469                if (DST_DB_IsSync()) continue;
470                //T();
471                DS_U32 *version = (DS_U32 *)&strFlash[0];
472                DS_U32 *crc = (DS_U32 *)&strFlash[4];
473                int nPos = 8;
474                memcpy(&strFlash[nPos], &db_config, sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
475                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
476                memcpy(&strFlash[nPos], &db_pat, sizeof(_DB_PAT_) * DB_PAT_MAX);
477                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
478                memcpy(&strFlash[nPos], &db_pmt, sizeof(_DB_PMT_) * DB_PMT_MAX);
479                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
480                memcpy(&strFlash[nPos], &db_tvct, sizeof(_DB_TVCT_) * DB_TVCT_MAX);
481                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
482                memcpy(&strFlash[nPos], &db_tvct_sub, sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
483                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
484#if SUPPORT_CHANNEL_EDIT
485                memcpy(&strFlash[nPos], &db_skip_list, sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
486                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
487#endif // SUPPORT_CHANNEL_EDIT
488                *version = FLASH_VERSION;
489                *crc =  DST_CRC32(&strFlash[8], g_nFlashDBSize-8);
490                int i;
491                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
492                DHL_Flash_Write(g_nFlashDBAddress[0], g_nFlashDBSize, strFlash);
493                DHL_Flash_Write(g_nFlashDBAddress[1], g_nFlashDBSize, strFlash);
494                g_Sync_finish_time = DST_OS_GetTickCount();
495        }
496}
497
498void DST_DB_Open()
499{
500        if (strFlash) DST_OS_Free(&strFlash);
501        g_nFlashDBSize = 8; //version, crc
502        g_nFlashDBSize += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
503        g_nFlashDBSize += sizeof(_DB_PAT_) * DB_PAT_MAX;
504        g_nFlashDBSize += sizeof(_DB_PMT_) * DB_PMT_MAX;
505        g_nFlashDBSize += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
506        g_nFlashDBSize += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
507#if SUPPORT_CHANNEL_EDIT
508        g_nFlashDBSize += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
509#endif
510
511//      DST_Printf("nFlashDBSize4K = %d nFlashDBSize = %d\n", nFlashDBSize4K, (int)g_nFlashDBSize);
512        DS_U32 nFlashDBSize4K = ((g_nFlashDBSize+4096-1)/4096)*4096;
513        g_nFlashDBAddress[0] = FLASH_CH_MAP_POS;
514        g_nFlashDBAddress[1] = g_nFlashDBAddress[0] + nFlashDBSize4K;
515       
516        strFlash = DHL_Flash_Read(g_nFlashDBAddress[0], g_nFlashDBSize);
517        int i;
518        for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
519        DS_U32 version = *(DS_U32 *)&strFlash[0];
520        DS_U32 crc = *(DS_U32 *)&strFlash[4];
521        bool bValidDB = true;
522        if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) //DB0 is broken
523        {
524                if (strFlash) DST_OS_Free(&strFlash);
525                strFlash = DHL_Flash_Read(g_nFlashDBAddress[1], g_nFlashDBSize);
526                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
527                DS_U32* buff32 = (DS_U32*)strFlash;
528                version = buff32[0];
529                crc = buff32[1];
530                if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) // DB1 is broken
531                {
532                        bValidDB = false;
533                        DST_Factory_Reset();
534                }       
535        }
536        if (bValidDB == true)
537        {
538                int nPos = 8;
539                memcpy(&db_config, &strFlash[nPos], sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
540                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
541                memcpy(&db_pat, &strFlash[nPos],  sizeof(_DB_PAT_) * DB_PAT_MAX);
542                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
543                memcpy(&db_pmt, &strFlash[nPos], sizeof(_DB_PMT_) * DB_PMT_MAX);
544                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
545                memcpy( &db_tvct, &strFlash[nPos], sizeof(_DB_TVCT_) * DB_TVCT_MAX);
546                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
547                memcpy(&db_tvct_sub, &strFlash[nPos], sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
548                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
549#if SUPPORT_CHANNEL_EDIT
550                memcpy(&db_skip_list, &strFlash[nPos], sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
551                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
552#endif         
553                int i;
554                for (i = 0; i < DB_CONFIG_MAX; i++)
555                {
556                        if (strlen(db_config[i].name) == 0) continue;
557                        DST_Printf("%s | %d\n", db_config[i].name, db_config[i].value);
558                }
559        }
560        DST_OS_SpawnTask( (void(*) (void *))tDB_Sync, (char*)"tDB_Sync", APP_TASK_PRIO_EEPROM_SYNC, WIN_MGR_TASK_STACKSIZE,  0);
561}
562
563int DST_DB_GetRF(int major, int *minor, bool* bFound)
564{
565        *bFound = true;
566        int i;
567        int min_rf = 10000;
568        int min_minor = 10000;
569        int nPos = -1;
570        DBLock(true); 
571        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
572        {
573                if (db_channel_db[i].program_number == 0) continue;
574                if (db_channel_db[i].major != major) continue;
575                if (db_channel_db[i].minor != *minor) continue;
576                if (db_channel_db[i].rf <  min_rf)
577                {
578                        min_rf = db_channel_db[i].rf;
579                        nPos = i;
580                }
581        }
582        if (nPos >=0) 
583        {
584                *minor = db_channel_db[nPos].minor;
585                int ret = db_channel_db[nPos].rf;
586                DBLock(false); 
587                return ret;
588        }
589
590        min_rf = 10000;
591        min_minor = 10000;
592        nPos = -1;
593
594        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
595        {
596                if (db_channel_db[i].program_number == 0) continue;
597                if (db_channel_db[i].major != major) continue;
598//              if (db_channel_db[i].minor != minor) continue;
599                if (db_channel_db[i].minor < min_minor)
600                {
601                        min_minor = db_channel_db[i].minor;
602                        nPos = i;
603                }
604        }
605        if (nPos >= 0)
606        {
607                nPos = -1;
608                for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
609                {
610                        if (db_channel_db[i].program_number == 0) continue;
611                        if (db_channel_db[i].major != major) continue;
612                        if (db_channel_db[i].minor != min_minor) continue;
613                        if (db_channel_db[i].rf <  min_rf)
614                        {
615                                min_rf = db_channel_db[i].rf;
616                                nPos = i;
617                        }
618                }       
619        }
620        if (nPos >=0) 
621        {
622                *minor = db_channel_db[nPos].minor;
623                int ret = db_channel_db[nPos].rf;
624                DBLock(false); 
625                return ret;
626        }
627        *bFound = false;
628        DBLock(false); 
629        return 0;
630}
631
632int DST_DB_AvailableChannelCount(int major)
633{
634        if (major == 0) return 0;
635        int i;
636        int nCount = 0;
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].major == major) || 
642                        (db_channel_db[i].major/10 == major) ||
643                        (db_channel_db[i].major/100 == major) ||
644                        (db_channel_db[i].major/1000 == major) ||
645                        (db_channel_db[i].major/10000 == major))
646                {
647                        nCount++;
648                }       
649        }
650        DBLock(false); 
651        return nCount;
652}
653
654bool DST_DB_PresentMatchChannel(int rf, int major, int minor)
655{
656        int i;
657        DBLock(true); 
658        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
659        {
660                if (db_channel_db[i].program_number == 0) continue;
661                if (db_channel_db[i].rf != rf) continue;
662                if (db_channel_db[i].major != major) continue;
663                if (minor != 0) if (db_channel_db[i].minor != minor) continue;
664                DBLock(false); 
665                return true;
666        }
667        DBLock(false); 
668        return false;
669}
670
671// ÁÖÆļö ¼³Á¤¿¡¼­ Á¦¿ÜµÈ ä³ÎÀÎÁö?
672// ÀԷ°ªÀº rfÀÇ index °ªÀÌ´Ù
673int DST_DB_IsExceptRF(int rf)
674{
675        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF()) return 0;
676        if (rf < DST_EEPROM_GetMinRF()) return 1;
677        if (rf > DST_EEPROM_GetMaxRF()) return 1;
678        return 0;
679}
680
681// ¸î°³ÀÇ Ã¤³ÎÀÌ Á¦¿ÜµÇ¾ú´ÂÁö?
682int DST_DB_GetExceptRFCount()
683{
684        return (DST_EEPROM_GetMinRF() - DST_MinRF()) + (DST_MaxRF() - DST_EEPROM_GetMaxRF());
685}
686
687static int GetNextRF(int rf)
688{
689        if (rf >= DST_MaxRF()) return 0;
690        return rf+1;
691}
692// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
693// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
694int DST_DB_GetNextUnexceptRF(int rf)
695{
696        int i=0;
697        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
698        {
699                return GetNextRF(rf);
700        }
701        int curRF = rf;
702        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
703        {
704                curRF = GetNextRF(curRF); 
705                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
706        }       
707        return 0;
708}
709
710static int GetPrevRF(int rf)
711{
712        if (rf <= DST_MinRF()) return DST_MaxRF();
713        return rf-1;
714}
715// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
716// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
717int DST_DB_GetPrevUnexceptRF(int rf)
718{
719        int i=0;
720        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
721        {
722                return GetPrevRF(rf);
723        }
724        int curRF = rf;
725        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
726        {
727                curRF = GetPrevRF(curRF); 
728                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
729        }       
730        return 0;
731}
732
733int DST_DB_GetUnexceptedFirstRF()
734{
735        int i=0;
736        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
737        {
738                if (DST_DB_IsExceptRF(i) == 0) return i;
739        }
740        return DST_MinRF();     
741}
742
743int DST_DB_GetUnexceptedLastRF()
744{
745        int i=0;
746        for (i = DST_MaxRF(); i >= DST_MinRF(); i--)
747        {
748                if (DST_DB_IsExceptRF(i) == 0) return i;
749        }
750        return DST_MaxRF();     
751}
Note: See TracBrowser for help on using the repository browser.