source: titan/titan/radiotext.h @ 34375

Last change on this file since 34375 was 8964, checked in by nit, 13 years ago

[titan] add new dvb subtitle code (libdvbsub never needed), add center and scoll funktion for vfd, some little fixes, add radiotext/rass funktions (not working yet)

File size: 16.5 KB
Line 
1#ifndef RADIOTEXT_H
2#define RADIOTEXT_H
3
4#define SWAP(x) ((x << 8)|(x >> 8))
5#define LO(x) (x & 0xFF)
6
7int rtmsgptr = 0, rtbsflag = 0, rtqdarpos = 0, rttptr = 0, rtqdarmvishow = 0, rttype;
8unsigned char rtmessage[66], rtlastmessage[66], rtdatamessage[256], rtpbuf[5], rtleninfo, rttextlen, rttextlen2, rtstate = '\0';
9unsigned char rtpitem[64][64], rtplusosd[64]; //rtp
10unsigned char rtqdar[60 * 1024]; //60 kB for holding Rass qdar archive
11unsigned short rtcrc16, rtcrc;
12long rtpart, rtparts, rtpartcnt;
13unsigned char rtrasspicturemask[5];  // 40 bits... (10 * 4 pictures)
14
15static int rtbitrate[3][3][16] = {
16        {
17                {-1,8000,16000,24000,32000,40000,48000,56000,64000,80000,96000,112000,128000,144000,160000,0}, //MPEG-2, L3
18                {-1,8000,16000,24000,32000,40000,48000,56000,64000,80000,96000,112000,128000,144000,160000,0}, //MPEG-2, L2
19                {-1,32000,48000,56000,64000,80000,96000,112000,128000,144000,160000,176000,192000,224000,256000,0} //MPEG-2, L1
20        },
21        {
22                {-1,32000,40000,48000,56000,64000,80000,96000,112000,128000,160000,192000,224000,256000,320000,0}, //MPEG-1, L3
23                {-1,32000,48000,56000,64000,80000,96000,112000,128000,160000,192000,224000,256000,320000,384000,0}, //MPEG-1, L2
24                {-1,32000,64000,96000,128000,160000,192000,224000,256000,288000,320000,352000,384000,416000,448000,0} //MPEG-1, L1
25        },
26        {
27                {-1,6000,8000,10000,12000,16000,20000,24000,28000,320000,40000,48000,56000,64000,80000,0}, //MPEG-2.5, L3??
28                {-1,6000,8000,10000,12000,16000,20000,24000,28000,320000,40000,48000,56000,64000,80000,0}, //MPEG-2.5, L2
29                {-1,8000,12000,16000,20000,24000,32000,40000,48000,560000,64000,80000,96000,112000,128000,0} //MPEG-2.5, L1
30        }
31};
32
33static int rtfrequency[3][4] = {
34        {22050,24000,16000,0}, //MPEG2 - 22.05, 24, 16khz
35        {44100,48000,32000,0}, //MPEG1 - 44.1, 48, 32khz
36        {11025,12000,8000,0} //MPEG2.5 - 11.025, 12, 8khz
37};
38
39/*
40DEFINE_REF(eDVBRdsDecoder);
41
42eDVBRdsDecoder::eDVBRdsDecoder(iDVBDemux *demux, int type)
43        :rtmsgptr(0), rtbsflag(0), rtqdarpos(0), rttptr(0), rtqdarmvishow(0), rtstate(0)
44        ,rttype(type), m_pid(-1), m_abortTimer(eTimer::create(eApp))
45{
46        setStreamID(0xC0, 0xC0);
47
48        memset(rtrasspicturemask, 0, sizeof(rtrasspicturemask));
49        memset(rtpitem, 0, sizeof(rtpitem));
50
51        if (demux->createPESReader(eApp, m_pes_reader))
52                eDebug("failed to create PES reader!");
53        else if (type == 0)
54                m_pes_reader->connectRead(slot(*this, &eDVBRdsDecoder::processData), m_read_connection);
55        else
56                m_pes_reader->connectRead(slot(*this, &eDVBRdsDecoder::gotAncillaryData), m_read_connection);
57        CONNECT(m_abortTimer->timeout, eDVBRdsDecoder::abortNonAvail);
58}
59*/
60
61char* rtgetrass(int page, int subpage)
62{
63        char *fname = NULL;
64        int val = 0;
65
66        fname = malloc(50);
67        if(fname == NULL)
68        {
69                err("no mem");
70                return NULL;
71        }
72       
73        switch(subpage)
74        {
75                case 0:
76                        val = page * 1000;
77                        break;
78                case 1:
79                        val = page * 1100;
80                        break;
81                case 2:
82                        val = page * 1110;
83                        break;
84                case 3:
85                        val = page * 1111;
86                        break;
87        }
88
89        sprintf(fname, "/tmp/Rass%04d.mvi", val);
90        return fname;
91}
92
93void rtdelrass()
94{
95        int page = 0;
96
97        // delete cached rass slides
98        for(page=0; page < 10; ++page)
99        {
100                unsigned char mask = rtrasspicturemask[(page * 4) / 8];
101                if(page % 2) mask >>= 4;
102                int subpage = 0;
103
104                while(mask)
105                {
106                        if(mask & 1)
107                        {
108                                char* filename = rtgetrass(page, subpage);
109                                if(filename != NULL && strlen(filename) > 0) unlink(filename);
110                                free(filename); filename = NULL;
111                        }
112                        mask >>= 1;
113                        ++subpage;
114                }
115        }
116        unlink("/tmp/RassLast.mvi");
117}
118
119unsigned short rt_crc_ccitt_byte(unsigned short crc, unsigned char c)
120{
121        rtcrc = SWAP(rtcrc) ^ c;
122        rtcrc = rtcrc ^ (LO(rtcrc) >> 4);
123        rtcrc = rtcrc ^ (SWAP(LO(rtcrc)) << 4) ^ (LO(rtcrc) << 5);
124        return rtcrc;
125}
126
127/*
128void eDVBRdsDecoder::connectEvent(const Slot1<void, int> &slot, ePtr<eConnection> &connection)
129{
130        connection = new eConnection(this, m_event.connect(slot));
131}
132*/
133
134void rtaddpicturemask(int id)
135{
136        int page = id / 1000;
137        int tmp = page > 0 ? id / page : id;
138        int subpage = 0;
139
140        while(tmp > 1000)
141        {
142                ++subpage;
143                tmp -= 1000;
144                tmp *= 10;
145        }
146
147        int index = (page * 4 + subpage) / 8;
148        int val = (page % 2) ? 16 * (1 << subpage) : (1 << subpage);
149        if(rtrasspicturemask[index] & val) //already have this picture
150                return;
151        rtrasspicturemask[index] |= val;
152        // m_event(RassInteractivePicMaskChanged);
153}
154
155void rtdelpicturemask(int id)
156{
157        int page = id / 1000;
158        int tmp = page > 0 ? id / page : id;
159        int subpage = 0;
160
161        while(tmp > 1000)
162        {
163                ++subpage;
164                tmp -= 1000;
165                tmp *= 10;
166        }
167
168        int index = (page * 4) / 8;
169        int val = (page % 2) ? 16 * (1 << subpage) : (1 << subpage);
170        if(rtrasspicturemask[index] & val) // have this picture
171        {
172                rtrasspicturemask[index] &= ~val;
173                // m_event(RassInteractivePicMaskChanged);
174        }
175}
176
177void rtprocessqdar(unsigned char *buf)
178{
179        if(buf[0] == 0x40 && buf[1] == 0xDA)
180        {
181                unsigned int item, cnt, ctrl, item_type;
182                unsigned long item_length, id, item_no, ptr, tmp;
183                unsigned short crc_qdar, crc_read;
184                char fname[50];
185
186                ptr=4; cnt=0;
187                item = buf[2] << 8; //Number of Items
188                item |= buf[3];
189               
190                while(cnt++ < item) //read in items
191                {
192                        id = buf[ptr++] << 8; //QDarID
193                        id |= buf[ptr++];
194                       
195                        item_no = buf[ptr++] << 8; //Item Number
196                        item_no |= buf[ptr++];
197                       
198                        ctrl = buf[ptr++]; //controlbyte
199                        item_type = buf[ptr++]; //item type
200                       
201                        item_length = buf[ptr++] << 24; // Item length
202                        item_length |= buf[ptr++] << 16;
203                        item_length |= buf[ptr++] << 8;
204                        item_length |= buf[ptr++];
205                       
206                        ptr = ptr + 4; //rfu Bytes ... not used
207                        tmp = ptr; //calc crc
208                        crc_qdar = 0xFFFF;
209
210                        while(tmp < ptr + item_length)
211                                crc_qdar = rt_crc_ccitt_byte(crc_qdar, buf[tmp++]);
212               
213                        crc_read = buf[ptr + item_length] << 8;
214                        crc_read |= buf[ptr + item_length + 1];
215                        //debug(270, "RDS/Rass CRC read: %04X calculated: %04X", crc_read, crc_qdar ^ 0xFFFF);
216
217                        if(crc_read == (crc_qdar ^ 0xFFFF)) //process item
218                        {
219                                switch(item_type)
220                                {
221                                        case 0x01: //Stillframe
222                                                if (ctrl & 0x01) //display slide
223                                                {
224                                                        sprintf(fname,"/tmp/RassLast.mvi");
225                                                        FILE *fh = fopen(fname, "wb");
226                                                        fwrite(buf + ptr, 1, item_length - 2, fh);
227                                                        fclose(fh);
228                                                        // m_event(RecvRassSlidePic);
229                                                        rtqdarmvishow = 1;
230                                                }
231                                                if (ctrl & 0x02) //save slide for interactive mode
232                                                {
233                                                        if(id == 0 || id >= 1000)
234                                                        {
235                                                                sprintf(fname, "/tmp/Rass%04d.mvi", (int)id);
236                                                                FILE *fh = fopen(fname, "wb");
237                                                                fwrite(buf + ptr, 1, item_length - 2, fh);
238                                                                fclose(fh);
239                                                                rtaddpicturemask(id);
240                                                        }
241                                                        else
242                                                                debug(270, "ignore recv interactive picture id %lu", id);
243                                                }
244                                                if(ctrl & 0x04) // display slide if nothing had been displayed yet
245                                                {
246                                                        if(rtqdarmvishow != 1)
247                                                        {
248                                                                sprintf(fname, "/tmp/RassLast.mvi");
249                                                                FILE *fh = fopen(fname, "wb");
250                                                                fwrite(buf + ptr, 1, item_length - 2, fh);
251                                                                fclose(fh);
252                                                                // m_event(RecvRassSlidePic);
253                                                                rtqdarmvishow = 1;
254                                                        }
255                                                }
256                                                if(ctrl & 0x08) //delete slide
257                                                {
258                                                        debug(270, "delete slide id %lu, item_no %lu", id, item_no);
259                                                        if(id == 0 || id >= 1000)
260                                                        {
261                                                                debug(270, "delete %lu", id);
262                                                                rtdelpicturemask(id);
263                                                                sprintf(fname, "/tmp/Rass%04d.mvi", (int)id); //was item_no ? ! ?
264                                                                unlink(fname);
265                                                        }
266                                                        else
267                                                                debug(270, "ignore del interactive picture id %lu", id);
268                                                }
269                                                break;
270                                        default: //nothing more yet defined
271                                                break;
272                                }
273                        }
274                        else
275                        {
276                                debug(270, "RDS/Rass CRC error, skip Rass-Qdar-Item");
277                        }
278                       
279                        ptr =+ item_length;
280                }
281        }
282        else
283        {
284                debug(270, "RDS/Rass No Rass-QDAR archive (%02X %02X) so skipping !", buf[0], buf[1]);
285        }
286}
287
288void rtgotancillarydata(const unsigned char *buf, int len)
289{
290        if(len <= 0) return;
291
292        int pos = rttype ? 0 : len-1;
293        while(len)
294        {
295                unsigned char c = buf[pos];
296
297                pos += rttype ? 1 : -1;
298                --len;
299
300                if(rtbsflag == 1) // byte stuffing
301                {
302                        rtbsflag = 2;
303                        switch(c)
304                        {
305                                case 0x00: c=0xFD; break;
306                                case 0x01: c=0xFE; break;
307                                case 0x02: c=0xFF; break;
308                        }
309                }
310
311                if(c == 0xFD && rtbsflag == 0)
312                        rtbsflag = 1;
313                else
314                        rtbsflag = 0;
315                                       
316                if(rtbsflag == 0)
317                {
318                        if(rtstate == 1)
319                                rtcrc = 0xFFFF;
320                        if((rtstate >= 1 && rtstate < 11) || (rtstate >=26 && rtstate < 36))
321                                rtcrc = rt_crc_ccitt_byte(rtcrc, c);
322
323                        switch(rtstate)
324                        {
325                                case 0:
326                                        if(c == 0xFE) rtstate = 1; //startkennung
327                                        break;
328                                case 1: // 10bit Site Address + 6bit Encoder Address
329                                case 2:
330                                case 3: // Sequence Counter
331                                        ++rtstate;
332                                        break;
333                                case 4:
334                                        rtleninfo = c;
335                                        ++rtstate;
336                                        break;
337                                case 5:
338                                        switch(c)
339                                        {
340                                                case 0x0A: // Radiotext
341                                                        ++rtstate;
342                                                        break;
343                                                case 0x46: // Radiotext Plus tags
344                                                        rtstate = 38;
345                                                        break;
346                                                case 0xDA: // Rass
347                                                        rtstate = 26;
348                                                        break;
349                                                default: // reset to state 0
350                                                        rtstate = 0;
351                                        }
352                                        break;
353
354                                        // process Radiotext
355                                case 6: // Data Set Number ... ignore
356                                case 7: // Program Service Number ... ignore
357                                        ++rtstate;
358                                        break;
359                                case 8: // Message Element Length
360                                        rttextlen = c;
361                                        if(!rttextlen || rttextlen > 65 || rttextlen > rtleninfo - 4)
362                                                rtstate = 0;
363                                        else
364                                        {
365                                                ++rtstate;
366                                                rttextlen -= 2;
367                                                rtmsgptr = 0;
368                                        }
369                                        break;
370                                case 9: // Radio Text Status bit:
371                                        // 0   = AB-flagcontrol
372                                        // 1-4 = Transmission-Number
373                                        // 5-6 = Buffer-Config
374                                        ++rtstate; // ignore ...
375                                        break;
376                                case 10:
377                                        // TODO build a complete radiotext charcode to UTF8 conversion table for all character > 0x80
378                                        switch (c)
379                                        {
380                                                case 0 ... 0x7f: break;
381                                                case 0x8d: c = 'ß'; break;
382                                                case 0x91: c = 'ä'; break;
383                                                case 0xd1: c = 'Ä'; break;
384                                                case 0x97: c = 'ö'; break;
385                                                case 0xd7: c = 'Ö'; break;
386                                                case 0x99: c = 'ü'; break;
387                                                case 0xd9: c = 'Ü'; break;
388                                                default: c = ' '; break;  // convert all unknown to space
389                                        }
390                                        rtmessage[rtmsgptr++] = c;
391                                        if(rttextlen)
392                                                --rttextlen;
393                                        else
394                                                ++rtstate;
395                                        break;
396                                case 11:
397                                        rtcrc16 = c << 8;
398                                        ++rtstate;
399                                        break;
400                                case 12:
401                                        rtcrc16 |= c;
402                                        rtmessage[rtmsgptr--] = 0;
403                                        while(rtmessage[rtmsgptr] == ' ' && rtmsgptr > 0)
404                                                rtmessage[rtmsgptr--] = 0;
405                                        if(rtcrc16 == (rtcrc ^ 0xFFFF))
406                                        {
407                                                debug(270, "radiotext: (%s)", rtmessage);
408                                                // m_event(RadioTextChanged);
409                                                memcpy(rtlastmessage, rtmessage, 66);
410                                        }
411                                        else
412                                                err("invalid radiotext crc (%s)", rtmessage);
413                                        rtstate = 0;
414                                        break;
415
416                                // process Rass
417                                case 26: //MEL
418                                        rttextlen = c;
419                                        rttextlen2 = c;
420                                        ++rtstate;
421                                        rttextlen -= 9;
422                                        rttextlen2 -= 9;
423                                        rttptr = 0;
424                                        break;
425                                case 27: // SID not used atm
426                                        ++rtstate;
427                                        break;
428                                case 28: // SID not used atm
429                                        ++rtstate;
430                                        break;
431                                case 29: // PNR packet number
432                                        rtpart = c << 16;
433                                        ++rtstate;
434                                        break;
435                                case 30: // PNR packet number
436                                        rtpart |= c << 8;
437                                        ++rtstate;
438                                        break;
439                                case 31: // PNR packet number
440                                        rtpart |= c;
441                                        ++rtstate;
442                                        break;
443                                case 32: // NOP number of packets
444                                        rtparts = c << 16;
445                                        ++rtstate;
446                                        break;
447                                case 33: // NOP number of packets
448                                        rtparts |= c << 8;
449                                        ++rtstate;
450                                        break;
451                                case 34: // NOP number of packets
452                                        rtparts |= c;
453                                        ++rtstate;
454                                        break;
455                                case 35:
456                                        rtdatamessage[rttptr++] = c;
457                                        if(rttextlen)
458                                                --rttextlen;
459                                        else
460                                                ++rtstate;
461                                        break;
462                                case 36:
463                                        rtcrc16 = c << 8;
464                                        ++rtstate;
465                                        break;
466                                case 37:
467                                        rtcrc16 |= c;
468                                        //debug(270, "RDS/Rass CRC read: %04X CRC calculated: %04X", rtcrc16 , rtcrc ^ 0xFFFF);
469                                        rtstate = 0;
470                                        if(rtcrc16 == (rtcrc ^ 0xFFFF))
471                                        {
472                                                if(rtpartcnt == -1)
473                                                        rtpartcnt = 1;
474                                                if(rtpartcnt == rtpart)
475                                                {
476                                                        memcpy(rtqdar + rtqdarpos, rtdatamessage, rttextlen2 + 1);
477                                                        rtqdarpos = rtqdarpos + rttextlen2 + 1;
478                                                        if(rtpartcnt == rtparts)
479                                                        {
480                                                                rtprocessqdar(rtqdar); // decode qdar archive
481                                                                rtqdarpos = 0;
482                                                                rtpartcnt = -1;
483                                                        }
484                                                        else
485                                                                ++rtpartcnt;
486                                                }
487                                                else
488                                                {
489                                                        rtqdarpos = 0;
490                                                        rtpartcnt = -1;
491                                                }
492                                        }
493                                        else
494                                        {
495                                                debug(270, "RDS/Rass CRC error, skip Rass-Qdar-Packet");
496                                                debug(270, "RDS/Rass CRC read: %04X CRC calculated: %04X", rtcrc16, rtcrc ^ 0xFFFF);
497                                                rtpartcnt = -1;
498                                        }
499                                        rtstate=0;
500                                        break;
501
502                                // process RT plus tags ...
503                                case 38: // Message Element Length
504                                        rttextlen = c; 
505                                        ++rtstate;
506                                        break;
507                                case 39: // Application ID
508                                case 40: // always 0x4BD7 so we ignore it ;)
509                                case 41: // Applicationgroup Typecode/PTY ... ignore
510                                        ++rtstate;
511                                        break;
512                                case 42:
513                                        rtpbuf[0] = c;
514                                        ++rtstate;
515                                        break;
516                                case 43:
517                                        rtpbuf[1] = c;
518                                        ++rtstate;
519                                        break;
520                                case 44:
521                                        rtpbuf[2] = c;
522                                        ++rtstate;
523                                        break;
524                                case 45:
525                                        rtpbuf[3] = c;
526                                        ++rtstate;
527                                        break;
528                                case 46: // bit 10#4 = Item Togglebit
529                                        // bit 10#3 = Item Runningbit
530                                        // Tag1: bit 10#2..11#5 = Contenttype, 11#4..12#7 = Startmarker, 12#6..12#1 = Length
531                                        rtpbuf[4] = c;
532                                        if(rtlastmessage[0] == 0) // no rds message till now ? quit ...
533                                                break;
534                                        int rtp_typ[2], rtp_start[2], rtp_len[2];
535                                        rtp_typ[0] = (0x38 & rtpbuf[0] << 3) | rtpbuf[1] >> 5;
536                                        rtp_start[0] = (0x3e & rtpbuf[1] <<1 ) | rtpbuf[2] >> 7;
537                                        rtp_len[0] = 0x3f & rtpbuf[2] >> 1;
538                                        // Tag2: bit 12#0..13#3 = Contenttype, 13#2..14#5 = Startmarker, 14#4..14#0 = Length(5bit)
539                                        rtp_typ[1] = (0x20 & rtpbuf[2] << 5) | rtpbuf[3] >> 3;
540                                        rtp_start[1] = (0x38 & rtpbuf[3] << 3) | rtpbuf[4] >> 5;
541                                        rtp_len[1] = 0x1f & rtpbuf[4];
542                                                                       
543                                        unsigned char rtplusosdtmp[64];
544                                       
545                                        if(rtp_start[0] < 66 && (rtp_len[0] + rtp_start[0]) < 66)
546                                        {
547                                                memcpy(rtpitem[rtp_typ[0]], rtlastmessage + rtp_start[0], rtp_len[0] + 1);
548                                                rtpitem[rtp_typ[0]][rtp_len[0] + 1] = 0;
549                                        }
550                                                                       
551                                        if(rtp_typ[0] != rtp_typ[1])
552                                        {
553                                                if(rtp_start[1] < 66 && (rtp_len[1] + rtp_start[1]) < 66)
554                                                {
555                                                        memcpy(rtpitem[rtp_typ[1]], rtlastmessage + rtp_start[1], rtp_len[1] + 1);
556                                                        rtpitem[rtp_typ[1]][rtp_len[1] + 1] = 0;
557                                                }
558                                        }
559
560                                        // main RTPlus item_types used by the radio stations:
561                                        // 1 title
562                                        // 4 artist
563                                        // 24 info.date_time
564                                        // 31 stationname
565                                        // 32 program.now
566                                        // 39 homepage
567                                        // 41 phone.hotline
568                                        // 46 email.hotline
569                                        // todo: make a window to display all saved items ...
570       
571                                        //create RTPlus OSD for title/artist
572                                        rtplusosd[0] = 0;
573                                                               
574                                        if(rtpitem[4][0] != 0) //artist
575                                                sprintf((char*)rtplusosdtmp, " (%s)", rtpitem[4]);
576                                                               
577                                        if(rtpitem[1][0] != 0) //title
578                                                sprintf((char*)rtplusosd, "%s%s", rtpitem[1], rtplusosdtmp);
579                                                                       
580                                        if(rtplusosd[0] != 0)
581                                        {
582                                                // m_event(RtpTextChanged);
583                                                debug(270, "RTPlus: %s", rtplusosd);
584                                        }
585                                               
586                                        rtstate = 0;
587                                        break;
588                        }
589                }
590        }
591}
592
593void rtprocesspes(unsigned char *data, int len)
594{
595        int pos = 9 + data[8]; // skip pes header
596
597        while(pos < len)
598        {
599                if((0xFF & data[pos]) != 0xFF || (0xF0 & data[pos + 1]) != 0xF0)
600                        return;
601
602                int padding_bit = (data[pos + 2] >> 1) & 1;
603                int mode = (data[pos + 3] >> 6) & 3;
604                int channel = mode == 3 ? 1 : 2;
605                int id = (data[pos + 1] >> 3) & 1;
606                int emphasis_bit = data[pos + 3] & 3;
607                //int protection_bit = data[pos + 1] & 1;
608                int rate = -1;
609                int sample_freq = -1;
610                int layer = -1;
611
612                if(emphasis_bit == 2 && id == 1)
613                        id = 2;
614
615                if((layer = (data[pos + 1] >> 1) & 3) < 1)
616                        return;
617
618                if((rate = rtbitrate[id][layer - 1][(data[pos + 2] >> 4) & 0xf]) < 1)
619                        return;
620
621                if((sample_freq = rtfrequency[id][(data[pos + 2] >> 2) & 3]) == 0)
622                        return;
623
624                if(id == 1 && layer == 2)
625                {
626                        if(rate / channel < 32000) return;
627                        if(rate / channel > 192000) return;
628                }
629
630                int frame_size = layer < 3 ?  (144 * rate / sample_freq) + padding_bit : ((12 * rate / sample_freq) * 4) + (4 * padding_bit);
631
632                pos += frame_size;
633                int offs = pos - 1;
634
635                if (data[offs] == 0xFD)
636                {
637                        //m_abortTimer->stop();
638                        int ancillary_len = 1 + data[offs - 1];
639                        offs -= ancillary_len;
640                        rtgotancillarydata(data + offs, ancillary_len -1 );
641                }
642        }
643}
644
645/*
646int eDVBRdsDecoder::start(int pid)
647{
648        int ret = -1;
649        if (m_pes_reader && !(ret = m_pes_reader->start(pid)) && rttype == 0)
650                m_abortTimer->startLongTimer(20);
651        m_pid = pid;
652        return ret;
653}
654
655void eDVBRdsDecoder::abortNonAvail()
656{
657        eDebug("no ancillary data in audio stream... abort radiotext pes parser");
658        if (m_pes_reader)
659                m_pes_reader->stop();
660}
661
662ePyObject eDVBRdsDecoder::getRassPictureMask()
663{
664        ePyObject ret = PyTuple_New(5);
665        PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(rtrasspicturemask[0]));
666        PyTuple_SET_ITEM(ret, 1, PyInt_FromLong(rtrasspicturemask[1]));
667        PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(rtrasspicturemask[2]));
668        PyTuple_SET_ITEM(ret, 3, PyInt_FromLong(rtrasspicturemask[3]));
669        PyTuple_SET_ITEM(ret, 4, PyInt_FromLong(rtrasspicturemask[4]));
670        return ret;
671}
672*/
673
674#endif
Note: See TracBrowser for help on using the repository browser.