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

Last change on this file was 46, checked in by phkim, 10 years ago
  1. phkim
  2. 서경방송 [릴리즈 1.1.1]
  3. 초기화등 빠른 동기화를 위한 함수 추가및 수정
File size: 20.3 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                int tempMajor,tempMinor;
129                tempMajor = DST_DB_GetMajor(rf,program_number);
130                tempMinor = DST_DB_GetMinor(rf,program_number);
131                if (bUp)
132                {
133                        nPos = 0;
134                        for (i =0; i < DB_CHANNEL_UPDN_MAX; i++)
135                        {
136                                if (db_channel_updn[i].program_number == 0) continue;
137                               
138                                if (db_channel_updn[i].major > tempMajor) 
139                                {
140                                        nPos = i;
141                                        break;
142                                }
143                                else if (db_channel_updn[i].major == tempMajor)
144                                {
145                                        if (db_channel_updn[i].rf > rf) 
146                                        {
147                                                nPos = i;
148                                                break;
149                                        }
150                                        else if (db_channel_updn[i].rf == rf) 
151                                        {
152                                                if (db_channel_updn[i].minor > tempMinor) 
153                                                {
154                                                        nPos = i;
155                                                        break;
156                                                }
157                                        }
158                                } 
159                        }
160                }
161                else
162                {
163                        nPos = nCount-1;
164                        for (i =0; i < DB_CHANNEL_UPDN_MAX; i++)
165                        {
166                                if (db_channel_updn[i].program_number == 0) continue;
167
168                                if (db_channel_updn[i].major > tempMajor) 
169                                {
170                                        nPos = i;
171                                        break;
172                                }
173                                else if (db_channel_updn[i].major == tempMajor)
174                                {
175                                        if (db_channel_updn[i].rf > rf) 
176                                        {
177                                                nPos = i;
178                                                break;
179                                        }
180                                        else if (db_channel_updn[i].rf == rf) 
181                                        {
182                                                if (db_channel_updn[i].minor > tempMinor) 
183                                                {
184                                                        nPos = i;
185                                                        break;
186                                                }
187                                        }
188                                } 
189                        }
190                }
191                DST_UI_ChannelTune(db_channel_updn[nPos].rf, db_channel_updn[nPos].program_number);
192                DBLock(false);
193                return; 
194        }
195        if (bUp)
196        {
197                nPos = (nPos >= nCount-1) ? 0 : nPos+1;
198        }
199        else
200        {
201                nPos = (nPos == 0) ? nCount-1 : nPos-1;
202        }
203        rf = db_channel_updn[nPos].rf;
204        program_number = db_channel_updn[nPos].program_number;
205        DBLock(false);
206        DST_UI_ChannelTune(rf, program_number);
207}
208
209ChannelMap* DST_DB_GetChannelMapForChEdit(int *nChannels)
210{
211        DBLock(true);
212        *nChannels = CT_ChMapCount();
213        if (*nChannels == 0) 
214        {
215                DBLock(false);
216                return 0;
217        }
218        ChannelMap* chMap = (ChannelMap *)DST_OS_Calloc(sizeof(ChannelMap), *nChannels);
219        int i;
220        int nPos = 0;
221        for (i=0; i < DB_CHANNEL_DB_MAX; i++)
222        {
223                if (db_channel_db[i].program_number == 0) continue;
224                chMap[nPos].rf = db_channel_db[i].rf;
225                chMap[nPos].major = db_channel_db[i].major;
226                chMap[nPos].minor = db_channel_db[i].minor;
227                strcpy((char*)chMap[nPos].name, db_channel_db[i].name);
228                chMap[nPos].number = db_channel_db[i].program_number;
229                sprintf(chMap[nPos].num, "%d-%d", chMap[nPos].major, chMap[nPos].minor);
230                if (chMap[nPos].minor == 0) sprintf(chMap[nPos].num, "%d", chMap[nPos].major);
231                nPos++;
232                if (nPos >= *nChannels) break;
233        }
234        if (*nChannels > 1)
235        {
236                // major, minor, rf ¼ø¼­·Î Á¤·Ä
237                for (i=0; i < *nChannels-1; i++)
238                {
239                        int j;
240                        for (j = i+1; j < *nChannels; j++)
241                        {
242                                if (chMap[i].major < chMap[j].major) continue;
243                                if (chMap[i].minor < chMap[j].minor) continue;
244                                if (chMap[i].rf < chMap[j].rf) continue;
245                                ChannelMap tmp = chMap[i];
246                                chMap[i] = chMap[j];
247                                chMap[j] = tmp;
248                        }
249                }
250        }
251        DBLock(false);
252        return chMap;
253}
254
255int DST_DB_GetChannelCount()
256{
257        return CT_ChMapCount();
258}
259
260bool DST_DB_GetCurrentChannelInfo(char* chNum, DS_U32* chName, int *num)
261{
262        if (chNum) chNum[0] = 0;
263        if (chName) chName[0] = 0;
264
265#if 0           
266        DS_U8 RF= DST_EEPROM_GetRF();
267        DS_U16 program_number = DST_EEPROM_GetProgramNumber();
268#else
269        DS_U8  RF= 0;
270        DS_U16 program_number = 0;
271        DST_GetAVState(&RF, &program_number, 0);
272#endif
273       
274        if (program_number == 0)
275        {
276                if (num) *num = DST_GetFrequencyNumberbyIndex(RF);
277                if (chNum) sprintf(chNum,"%d", DST_GetFrequencyNumberbyIndex(RF));
278                return false;
279        }
280//      CDB db; NewCDB(&db);
281//      db.GetTable(&db, "select major, minor, name from channel_db where rf =%d and program_number=%d", RF, program_number);
282        int major = 0;
283        int minor = 0;
284        int i;
285        int nPos = -1;
286        DBLock(true);
287        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
288        {
289                if (db_channel_db[i].program_number == 0) continue;
290                if (db_channel_db[i].rf != RF) continue;
291                if (db_channel_db[i].program_number != program_number) continue;
292                major = db_channel_db[i].major;
293                minor = db_channel_db[i].minor;
294                nPos = i;
295                break;
296        }
297       
298        if (nPos < 0)
299        {
300                if (num) *num = DST_GetFrequencyNumberbyIndex(RF);
301                if (chNum) sprintf(chNum,"%d", DST_GetFrequencyNumberbyIndex(RF));
302//              DeleteCDB(&db);
303                DBLock(false);
304                return false;
305        }
306       
307//      int major = dst_atoi(db.GetResult(&db, 3));
308//      int minor = dst_atoi(db.GetResult(&db, 4));
309        if (chName)
310        {
311                DS_U32 *strText32 = DST_UTF82Uni((DS_U8*)db_channel_db[nPos].name);
312                if (strText32) strcpy32(chName, strText32);
313        }
314        if (minor == 0)
315        {
316                sprintf(chNum,"%d (%d) ", major, DST_GetFrequencyNumberbyIndex(RF));
317        }
318        else
319        {
320                sprintf(chNum,"%d-%d(%d) ", major, minor, DST_GetFrequencyNumberbyIndex(RF));
321        }
322//      DeleteCDB(&db);
323        DBLock(false);
324        return true;
325}
326
327// ºÎÆà ÈÄ È¤Àº ¿ÀÅä ½ºÄµ ÈÄ È£Ã⠵ȴÙ.
328void DST_DB_TuneFirstChannel()
329{
330        DBLock(true);
331        if (DST_DB_PresentChMap() == false)
332        {
333                DST_UI_ChannelTune(DST_DB_GetUnexceptedFirstRF(), 0);
334                DBLock(false);
335                return;
336        }
337        // RF ¹øÈ£¿Í ÇÁ·Î±×·¥³Ñ¹ö ÀÏÄ¡Çϴ ä³ÎÀ» ã´Â´Ù.
338        int rf = DST_EEPROM_GetRF();
339        int program_number = DST_EEPROM_GetProgramNumber();
340        int i;
341        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
342        {
343                if (db_channel_db[i].program_number == 0) continue;
344                if (db_channel_db[i].rf != rf) continue;
345                if (db_channel_db[i].program_number != program_number) continue;
346                DST_UI_ChannelTune(rf, program_number);
347                DBLock(false);
348                return;
349        }
350        // RF ¹øÈ£ ÀÏÄ¡Çϴ ä³ÎÀ» ã´Â´Ù.
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                DST_UI_ChannelTune(rf, db_channel_db[i].program_number);
356                DBLock(false);
357                return;
358        }
359        // ù¹ø° ä³Î
360        if (db_channel_updn[0].program_number)
361        {
362                DST_UI_ChannelTune(db_channel_updn[0].rf, db_channel_updn[0].program_number);
363                DBLock(false);
364                return;
365        }
366        DST_UI_ChannelTune(DST_MinRF(), 0);
367        DBLock(false); 
368}
369
370// ¸Å´º¾ó ½ºÄµ ÈÄ ÇØ´ç RFÀÇ Ã¹¹ø° ä³Î·Î °£´Ù.
371void DST_DB_TuneFirstChannelinRF(int rf)
372{
373        int i;
374        if (DST_DB_PresentChMap() == false) return;
375        DBLock(true);
376        // RF ¹øÈ£ ÀÏÄ¡Çϴ ä³ÎÀ» ã´Â´Ù.
377        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
378        {
379                if (db_channel_db[i].program_number == 0) continue;
380                if (db_channel_db[i].rf != rf) continue;
381                DST_UI_ChannelTune(rf, db_channel_db[i].program_number);
382                DBLock(false);
383                return;
384        }
385        DST_UI_ChannelTune(rf, 0);
386        DBLock(false); 
387}
388
389
390int DST_DB_GetProgramNumber(int major, int minor)
391{
392        int i;
393        DBLock(true); 
394        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
395        {
396                if (db_channel_db[i].program_number == 0) continue;
397                if (db_channel_db[i].major != major) continue;
398                if (db_channel_db[i].minor != minor) continue;
399                int ret = db_channel_db[i].program_number;
400                DBLock(false); 
401                return ret;
402        }
403        if (minor != 0) 
404        {
405                DBLock(false); 
406                return 0;
407        }
408        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
409        {
410                if (db_channel_db[i].program_number == 0) continue;
411                if (db_channel_db[i].major != major) continue;
412                //if (db_channel_db[i].minor != minor) continue;
413                int ret = db_channel_db[i].program_number;
414                DBLock(false); 
415                return ret;
416        }
417        DBLock(false); 
418        return 0;
419}
420
421int DST_DB_GetProgramNumberbyRFNumber(int rf)
422{
423        int i;
424        int program_number = 0;
425        int min_minor = 10000;
426        DBLock(true); 
427        for (i=0; i < DB_CHANNEL_DB_MAX;i++)
428        {
429                if (db_channel_db[i].program_number == 0) continue;
430                if (db_channel_db[i].rf != rf) continue;
431                if (db_channel_db[i].minor < min_minor)
432                {
433                        program_number = db_channel_db[i].program_number;
434                        min_minor = db_channel_db[i].minor;
435                }
436        }
437        DBLock(false); 
438        return program_number;
439}
440
441void DST_DB_Del()
442{
443        DBLock(true); 
444#if EPG_SUPPORT
445        int i;
446        for (i =0 ; i < DB_EIT_SUB_MAX; i++)
447        {
448                if (db_eit_sub[i].title) DST_OS_Free(&db_eit_sub[i].title);
449                memset(&db_eit_sub[i], 0, sizeof(_DB_EIT_SUB_));
450        }
451        for (i =0 ; i < DB_ETT_MAX; i++)
452        {
453                if (db_ett[i].title) DST_OS_Free(&db_ett[i].title);
454                memset(&db_ett[i], 0, sizeof(_DB_ETT_));
455        }
456        memset(&db_eit, 0, sizeof(_DB_EIT_)*DB_EIT_MAX);
457#endif
458        memset(&db_pat, 0, sizeof(_DB_PAT_)*DB_PAT_MAX);
459        memset(&db_pmt, 0, sizeof(_DB_PMT_)*DB_PMT_MAX);
460        memset(&db_tvct, 0, sizeof(_DB_TVCT_)*DB_TVCT_MAX);
461        memset(&db_tvct_sub, 0, sizeof(_DB_TVCT_SUB_)*DB_TVCT_SUB_MAX);
462#if CVCT_SUPPORT
463        memset(&db_cvct, 0, sizeof(_DB_CVCT_)*DB_CVCT_MAX);
464        memset(&db_cvct_sub, 0, sizeof(_DB_CVCT_SUB_)*DB_CVCT_SUB_MAX);
465#endif
466#if SUPPORT_CHANNEL_EDIT
467        memset(&db_skip_list, 0, sizeof(_DB_SKIP_LIST_)*DB_SKIP_LIST_MAX);
468#endif // SUPPORT_CHANNEL_EDIT
469        CT_ChMapUpdate();
470        DBLock(false); 
471}
472
473// FLASH ¸Þ¸ð¸® ÀúÀå
474
475DS_U32 DST_CRC32(DS_U8 *data, int len)
476{
477        static DS_U32 crcTable[256];
478        static bool bFirst=true;
479        if (bFirst)
480        {
481                bFirst = false;
482                int i;
483                for ( i=0; i<256; i++) {
484                        DS_U32 crc = 0;
485                        int j;
486                        for ( j=7; j>=0; j--) {
487                                if (((i >> j) ^ (crc >> 31)) & 1) crc=(crc<<1)^0x04C11DB7;
488                                else crc<<=1;
489                        }
490                        crcTable[i] = crc;
491                }
492        }
493        DS_U32 crc = 0xFFFFFFFF;
494        int i;
495        for ( i = 0; i < len; ++i) crc = (crc << 8) ^ crcTable[(crc >> 24) ^ (*data++)];
496        return crc;
497}
498
499// FLASH MEMORY LOW LEVEL ACCESS FUNCTION
500static DS_U8 *strFlash = 0;
501static DS_U32 g_nFlashDBSize = 0;
502static DS_U32 g_nFlashDBAddress[2] = {0, 0};
503
504static DS_U32 g_sync_request_time = 0;
505static DS_U32 g_Sync_finish_time = 0;
506static bool s_SyncNow = false;
507
508void DST_DB_Sync()
509{
510        g_sync_request_time = DST_OS_GetTickCount();
511}
512
513void DST_DB_SyncNow()
514{
515        DST_DB_Sync();
516        s_SyncNow = true;
517}
518bool DST_DB_IsSync()
519{
520        return (g_Sync_finish_time < g_sync_request_time) ? false : true;
521}
522
523static void tDB_Sync()
524{
525        while (1)
526        {
527                //T();
528                if(s_SyncNow == false)
529                {
530                        DST_OS_Delay(1000);
531                        if (DST_g_KeyPressTime > DST_OS_GetTickCount()) DST_g_KeyPressTime = DST_OS_GetTickCount();
532                        if (DST_OS_GetTickCount() - DST_g_KeyPressTime < DST_OS_GetTicksPerSecond()*5) continue;
533                        if (DST_DB_IsSync()) continue;
534                }
535                s_SyncNow = false;
536
537                //T();
538                DS_U32 *version = (DS_U32 *)&strFlash[0];
539                DS_U32 *crc = (DS_U32 *)&strFlash[4];
540                int nPos = 8;
541                memcpy(&strFlash[nPos], &db_config, sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
542                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
543                memcpy(&strFlash[nPos], &db_pat, sizeof(_DB_PAT_) * DB_PAT_MAX);
544                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
545                memcpy(&strFlash[nPos], &db_pmt, sizeof(_DB_PMT_) * DB_PMT_MAX);
546                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
547                memcpy(&strFlash[nPos], &db_tvct, sizeof(_DB_TVCT_) * DB_TVCT_MAX);
548                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
549                memcpy(&strFlash[nPos], &db_tvct_sub, sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
550                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
551#if SUPPORT_CHANNEL_EDIT
552                memcpy(&strFlash[nPos], &db_skip_list, sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
553                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
554#endif // SUPPORT_CHANNEL_EDIT
555                *version = FLASH_VERSION;
556                *crc =  DST_CRC32(&strFlash[8], g_nFlashDBSize-8);
557                int i;
558                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
559                DHL_Flash_Write(g_nFlashDBAddress[0], g_nFlashDBSize, strFlash);
560                DHL_Flash_Write(g_nFlashDBAddress[1], g_nFlashDBSize, strFlash);
561                g_Sync_finish_time = DST_OS_GetTickCount();
562        }
563}
564
565void DST_DB_Open()
566{
567        if (strFlash) DST_OS_Free(&strFlash);
568        g_nFlashDBSize = 8; //version, crc
569        g_nFlashDBSize += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
570        g_nFlashDBSize += sizeof(_DB_PAT_) * DB_PAT_MAX;
571        g_nFlashDBSize += sizeof(_DB_PMT_) * DB_PMT_MAX;
572        g_nFlashDBSize += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
573        g_nFlashDBSize += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
574#if SUPPORT_CHANNEL_EDIT
575        g_nFlashDBSize += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
576#endif
577
578//      DST_Printf("nFlashDBSize4K = %d nFlashDBSize = %d\n", nFlashDBSize4K, (int)g_nFlashDBSize);
579        DS_U32 nFlashDBSize4K = ((g_nFlashDBSize+4096-1)/4096)*4096;
580        g_nFlashDBAddress[0] = FLASH_CH_MAP_POS;
581        g_nFlashDBAddress[1] = g_nFlashDBAddress[0] + nFlashDBSize4K;
582       
583        strFlash = DHL_Flash_Read(g_nFlashDBAddress[0], g_nFlashDBSize);
584        int i;
585        for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
586        DS_U32 version = *(DS_U32 *)&strFlash[0];
587        DS_U32 crc = *(DS_U32 *)&strFlash[4];
588        bool bValidDB = true;
589        if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) //DB0 is broken
590        {
591                if (strFlash) DST_OS_Free(&strFlash);
592                strFlash = DHL_Flash_Read(g_nFlashDBAddress[1], g_nFlashDBSize);
593                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
594                DS_U32* buff32 = (DS_U32*)strFlash;
595                version = buff32[0];
596                crc = buff32[1];
597                if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) // DB1 is broken
598                {
599                        bValidDB = false;
600                        DST_Factory_Reset();
601                }       
602        }
603        if (bValidDB == true)
604        {
605                int nPos = 8;
606                memcpy(&db_config, &strFlash[nPos], sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
607                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
608                memcpy(&db_pat, &strFlash[nPos],  sizeof(_DB_PAT_) * DB_PAT_MAX);
609                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
610                memcpy(&db_pmt, &strFlash[nPos], sizeof(_DB_PMT_) * DB_PMT_MAX);
611                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
612                memcpy( &db_tvct, &strFlash[nPos], sizeof(_DB_TVCT_) * DB_TVCT_MAX);
613                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
614                memcpy(&db_tvct_sub, &strFlash[nPos], sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
615                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
616#if SUPPORT_CHANNEL_EDIT
617                memcpy(&db_skip_list, &strFlash[nPos], sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
618                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
619#endif         
620                int i;
621                for (i = 0; i < DB_CONFIG_MAX; i++)
622                {
623                        if (strlen(db_config[i].name) == 0) continue;
624                        DST_Printf("%s | %d\n", db_config[i].name, db_config[i].value);
625                }
626        }
627        DST_OS_SpawnTask( (void(*) (void *))tDB_Sync, (char*)"tDB_Sync", APP_TASK_PRIO_EEPROM_SYNC, WIN_MGR_TASK_STACKSIZE,  0);
628}
629
630int DST_DB_GetRF(int major, int *minor, bool* bFound)
631{
632        *bFound = true;
633        int i;
634        int min_rf = 10000;
635        int min_minor = 10000;
636        int nPos = -1;
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) continue;
642                if (db_channel_db[i].minor != *minor) continue;
643                if (db_channel_db[i].rf <  min_rf)
644                {
645                        min_rf = db_channel_db[i].rf;
646                        nPos = i;
647                }
648        }
649        if (nPos >=0) 
650        {
651                *minor = db_channel_db[nPos].minor;
652                int ret = db_channel_db[nPos].rf;
653                DBLock(false); 
654                return ret;
655        }
656
657        min_rf = 10000;
658        min_minor = 10000;
659        nPos = -1;
660
661        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
662        {
663                if (db_channel_db[i].program_number == 0) continue;
664                if (db_channel_db[i].major != major) continue;
665//              if (db_channel_db[i].minor != minor) continue;
666                if (db_channel_db[i].minor < min_minor)
667                {
668                        min_minor = db_channel_db[i].minor;
669                        nPos = i;
670                }
671        }
672        if (nPos >= 0)
673        {
674                nPos = -1;
675                for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
676                {
677                        if (db_channel_db[i].program_number == 0) continue;
678                        if (db_channel_db[i].major != major) continue;
679                        if (db_channel_db[i].minor != min_minor) continue;
680                        if (db_channel_db[i].rf <  min_rf)
681                        {
682                                min_rf = db_channel_db[i].rf;
683                                nPos = i;
684                        }
685                }       
686        }
687        if (nPos >=0) 
688        {
689                *minor = db_channel_db[nPos].minor;
690                int ret = db_channel_db[nPos].rf;
691                DBLock(false); 
692                return ret;
693        }
694        *bFound = false;
695        DBLock(false); 
696        return 0;
697}
698
699int DST_DB_AvailableChannelCount(int major)
700{
701        if (major == 0) return 0;
702        int i;
703        int nCount = 0;
704        DBLock(true); 
705        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
706        {
707                if (db_channel_db[i].program_number == 0) continue;
708                if ((db_channel_db[i].major == major) || 
709                        (db_channel_db[i].major/10 == major) ||
710                        (db_channel_db[i].major/100 == major) ||
711                        (db_channel_db[i].major/1000 == major) ||
712                        (db_channel_db[i].major/10000 == major))
713                {
714                        nCount++;
715                }       
716        }
717        DBLock(false); 
718        return nCount;
719}
720
721bool DST_DB_PresentMatchChannel(int rf, int major, int minor)
722{
723        int i;
724        DBLock(true); 
725        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
726        {
727                if (db_channel_db[i].program_number == 0) continue;
728                if (db_channel_db[i].rf != rf) continue;
729                if (db_channel_db[i].major != major) continue;
730                if (minor != 0) if (db_channel_db[i].minor != minor) continue;
731                DBLock(false); 
732                return true;
733        }
734        DBLock(false); 
735        return false;
736}
737
738// ÁÖÆļö ¼³Á¤¿¡¼­ Á¦¿ÜµÈ ä³ÎÀÎÁö?
739// ÀԷ°ªÀº rfÀÇ index °ªÀÌ´Ù
740int DST_DB_IsExceptRF(int rf)
741{
742        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF()) return 0;
743        if (rf < DST_EEPROM_GetMinRF()) return 1;
744        if (rf > DST_EEPROM_GetMaxRF()) return 1;
745        return 0;
746}
747
748// ¸î°³ÀÇ Ã¤³ÎÀÌ Á¦¿ÜµÇ¾ú´ÂÁö?
749int DST_DB_GetExceptRFCount()
750{
751        return (DST_EEPROM_GetMinRF() - DST_MinRF()) + (DST_MaxRF() - DST_EEPROM_GetMaxRF());
752}
753
754static int GetNextRF(int rf)
755{
756        if (rf >= DST_MaxRF()) return 0;
757        return rf+1;
758}
759// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
760// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
761int DST_DB_GetNextUnexceptRF(int rf)
762{
763        int i=0;
764        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
765        {
766                return GetNextRF(rf);
767        }
768        int curRF = rf;
769        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
770        {
771                curRF = GetNextRF(curRF); 
772                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
773        }       
774        return 0;
775}
776
777static int GetPrevRF(int rf)
778{
779        if (rf <= DST_MinRF()) return DST_MaxRF();
780        return rf-1;
781}
782// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
783// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
784int DST_DB_GetPrevUnexceptRF(int rf)
785{
786        int i=0;
787        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
788        {
789                return GetPrevRF(rf);
790        }
791        int curRF = rf;
792        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
793        {
794                curRF = GetPrevRF(curRF); 
795                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
796        }       
797        return 0;
798}
799
800int DST_DB_GetUnexceptedFirstRF()
801{
802        int i=0;
803        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
804        {
805                if (DST_DB_IsExceptRF(i) == 0) return i;
806        }
807        return DST_MinRF();     
808}
809
810int DST_DB_GetUnexceptedLastRF()
811{
812        int i=0;
813        for (i = DST_MaxRF(); i >= DST_MinRF(); i--)
814        {
815                if (DST_DB_IsExceptRF(i) == 0) return i;
816        }
817        return DST_MaxRF();     
818}
Note: See TracBrowser for help on using the repository browser.