1 | #ifndef RADIOTEXT_H |
---|
2 | #define RADIOTEXT_H |
---|
3 | |
---|
4 | #define SWAP(x) ((x << 8)|(x >> 8)) |
---|
5 | #define LO(x) (x & 0xFF) |
---|
6 | |
---|
7 | int rtmsgptr = 0, rtbsflag = 0, rtqdarpos = 0, rttptr = 0, rtqdarmvishow = 0, rttype; |
---|
8 | unsigned char rtmessage[66], rtlastmessage[66], rtdatamessage[256], rtpbuf[5], rtleninfo, rttextlen, rttextlen2, rtstate = '\0'; |
---|
9 | unsigned char rtpitem[64][64], rtplusosd[64]; //rtp |
---|
10 | unsigned char rtqdar[60 * 1024]; //60 kB for holding Rass qdar archive |
---|
11 | unsigned short rtcrc16, rtcrc; |
---|
12 | long rtpart, rtparts, rtpartcnt; |
---|
13 | unsigned char rtrasspicturemask[5]; // 40 bits... (10 * 4 pictures) |
---|
14 | |
---|
15 | static 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 | |
---|
33 | static 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 | /* |
---|
40 | DEFINE_REF(eDVBRdsDecoder); |
---|
41 | |
---|
42 | eDVBRdsDecoder::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 | |
---|
61 | char* 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 | |
---|
93 | void 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 | |
---|
119 | unsigned 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 | /* |
---|
128 | void eDVBRdsDecoder::connectEvent(const Slot1<void, int> &slot, ePtr<eConnection> &connection) |
---|
129 | { |
---|
130 | connection = new eConnection(this, m_event.connect(slot)); |
---|
131 | } |
---|
132 | */ |
---|
133 | |
---|
134 | void 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 | |
---|
155 | void 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 | |
---|
177 | void 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 | |
---|
288 | void 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 | |
---|
593 | void 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 | /* |
---|
646 | int 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 | |
---|
655 | void 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 | |
---|
662 | ePyObject 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 |
---|