use boundFunction from tools
[enigma2.git] / lib / dvb / esection.cpp
1 #include <lib/dvb/esection.h>
2 #include <lib/base/eerror.h>
3
4 void eGTable::sectionRead(const __u8 *d)
5 {
6         unsigned int last_section_number = d[7];
7         m_table.flags &= ~eDVBTableSpec::tfAnyVersion;
8         m_table.flags |= eDVBTableSpec::tfThisVersion;
9         m_table.version = (d[5]>>1)&0x1F;
10
11
12         if (createTable(d[6], d, last_section_number + 1))
13         {
14                 if (m_timeout)
15                         m_timeout->stop();
16                 m_reader->stop();
17                 ready = 1;
18                 tableReady(error);
19         } else if ((m_table.flags & eDVBTableSpec::tfHaveTimeout) && m_timeout)
20                 m_timeout->start(m_table.timeout, 1); // reset timeout
21 }
22
23 void eGTable::timeout()
24 {
25         eDebug("timeout!");
26         m_reader->stop();
27         ready = 1;
28         error = -1;
29         tableReady(error);
30 }
31
32 eGTable::eGTable():
33                 m_timeout(0), error(0)
34 {
35 }
36
37 DEFINE_REF(eGTable);
38
39 RESULT eGTable::start(iDVBSectionReader *reader, const eDVBTableSpec &table)
40 {
41         RESULT res;
42         m_table = table;
43
44         m_reader = reader;
45         m_reader->connectRead(slot(*this, &eGTable::sectionRead), m_sectionRead_conn);
46         
47         // setup filter struct
48         eDVBSectionFilterMask mask;
49         
50         memset(&mask, 0, sizeof(mask));
51         mask.pid   = m_table.pid;
52         mask.flags = 0;
53         
54         if (m_table.flags & eDVBTableSpec::tfCheckCRC)
55                 mask.flags |= eDVBSectionFilterMask::rfCRC;
56         
57         if (m_table.flags & eDVBTableSpec::tfHaveTID)
58         {
59                 mask.data[0] = m_table.tid;
60                 if (m_table.flags & eDVBTableSpec::tfHaveTIDMask)
61                         mask.mask[0] = m_table.tid_mask;
62                 else
63                         mask.mask[0] = 0xFF;
64         }
65
66         if (m_table.flags & eDVBTableSpec::tfHaveTIDExt)
67         {
68                 mask.data[1] = m_table.tidext >> 8;
69                 mask.data[2] = m_table.tidext;
70                 if (m_table.flags & eDVBTableSpec::tfHaveTIDExtMask)
71                 {
72                         mask.mask[1] = m_table.tidext_mask >> 8;
73                         mask.mask[2] = m_table.tidext_mask;
74                 }
75                 else
76                 {
77                         mask.mask[1] = 0xFF;
78                         mask.mask[2] = 0xFF;
79                 }
80         }
81         
82         if (!(m_table.flags & eDVBTableSpec::tfAnyVersion))
83         {
84                 eDebug("doing version filtering");
85                 mask.data[3] |= (m_table.version << 1)|1;
86                 mask.mask[3] |= 0x3f;
87                 if (!(m_table.flags & eDVBTableSpec::tfThisVersion))
88                         mask.mode[3] |= 0x3e; // negative filtering
89         } else
90                 eDebug("no version filtering");
91         
92         eDebug("%04x:  %02x %02x %02x %02x %02x %02x",
93                 mask.pid,
94                 mask.data[0], mask.data[1], mask.data[2],
95                 mask.data[3], mask.data[4], mask.data[5]);
96         eDebug("mask:  %02x %02x %02x %02x %02x %02x",
97                 mask.mask[0], mask.mask[1], mask.mask[2],
98                 mask.mask[3], mask.mask[4], mask.mask[5]);
99         eDebug("mode:  %02x %02x %02x %02x %02x %02x",
100                 mask.mode[0], mask.mode[1], mask.mode[2],
101                 mask.mode[3], mask.mode[4], mask.mode[5]);
102
103         if ((res = m_reader->start(mask)))
104         {
105                 eDebug("reader failed to start.");
106                 return res;
107         }
108         
109         if (m_table.flags & eDVBTableSpec::tfHaveTimeout)
110         {
111                 if (m_timeout)
112                         delete m_timeout;
113                 m_timeout = new eTimer(eApp);
114                 m_timeout->start(m_table.timeout, 1); // begin timeout
115                 CONNECT(m_timeout->timeout, eGTable::timeout);
116         }
117         
118         return 0;
119 }
120
121 RESULT eGTable::start(iDVBDemux *demux, const eDVBTableSpec &table)
122 {
123         int res;
124         ePtr<iDVBSectionReader> reader;
125         res = demux->createSectionReader(eApp, reader);
126         if (res)
127                 return res;
128         return start(reader, table);
129 }
130
131 eGTable::~eGTable()
132 {
133         if (m_timeout)
134                 delete m_timeout;
135 }
136
137 void eAUGTable::slotTableReady(int error)
138 {
139         getNext(error);
140 }