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

Last change on this file since 39 was 39, checked in by phkim, 10 years ago
  1. phkim
  2. app_c
  3. 변경 내용
    • 채널 편집후 채널 업다운시 버그 수정 (6-1, 11-1 만 활성화, 이후 채널 편집 모드에서 9-1로 채널 변경, 메뉴에서 나와서 채널 up/dn 시 버그)
File size: 20.2 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;
506
507void DST_DB_Sync()
508{
509        g_sync_request_time = DST_OS_GetTickCount();
510}
511
512bool DST_DB_IsSync()
513{
514        return (g_Sync_finish_time < g_sync_request_time) ? false : true;
515}
516
517static void tDB_Sync()
518{
519        while (1)
520        {
521                //T();
522                DST_OS_Delay(1000);
523                if (DST_g_KeyPressTime > DST_OS_GetTickCount()) DST_g_KeyPressTime = DST_OS_GetTickCount();
524                if (DST_OS_GetTickCount() - DST_g_KeyPressTime < DST_OS_GetTicksPerSecond()*5) continue;
525                if (DST_DB_IsSync()) continue;
526                //T();
527                DS_U32 *version = (DS_U32 *)&strFlash[0];
528                DS_U32 *crc = (DS_U32 *)&strFlash[4];
529                int nPos = 8;
530                memcpy(&strFlash[nPos], &db_config, sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
531                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
532                memcpy(&strFlash[nPos], &db_pat, sizeof(_DB_PAT_) * DB_PAT_MAX);
533                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
534                memcpy(&strFlash[nPos], &db_pmt, sizeof(_DB_PMT_) * DB_PMT_MAX);
535                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
536                memcpy(&strFlash[nPos], &db_tvct, sizeof(_DB_TVCT_) * DB_TVCT_MAX);
537                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
538                memcpy(&strFlash[nPos], &db_tvct_sub, sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
539                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
540#if SUPPORT_CHANNEL_EDIT
541                memcpy(&strFlash[nPos], &db_skip_list, sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
542                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
543#endif // SUPPORT_CHANNEL_EDIT
544                *version = FLASH_VERSION;
545                *crc =  DST_CRC32(&strFlash[8], g_nFlashDBSize-8);
546                int i;
547                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
548                DHL_Flash_Write(g_nFlashDBAddress[0], g_nFlashDBSize, strFlash);
549                DHL_Flash_Write(g_nFlashDBAddress[1], g_nFlashDBSize, strFlash);
550                g_Sync_finish_time = DST_OS_GetTickCount();
551        }
552}
553
554void DST_DB_Open()
555{
556        if (strFlash) DST_OS_Free(&strFlash);
557        g_nFlashDBSize = 8; //version, crc
558        g_nFlashDBSize += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
559        g_nFlashDBSize += sizeof(_DB_PAT_) * DB_PAT_MAX;
560        g_nFlashDBSize += sizeof(_DB_PMT_) * DB_PMT_MAX;
561        g_nFlashDBSize += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
562        g_nFlashDBSize += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
563#if SUPPORT_CHANNEL_EDIT
564        g_nFlashDBSize += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
565#endif
566
567//      DST_Printf("nFlashDBSize4K = %d nFlashDBSize = %d\n", nFlashDBSize4K, (int)g_nFlashDBSize);
568        DS_U32 nFlashDBSize4K = ((g_nFlashDBSize+4096-1)/4096)*4096;
569        g_nFlashDBAddress[0] = FLASH_CH_MAP_POS;
570        g_nFlashDBAddress[1] = g_nFlashDBAddress[0] + nFlashDBSize4K;
571       
572        strFlash = DHL_Flash_Read(g_nFlashDBAddress[0], g_nFlashDBSize);
573        int i;
574        for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
575        DS_U32 version = *(DS_U32 *)&strFlash[0];
576        DS_U32 crc = *(DS_U32 *)&strFlash[4];
577        bool bValidDB = true;
578        if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) //DB0 is broken
579        {
580                if (strFlash) DST_OS_Free(&strFlash);
581                strFlash = DHL_Flash_Read(g_nFlashDBAddress[1], g_nFlashDBSize);
582                for (i=0; i <g_nFlashDBSize; i++) strFlash[i] ^= 0xFF;
583                DS_U32* buff32 = (DS_U32*)strFlash;
584                version = buff32[0];
585                crc = buff32[1];
586                if ((version != FLASH_VERSION) || (crc !=  DST_CRC32(&strFlash[8], g_nFlashDBSize-8))) // DB1 is broken
587                {
588                        bValidDB = false;
589                        DST_Factory_Reset();
590                }       
591        }
592        if (bValidDB == true)
593        {
594                int nPos = 8;
595                memcpy(&db_config, &strFlash[nPos], sizeof(_DB_CONFIG_) * DB_CONFIG_MAX);
596                nPos += sizeof(_DB_CONFIG_) * DB_CONFIG_MAX;
597                memcpy(&db_pat, &strFlash[nPos],  sizeof(_DB_PAT_) * DB_PAT_MAX);
598                nPos += sizeof(_DB_PAT_) * DB_PAT_MAX;
599                memcpy(&db_pmt, &strFlash[nPos], sizeof(_DB_PMT_) * DB_PMT_MAX);
600                nPos += sizeof(_DB_PMT_) * DB_PMT_MAX;
601                memcpy( &db_tvct, &strFlash[nPos], sizeof(_DB_TVCT_) * DB_TVCT_MAX);
602                nPos += sizeof(_DB_TVCT_) * DB_TVCT_MAX;
603                memcpy(&db_tvct_sub, &strFlash[nPos], sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX);
604                nPos += sizeof(_DB_TVCT_SUB_) * DB_TVCT_SUB_MAX;
605#if SUPPORT_CHANNEL_EDIT
606                memcpy(&db_skip_list, &strFlash[nPos], sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX);
607                nPos += sizeof(_DB_SKIP_LIST_) * DB_SKIP_LIST_MAX;
608#endif         
609                int i;
610                for (i = 0; i < DB_CONFIG_MAX; i++)
611                {
612                        if (strlen(db_config[i].name) == 0) continue;
613                        DST_Printf("%s | %d\n", db_config[i].name, db_config[i].value);
614                }
615        }
616        DST_OS_SpawnTask( (void(*) (void *))tDB_Sync, (char*)"tDB_Sync", APP_TASK_PRIO_EEPROM_SYNC, WIN_MGR_TASK_STACKSIZE,  0);
617}
618
619int DST_DB_GetRF(int major, int *minor, bool* bFound)
620{
621        *bFound = true;
622        int i;
623        int min_rf = 10000;
624        int min_minor = 10000;
625        int nPos = -1;
626        DBLock(true); 
627        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
628        {
629                if (db_channel_db[i].program_number == 0) continue;
630                if (db_channel_db[i].major != major) continue;
631                if (db_channel_db[i].minor != *minor) continue;
632                if (db_channel_db[i].rf <  min_rf)
633                {
634                        min_rf = db_channel_db[i].rf;
635                        nPos = i;
636                }
637        }
638        if (nPos >=0) 
639        {
640                *minor = db_channel_db[nPos].minor;
641                int ret = db_channel_db[nPos].rf;
642                DBLock(false); 
643                return ret;
644        }
645
646        min_rf = 10000;
647        min_minor = 10000;
648        nPos = -1;
649
650        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
651        {
652                if (db_channel_db[i].program_number == 0) continue;
653                if (db_channel_db[i].major != major) continue;
654//              if (db_channel_db[i].minor != minor) continue;
655                if (db_channel_db[i].minor < min_minor)
656                {
657                        min_minor = db_channel_db[i].minor;
658                        nPos = i;
659                }
660        }
661        if (nPos >= 0)
662        {
663                nPos = -1;
664                for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
665                {
666                        if (db_channel_db[i].program_number == 0) continue;
667                        if (db_channel_db[i].major != major) continue;
668                        if (db_channel_db[i].minor != min_minor) continue;
669                        if (db_channel_db[i].rf <  min_rf)
670                        {
671                                min_rf = db_channel_db[i].rf;
672                                nPos = i;
673                        }
674                }       
675        }
676        if (nPos >=0) 
677        {
678                *minor = db_channel_db[nPos].minor;
679                int ret = db_channel_db[nPos].rf;
680                DBLock(false); 
681                return ret;
682        }
683        *bFound = false;
684        DBLock(false); 
685        return 0;
686}
687
688int DST_DB_AvailableChannelCount(int major)
689{
690        if (major == 0) return 0;
691        int i;
692        int nCount = 0;
693        DBLock(true); 
694        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
695        {
696                if (db_channel_db[i].program_number == 0) continue;
697                if ((db_channel_db[i].major == major) || 
698                        (db_channel_db[i].major/10 == major) ||
699                        (db_channel_db[i].major/100 == major) ||
700                        (db_channel_db[i].major/1000 == major) ||
701                        (db_channel_db[i].major/10000 == major))
702                {
703                        nCount++;
704                }       
705        }
706        DBLock(false); 
707        return nCount;
708}
709
710bool DST_DB_PresentMatchChannel(int rf, int major, int minor)
711{
712        int i;
713        DBLock(true); 
714        for (i = 0; i < DB_CHANNEL_DB_MAX; i++)
715        {
716                if (db_channel_db[i].program_number == 0) continue;
717                if (db_channel_db[i].rf != rf) continue;
718                if (db_channel_db[i].major != major) continue;
719                if (minor != 0) if (db_channel_db[i].minor != minor) continue;
720                DBLock(false); 
721                return true;
722        }
723        DBLock(false); 
724        return false;
725}
726
727// ÁÖÆļö ¼³Á¤¿¡¼­ Á¦¿ÜµÈ ä³ÎÀÎÁö?
728// ÀԷ°ªÀº rfÀÇ index °ªÀÌ´Ù
729int DST_DB_IsExceptRF(int rf)
730{
731        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF()) return 0;
732        if (rf < DST_EEPROM_GetMinRF()) return 1;
733        if (rf > DST_EEPROM_GetMaxRF()) return 1;
734        return 0;
735}
736
737// ¸î°³ÀÇ Ã¤³ÎÀÌ Á¦¿ÜµÇ¾ú´ÂÁö?
738int DST_DB_GetExceptRFCount()
739{
740        return (DST_EEPROM_GetMinRF() - DST_MinRF()) + (DST_MaxRF() - DST_EEPROM_GetMaxRF());
741}
742
743static int GetNextRF(int rf)
744{
745        if (rf >= DST_MaxRF()) return 0;
746        return rf+1;
747}
748// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
749// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
750int DST_DB_GetNextUnexceptRF(int rf)
751{
752        int i=0;
753        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
754        {
755                return GetNextRF(rf);
756        }
757        int curRF = rf;
758        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
759        {
760                curRF = GetNextRF(curRF); 
761                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
762        }       
763        return 0;
764}
765
766static int GetPrevRF(int rf)
767{
768        if (rf <= DST_MinRF()) return DST_MaxRF();
769        return rf-1;
770}
771// Á¦¿ÜµÇÁö ¾ÊÀº ´ÙÀ½ RFÀÇ index°ªÀ» °¡Á®¿Â´Ù
772// ÀÔ·ÂµÈ °ªÀº ÇöÀç indexed rf ´Ù
773int DST_DB_GetPrevUnexceptRF(int rf)
774{
775        int i=0;
776        if (DST_EEPROM_GetMinRF() == DST_MinRF() && DST_EEPROM_GetMaxRF() == DST_MaxRF())
777        {
778                return GetPrevRF(rf);
779        }
780        int curRF = rf;
781        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
782        {
783                curRF = GetPrevRF(curRF); 
784                if (DST_DB_IsExceptRF(curRF) == 0) return curRF;
785        }       
786        return 0;
787}
788
789int DST_DB_GetUnexceptedFirstRF()
790{
791        int i=0;
792        for (i = DST_MinRF(); i <= DST_MaxRF(); i++)
793        {
794                if (DST_DB_IsExceptRF(i) == 0) return i;
795        }
796        return DST_MinRF();     
797}
798
799int DST_DB_GetUnexceptedLastRF()
800{
801        int i=0;
802        for (i = DST_MaxRF(); i >= DST_MinRF(); i--)
803        {
804                if (DST_DB_IsExceptRF(i) == 0) return i;
805        }
806        return DST_MaxRF();     
807}
Note: See TracBrowser for help on using the repository browser.