fixes for /dev/misc/pvr opening problems in some conditions
[enigma2.git] / lib / dvb / subtitle.cpp
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <fcntl.h>
4 #include <memory.h>
5 #include <time.h>
6
7 #include <asm/types.h>
8 #include <lib/dvb/idemux.h>
9 #include <lib/dvb/subtitle.h>
10 #include <lib/base/smartptr.h>
11 #include <lib/base/eerror.h>
12 #include <lib/gdi/gpixmap.h>
13
14 void bitstream_init(bitstream *bit, const void *buffer, int size)
15 {
16         bit->data = (__u8*) buffer;
17         bit->size = size;
18         bit->avail = 8;
19         bit->consumed = 0;
20 }
21
22 int bitstream_get(bitstream *bit)
23 {
24         int val;
25         bit->avail -= bit->size;
26         val = ((*bit->data) >> bit->avail) & ((1<<bit->size) - 1);
27         if (!bit->avail)
28         {
29                 bit->data++;
30                 bit->consumed++;
31                 bit->avail = 8;
32         }
33         return val;
34 }
35
36 static int extract_pts(pts_t &pts, __u8 *pkt)
37 {
38         pkt += 7;
39         int flags = *pkt++;
40
41         pkt++; // header length
42
43         if (flags & 0x80) /* PTS present? */
44         {
45                         /* damn gcc bug */
46                 pts  = ((unsigned long long)(((pkt[0] >> 1) & 7))) << 30;
47                 pts |=   pkt[1] << 22;
48                 pts |=  (pkt[2]>>1) << 15;
49                 pts |=   pkt[3] << 7;
50                 pts |=  (pkt[5]>>1);
51
52                 return 0;
53         } else
54                 return -1;
55 }
56
57 void eDVBSubtitleParser::subtitle_process_line(subtitle_page *page, int object_id, int line, __u8 *data, int len)
58 {
59         subtitle_region *region = page->regions;
60 //      eDebug("line for %d:%d", page->page_id, object_id);
61         while (region)
62         {
63                 subtitle_region_object *object = region->region_objects;
64                 while (object)
65                 {
66                         if (object->object_id == object_id)
67                         {
68                                 int x = object->object_horizontal_position;
69                                 int y = object->object_vertical_position + line;
70                                 if (x + len > region->region_width)
71                                 {
72                                         //eDebug("[SUB] !!!! XCLIP %d + %d > %d", x, len, region->region_width);
73                                         len = region->region_width - x;
74                                 }
75                                 if (len < 0)
76                                         break;
77                                 if (y >= region->region_height)
78                                 {
79                                         //eDebug("[SUB] !!!! YCLIP %d >= %d", y, region->region_height);
80                                         break;
81                                 }
82 //                              //eDebug("inserting %d bytes (into region %d)", len, region->region_id);
83 //                              eDebug("put data to region_buffer %p", &(*region->region_buffer));
84                                 memcpy((__u8*)region->region_buffer->surface->data + region->region_buffer->surface->stride * y + x, data, len);
85                         }
86                         object = object->next;
87                 }
88                 region = region->next;
89         }
90 }
91
92 int eDVBSubtitleParser::subtitle_process_pixel_data(subtitle_page *page, int object_id, int *linenr, int *linep, __u8 *data)
93 {
94         int data_type = *data++;
95         static __u8 line[720];
96
97         bitstream bit;
98         bit.size=0;
99         switch (data_type)
100         {
101         case 0x10: // 2bit pixel data
102                 bitstream_init(&bit, data, 2);
103                 while (1)
104                 {
105                         int len=0, col=0;
106                         int code = bitstream_get(&bit);
107                         if (code)
108                         {
109                                 col = code;
110                                 len = 1;
111                         } else
112                         {
113                                 code = bitstream_get(&bit);
114                                 if (!code)
115                                 {
116                                         code = bitstream_get(&bit);
117                                         if (code == 1)
118                                         {
119                                                 col = 0;
120                                                 len = 2;
121                                         } else if (code == 2)
122                                         {
123                                                 len = bitstream_get(&bit) << 2;
124                                                 len |= bitstream_get(&bit);
125                                                 len += 12;
126                                                 col = bitstream_get(&bit);
127                                         } else if (code == 3)
128                                         {
129                                                 len = bitstream_get(&bit) << 6;
130                                                 len |= bitstream_get(&bit) << 4;
131                                                 len |= bitstream_get(&bit) << 2;
132                                                 len |= bitstream_get(&bit);
133                                                 len += 29;
134                                                 col = bitstream_get(&bit);
135                                         } else
136                                                 break;
137                                 } else if (code==1)
138                                 {
139                                         col = 0;
140                                         len = 1;
141                                 } else if (code&2)
142                                 {
143                                         if (code&1)
144                                                 len = 3 + 4 + bitstream_get(&bit);
145                                         else
146                                                 len = 3 + bitstream_get(&bit);
147                                         col = bitstream_get(&bit);
148                                 }
149                         }
150                         while (len && ((*linep) < 720))
151                         {
152                                 line[(*linep)++] = col;
153                                 len--;
154                         }
155                 }
156                 while (bit.avail != 8)
157                         bitstream_get(&bit);
158                 return bit.consumed + 1;
159         case 0x11: // 4bit pixel data
160                 bitstream_init(&bit, data, 4);
161                 while (1)
162                 {
163                         int len=0, col=0;
164                         int code = bitstream_get(&bit);
165                         if (code)
166                         {
167                                 col = code;
168                                 len = 1;
169                         } else
170                         {
171                                 code = bitstream_get(&bit);
172                                 if (!code)
173                                         break;
174                                 else if (code == 0xC)
175                                 {
176                                         col = 0;
177                                         len = 1;
178                                 } else if (code == 0xD)
179                                 {
180                                         col = 0;
181                                         len = 2;
182                                 } else if (code < 8)
183                                 {
184                                         col = 0;
185                                         len = (code & 7) + 2;
186                                 } else if ((code & 0xC) == 0x8)
187                                 {
188                                         col = bitstream_get(&bit);
189                                         len = (code & 3) + 4;
190                                 } else if (code == 0xE)
191                                 {
192                                         len = bitstream_get(&bit) + 9;
193                                         col = bitstream_get(&bit);
194                                 } else if (code == 0xF)
195                                 {
196                                         len  = bitstream_get(&bit) << 4;
197                                         len |= bitstream_get(&bit);
198                                         len += 25;
199                                         col  = bitstream_get(&bit);
200                                 }
201                         }
202                         while (len && ((*linep) < 720))
203                         {
204                                 line[(*linep)++] = col;
205                                 len--;
206                         }
207                 }
208                 while (bit.avail != 8)
209                         bitstream_get(&bit);
210                 return bit.consumed + 1;
211         case 0x12: // 8bit pixel data
212                 bitstream_init(&bit, data, 8);
213                 while(1)
214                 {
215                         int len=0, col=0;
216                         int code = bitstream_get(&bit);
217                         if (code)
218                         {
219                                 col = code;
220                                 len = 1;
221                         } else
222                         {
223                                 code = bitstream_get(&bit);
224                                 if ((code & 0x80) == 0x80)
225                                 {
226                                         len = code&0x7F;
227                                         col = bitstream_get(&bit);
228                                 } else if (code&0x7F)
229                                 {
230                                         len = code&0x7F;
231                                         col = 0;
232                                 } else
233                                         break;
234                         }
235                         while (len && ((*linep) < 720))
236                         {
237                                 line[(*linep)++] = col;
238                                 len--;
239                         }
240                 }
241                 return bit.consumed + 1;
242         case 0x20:  // ignore 2 -> 4bit map table
243                 bitstream_init(&bit, data, 4);
244                 for ( int i=0; i < 4; ++i )
245                         bitstream_get(&bit);
246                 break;
247         case 0x21:  // ignore 2 -> 8bit map table
248                 bitstream_init(&bit, data, 8);
249                 for ( int i=0; i < 4; ++i )
250                         bitstream_get(&bit);
251                 break;
252         case 0x22:  // ignore 4 -> 8bit map table
253                 bitstream_init(&bit, data, 8);
254                 for ( int i=0; i < 16; ++i )
255                         bitstream_get(&bit);
256                 break;
257         case 0xF0:
258                 subtitle_process_line(page, object_id, *linenr, line, *linep);
259 /*              {
260                         int i;
261                         for (i=0; i<720; ++i)
262                                 //eDebugNoNewLine("%d ", line[i]);
263                         //eDebug("");
264                 } */
265                 (*linenr)+=2; // interlaced
266                 *linep = 0;
267 //              //eDebug("[SUB] EOL");
268                 return 1;
269         default:
270                 eDebug("subtitle_process_pixel_data: invalid data_type %02x", data_type);
271                 return -1;
272         }
273         return 0;
274 }
275
276 int eDVBSubtitleParser::subtitle_process_segment(__u8 *segment)
277 {
278         int segment_type, page_id, segment_length, processed_length;
279         if (*segment++ !=  0x0F)
280         {
281                 eDebug("out of sync.");
282                 return -1;
283         }
284         segment_type = *segment++;
285         page_id  = *segment++ << 8;
286         page_id |= *segment++;
287         segment_length  = *segment++ << 8;
288         segment_length |= *segment++;
289         if (segment_type == 0xFF)
290                 return segment_length + 6;
291         if (page_id != m_composition_page_id && page_id != m_ancillary_page_id)
292                 return segment_length + 6;
293         //eDebug("have %d bytes of segment data", segment_length);
294
295         //eDebug("page_id %d, segtype %02x", page_id, segment_type);
296
297         subtitle_page *page, **ppage;
298
299         page = m_pages; ppage = &m_pages;
300
301         while (page)
302         {
303                 if (page->page_id == page_id)
304                         break;
305                 ppage = &page->next;
306                 page = page->next;
307         }
308
309         processed_length = 0;
310
311         switch (segment_type)
312         {
313         case 0x10: // page composition segment
314         {
315                 int page_time_out = *segment++; processed_length++;
316                 int page_version_number = *segment >> 4;
317                 int page_state = (*segment >> 2) & 0x3;
318                 //eDebug("pcs with %d bytes data (%d:%d:%d)", segment_length, page_id, page_version_number, page_state);
319                 segment++;
320                 processed_length++;
321
322                 //eDebug("page time out: %d", page_time_out);
323                 //eDebug("page_version_number: %d" ,page_version_number);
324                 //eDebug("page_state: %d", page_state);
325
326                 if (!page)
327                 {
328                         //eDebug("page not found");
329                         page = new subtitle_page;
330                         page->page_regions = 0;
331                         page->regions = 0;
332                         page->page_id = page_id;
333                         page->cluts = 0;
334                         page->next = 0;
335                         *ppage = page;
336                 } else
337                 {
338                         if (page->pcs_size != segment_length)
339                                 page->page_version_number = -1;
340                                 // if no update, just skip this data.
341                         if (page->page_version_number == page_version_number)
342                         {
343 //                              eDebug("skip data... ");
344                                 break;
345                         }
346                 }
347
348                 page->state = page_state;
349
350                 //eDebug("page updated: old: %d, new: %d", page->page_version_number, page_version_number);
351                         // when acquisition point or mode change: remove all displayed pages.
352                 if ((page_state == 1) || (page_state == 2))
353                 {
354                         while (page->page_regions)
355                         {
356                                 subtitle_page_region *p = page->page_regions->next;
357                                 //eDebug("delete page_region %d", page->page_regions->region_id);
358                                 delete page->page_regions;
359                                 page->page_regions = p;
360                         }
361                         while (page->regions)
362                         {
363                                 subtitle_region *p = page->regions->next;
364                                 //eDebug("delete region %d", page->regions->region_id);
365                                 while(page->regions->region_objects)
366                                 {
367                                         //eDebug("delete region object");
368                                         subtitle_region_object *ob = page->regions->region_objects->next;
369                                         delete page->regions->region_objects;
370                                         page->regions->region_objects = ob;
371                                 }
372                                 delete page->regions;
373                                 page->regions = p;
374                         }
375
376                 }
377
378                 //eDebug("new page.. (%d)", page_state);
379
380                 page->page_time_out = page_time_out;
381
382                 page->page_version_number = page_version_number;
383
384                 subtitle_page_region **r = &page->page_regions;
385
386                 //eDebug("%d  / %d data left", processed_length, segment_length);
387
388                         // go to last entry
389                 while (*r)
390                         r = &(*r)->next;
391
392                 if (processed_length == segment_length && !page->page_regions)
393                 {
394                         //eDebug("no regions in page.. clear screen!!");
395                         subtitle_redraw(page->page_id);
396                 }
397
398                 while (processed_length < segment_length)
399                 {
400                         subtitle_page_region *pr;
401
402                                 // append new entry to list
403                         pr = new subtitle_page_region;
404                         pr->next = 0;
405                         *r = pr;
406                         r = &pr->next;
407
408                         pr->region_id = *segment++; processed_length++;
409                         segment++; processed_length++;
410
411                         pr->region_horizontal_address  = *segment++ << 8;
412                         pr->region_horizontal_address |= *segment++;
413                         processed_length += 2;
414
415                         pr->region_vertical_address  = *segment++ << 8;
416                         pr->region_vertical_address |= *segment++;
417                         processed_length += 2;
418
419                         //eDebug("appended active region");
420                 }
421
422                 if (processed_length != segment_length)
423                         eDebug("%d != %d", processed_length, segment_length);
424                 break;
425         }
426         case 0x11: // region composition segment
427         {
428                 int region_id = *segment++; processed_length++;
429                 int region_version_number = *segment >> 4;
430                 int region_fill_flag = (*segment >> 3) & 1;
431                 segment++; processed_length++;
432
433                         // if we didn't yet received the pcs for this page, drop the region
434                 if (!page)
435                 {
436                         eDebug("ignoring region %x, since page %02x doesn't yet exist.", region_id, page_id);
437                         break;
438                 }
439
440                 subtitle_region *region, **pregion;
441
442                 region = page->regions; pregion = &page->regions;
443
444                 while (region)
445                 {
446                         fflush(stdout);
447                         if (region->region_id == region_id)
448                                 break;
449                         pregion = &region->next;
450                         region = region->next;
451                 }
452
453                 if (!region)
454                 {
455                         //eDebug("create region !!!!!!!!!!");
456                         *pregion = region = new subtitle_region;
457                         region->next = 0;
458                         region->committed = false;
459                 }
460                 else if (region->region_version_number != region_version_number)
461                 {
462                         subtitle_region_object *objects = region->region_objects;
463                         //eDebug("unequal version %p %p", objects, objects?objects->next:objects);
464                         while (objects)
465                         {
466                                 subtitle_region_object *n = objects->next;
467                                 delete objects;
468                                 objects = n;
469                         }
470                         if (region->region_buffer)
471                         {
472                                 //eDebug("no more need of region_buffer %p", &(*region->region_buffer));
473                                 region->region_buffer=0;
474                         }
475                         region->committed = false;
476                 }
477                 else
478                         break;
479
480                 //eDebug("region %d:%d update", page_id, region_id);
481
482                 region->region_id = region_id;
483                 region->region_version_number = region_version_number;
484
485                 region->region_width  = *segment++ << 8;
486                 region->region_width |= *segment++;
487                 processed_length += 2;
488
489                 region->region_height  = *segment++ << 8;
490                 region->region_height |= *segment++;
491                 processed_length += 2;
492
493                 region->region_buffer = new gPixmap(eSize(region->region_width, region->region_height), 8, 1);
494                 memset(region->region_buffer->surface->data, 0, region->region_height * region->region_buffer->surface->stride);
495                 //eDebug("new region_buffer %p", &(*region->region_buffer));
496
497                 int region_level_of_compatibility, region_depth;
498
499                 region_level_of_compatibility = (*segment >> 5) & 7;
500                 region_depth = (*segment++ >> 2) & 7;
501                 region->region_depth = (subtitle_region::depth) region_depth;
502                 processed_length++;
503
504                 int CLUT_id = *segment++; processed_length++;
505
506                 region->clut_id = CLUT_id;
507
508                 int region_8bit_pixel_code, region_4bit_pixel_code, region_2bit_pixel_code;
509                 region_8bit_pixel_code = *segment++; processed_length++;
510                 region_4bit_pixel_code = *segment >> 4;
511                 region_2bit_pixel_code = (*segment++ >> 2) & 3;
512                 processed_length++;
513
514                 if (!region_fill_flag)
515                 {
516                         region_2bit_pixel_code = region_4bit_pixel_code = region_8bit_pixel_code = 0;
517                         region_fill_flag = 1;
518                 }
519
520                 if (region_fill_flag)
521                 {
522                         //eDebug("region fill region_buffer %p", &(*region->region_buffer));
523                         if (region_depth == 1)
524                                 memset(region->region_buffer->surface->data, region_2bit_pixel_code, region->region_height * region->region_width);
525                         else if (region_depth == 2)
526                                 memset(region->region_buffer->surface->data, region_4bit_pixel_code, region->region_height * region->region_width);
527                         else if (region_depth == 3)
528                                 memset(region->region_buffer->surface->data, region_8bit_pixel_code, region->region_height * region->region_width);
529                         else
530                                 eDebug("!!!! invalid depth");
531                 }
532
533                 //eDebug("region %02x, version %d, %dx%d", region->region_id, region->region_version_number, region->region_width, region->region_height);
534
535                 region->region_objects = 0;
536                 subtitle_region_object **pobject = &region->region_objects;
537
538                 while (processed_length < segment_length)
539                 {
540                         subtitle_region_object *object;
541
542                         object = new subtitle_region_object;
543
544                         *pobject = object;
545                         object->next = 0;
546                         pobject = &object->next;
547
548                         object->object_id  = *segment++ << 8;
549                         object->object_id |= *segment++; processed_length += 2;
550
551                         object->object_type = *segment >> 6;
552                         object->object_provider_flag = (*segment >> 4) & 3;
553                         object->object_horizontal_position  = (*segment++ & 0xF) << 8;
554                         object->object_horizontal_position |= *segment++;
555                         processed_length += 2;
556
557                         object->object_vertical_position  = *segment++ << 8;
558                         object->object_vertical_position |= *segment++ ;
559                         processed_length += 2;
560
561                         if ((object->object_type == 1) || (object->object_type == 2))
562                         {
563                                 object->foreground_pixel_value = *segment++;
564                                 object->background_pixel_value = *segment++;
565                                 processed_length += 2;
566                         }
567                 }
568
569                 if (processed_length != segment_length)
570                         eDebug("too less data! (%d < %d)", segment_length, processed_length);
571
572                 break;
573         }
574         case 0x12: // CLUT definition segment
575         {
576                 int CLUT_id, CLUT_version_number;
577                 subtitle_clut *clut, **pclut;
578
579                 if (!page)
580                         break;
581
582                 //eDebug("CLUT: %02x", *segment);
583                 CLUT_id = *segment++;
584
585                 CLUT_version_number = *segment++ >> 4;
586                 processed_length += 2;
587
588                 //eDebug("page %d, CLUT %02x, version %d", page->page_id, CLUT_id, CLUT_version_number);
589
590                 clut = page->cluts; pclut = &page->cluts;
591
592                 while (clut)
593                 {
594                         if (clut->clut_id == CLUT_id)
595                                 break;
596                         pclut = &clut->next;
597                         clut = clut->next;
598                 }
599
600                 if (!clut)
601                 {
602                         *pclut = clut = new subtitle_clut;
603                         clut->next = 0;
604                         clut->clut_id = CLUT_id;
605                 }
606                 else if (clut->CLUT_version_number == CLUT_version_number)
607                         break;
608
609                 clut->CLUT_version_number=CLUT_version_number;
610
611                 memset(clut->entries_2bit, 0, sizeof(clut->entries_2bit));
612                 memset(clut->entries_4bit, 0, sizeof(clut->entries_4bit));
613                 memset(clut->entries_8bit, 0, sizeof(clut->entries_8bit));
614
615                 //eDebug("new clut");
616                 while (processed_length < segment_length)
617                 {
618                         int CLUT_entry_id, entry_CLUT_flag, full_range;
619                         int v_Y, v_Cr, v_Cb, v_T;
620
621                         CLUT_entry_id = *segment++;
622                         full_range = *segment & 1;
623                         entry_CLUT_flag = (*segment++ & 0xE0) >> 5;
624                         processed_length += 2;
625
626                         if (full_range)
627                         {
628                                 v_Y  = *segment++;
629                                 v_Cr = *segment++;
630                                 v_Cb = *segment++;
631                                 v_T  = *segment++;
632                                 processed_length += 4;
633                         } else
634                         {
635                                 v_Y   = *segment & 0xFC;
636                                 v_Cr  = (*segment++ & 3) << 6;
637                                 v_Cr |= (*segment & 0xC0) >> 2;
638                                 v_Cb  = (*segment & 0x3C) << 2;
639                                 v_T   = (*segment++ & 3) << 6;
640                                 processed_length += 2;
641                         }
642
643                         if (entry_CLUT_flag & 1) // 8bit
644                         {
645                                 ASSERT(CLUT_entry_id < 256);
646                                 clut->entries_8bit[CLUT_entry_id].Y = v_Y;
647                                 clut->entries_8bit[CLUT_entry_id].Cr = v_Cr;
648                                 clut->entries_8bit[CLUT_entry_id].Cb = v_Cb;
649                                 clut->entries_8bit[CLUT_entry_id].T = v_T;
650                                 clut->entries_8bit[CLUT_entry_id].valid = 1;
651                         }
652                         if (entry_CLUT_flag & 2) // 4bit
653                         {
654                                 ASSERT(CLUT_entry_id < 16);
655                                 clut->entries_4bit[CLUT_entry_id].Y = v_Y;
656                                 clut->entries_4bit[CLUT_entry_id].Cr = v_Cr;
657                                 clut->entries_4bit[CLUT_entry_id].Cb = v_Cb;
658                                 clut->entries_4bit[CLUT_entry_id].T = v_T;
659                                 clut->entries_4bit[CLUT_entry_id].valid = 1;
660                         }
661                         if (entry_CLUT_flag & 4) // 2bit
662                         {
663                                 ASSERT(CLUT_entry_id < 4);
664                                 clut->entries_2bit[CLUT_entry_id].Y = v_Y;
665                                 clut->entries_2bit[CLUT_entry_id].Cr = v_Cr;
666                                 clut->entries_2bit[CLUT_entry_id].Cb = v_Cb;
667                                 clut->entries_2bit[CLUT_entry_id].T = v_T;
668                                 clut->entries_2bit[CLUT_entry_id].valid = 1;
669                         }
670                         //eDebug("  %04x %02x %02x %02x %02x", CLUT_entry_id, v_Y, v_Cb, v_Cr, v_T);
671                 }
672                 break;
673         }
674         case 0x13: // object data segment
675         {
676                 int object_id, object_version_number, object_coding_method, non_modifying_color_flag;
677
678                 object_id  = *segment++ << 8;
679                 object_id |= *segment++;
680                 processed_length += 2;
681
682                 object_version_number = *segment >> 4;
683                 object_coding_method  = (*segment >> 2) & 3;
684                 non_modifying_color_flag = (*segment++ >> 1) & 1;
685                 processed_length++;
686
687                 //eDebug("object id %04x, version %d, object_coding_method %d (page_id %d)", object_id, object_version_number, object_coding_method, page_id);
688
689                 if (object_coding_method == 0)
690                 {
691                         int top_field_data_blocklength, bottom_field_data_blocklength;
692                         int i, line, linep;
693
694                         top_field_data_blocklength  = *segment++ << 8;
695                         top_field_data_blocklength |= *segment++;
696
697                         bottom_field_data_blocklength  = *segment++ << 8;
698                         bottom_field_data_blocklength |= *segment++;
699                         eDebug("%d / %d bytes", top_field_data_blocklength, bottom_field_data_blocklength);
700                         processed_length += 4;
701
702                         i = 0;
703                         line = 0;
704                         linep = 0;
705                         while (i < top_field_data_blocklength)
706                         {
707                                 int len;
708                                 len = subtitle_process_pixel_data(page, object_id, &line, &linep, segment);
709                                 if (len < 0)
710                                         return -1;
711                                 segment += len;
712                                 processed_length += len;
713                                 i += len;
714                         }
715
716                         line = 1;
717                         linep = 0;
718
719                         if (bottom_field_data_blocklength)
720                         {
721                                 i = 0;
722                                 while (i < bottom_field_data_blocklength)
723                                 {
724                                         int len;
725                                         len = subtitle_process_pixel_data(page, object_id, &line, &linep, segment);
726                                         if (len < 0)
727                                                 return -1;
728                                         segment += len;
729                                         processed_length += len;
730                                         i += len;
731                                 }
732                         }
733                         else if (top_field_data_blocklength)
734                                 eDebug("!!!! unimplemented: no bottom field! (%d : %d)", top_field_data_blocklength, bottom_field_data_blocklength);
735
736                         if ((top_field_data_blocklength + bottom_field_data_blocklength) & 1)
737                         {
738                                 segment++; processed_length++;
739                         }
740                 }
741                 else if (object_coding_method == 1)
742                         eDebug("---- object_coding_method 1 unsupported!");
743
744                 break;
745         }
746         case 0x80: // end of display set segment
747         {
748                 //eDebug("end of display set segment");
749                 subtitle_redraw_all();
750         }
751         case 0xFF: // stuffing
752                 break;
753         default:
754                 eDebug("unhandled segment type %02x", segment_type);
755         }
756
757         return segment_length + 6;
758 }
759
760 void eDVBSubtitleParser::subtitle_process_pes(__u8 *pkt, int len)
761 {
762         eDebugNoNewLine("subtitle_process_pes");
763         if (!extract_pts(m_show_time, pkt))
764         {
765                 eDebug(" %lld", m_show_time);
766                 pkt += 6; len -= 6;
767                 // skip PES header
768                 pkt++; len--;
769                 pkt++; len--;
770
771                 int hdr_len = *pkt++; len--;
772
773                 pkt+=hdr_len; len-=hdr_len;
774
775                 if (*pkt != 0x20)
776                 {
777                         //eDebug("data identifier is 0x%02x, but not 0x20", *pkt);
778                         return;
779                 }
780                 pkt++; len--; // data identifier
781                 *pkt++; len--; // stream id;
782
783                 if (len <= 0)
784                 {
785                         //eDebug("no data left (%d)", len);
786                         return;
787                 }
788
789                 while (len && *pkt == 0x0F)
790                 {
791                         int l = subtitle_process_segment(pkt);
792                         if (l < 0)
793                                 break;
794                         pkt += l;
795                         len -= l;
796                 }
797                 if (len && *pkt != 0xFF)
798                         eDebug("strange data at the end");
799         }
800         else
801                 eDebug("\ndvb subtitle packet without PTS.. ignore!!");
802 }
803
804 void eDVBSubtitleParser::subtitle_redraw_all()
805 {
806 #if 1
807         subtitle_page *page = m_pages;
808         while(page)
809         {
810                 if (page->state != 0)
811                         subtitle_redraw(page->page_id);
812                 page = page->next;
813         }
814 #else
815         subtitle_page *page = m_pages;
816         eDebug("----------- end of display set");
817         eDebug("active pages:");
818         while (page)
819         {
820                 eDebug("  page_id %02x", page->page_id);
821                 eDebug("  page_version_number: %d", page->page_version_number);
822                 eDebug("  active regions:");
823                 {
824                         subtitle_page_region *region = page->page_regions;
825                         while (region)
826                         {
827                                 eDebug("    region_id: %04x", region->region_id);
828                                 eDebug("    region_horizontal_address: %d", region->region_horizontal_address);
829                                 eDebug("    region_vertical_address: %d", region->region_vertical_address);
830
831                                 region = region->next;
832                         }
833                 }
834
835                 subtitle_redraw(page->page_id);
836                 eDebug("defined regions:");
837                 subtitle_region *region = page->regions;
838                 while (region)
839                 {
840                         eDebug("  region_id %04x, version %d, %dx%d", region->region_id, region->region_version_number, region->region_width, region->region_height);
841
842                         subtitle_region_object *object = region->region_objects;
843                         while (object)
844                         {
845                                 eDebug("  object %02x, type %d, %d:%d", object->object_id, object->object_type, object->object_horizontal_position, object->object_vertical_position);
846                                 object = object->next;
847                         }
848                         region = region->next;
849                 }
850                 page = page->next;
851         }
852 #endif
853 }
854
855 void eDVBSubtitleParser::subtitle_reset()
856 {
857         while (subtitle_page *page = m_pages)
858         {
859                         /* free page regions */
860                 while (page->page_regions)
861                 {
862                         subtitle_page_region *p = page->page_regions->next;
863                         delete page->page_regions;
864                         page->page_regions = p;
865                 }
866                         /* free regions */
867                 while (page->regions)
868                 {
869                         subtitle_region *region = page->regions;
870
871                         while (region->region_objects)
872                         {
873                                 subtitle_region_object *obj = region->region_objects;
874                                 region->region_objects = obj->next;
875                                 delete obj;
876                         }
877
878                         if (region->region_buffer)
879                         {
880 //                              eDebug("no more need of region_buffer 2 %p", &(*region->region_buffer));
881                                 region->region_buffer=0;
882                         }
883
884                         page->regions = region->next;
885                         delete region;
886                 }
887
888                         /* free CLUTs */
889                 while (page->cluts)
890                 {
891                         subtitle_clut *clut = page->cluts;
892                         page->cluts = clut->next;
893                         delete clut;
894                 }
895
896                 m_pages = page->next;
897                 delete page;
898         }
899 }
900
901 void eDVBSubtitleParser::subtitle_redraw(int page_id)
902 {
903         subtitle_page *page = m_pages;
904
905 //      eDebug("displaying page id %d", page_id);
906
907         while (page)
908         {
909                 if (page->page_id == page_id)
910                         break;
911                 page = page->next;
912         }
913         if (!page)
914         {
915                 //eDebug("page not found");
916                 return;
917         }
918
919         //eDebug("iterating regions..");
920                 /* iterate all regions in this pcs */
921         subtitle_page_region *region = page->page_regions;
922
923         eDVBSubtitlePage Page;
924         Page.m_show_time = m_show_time;
925         for (; region; region=region->next)
926         {
927 //              eDebug("region %d", region->region_id);
928                         /* find corresponding region */
929                 subtitle_region *reg = page->regions;
930                 while (reg)
931                 {
932                         if (reg->region_id == region->region_id)
933                                 break;
934                         reg = reg->next;
935                 }
936                 if (reg)
937                 {
938                         if (reg->committed)
939                                 continue;
940 //                      eDebug("copy region %d to %d, %d", region->region_id, region->region_horizontal_address, region->region_vertical_address);
941
942                         int x0 = region->region_horizontal_address;
943                         int y0 = region->region_vertical_address;
944
945                         if ((x0 < 0) || (y0 < 0))
946                         {
947 //                              eDebug("x0 %d, y0 %d",
948 //                                      x0, y0);
949                                 continue;
950                         }
951
952                         /* find corresponding clut */
953                         subtitle_clut *clut = page->cluts;
954                         while (clut)
955                         {
956                         //eDebug("have %d, want %d", clut->clut_id, main_clut_id);
957                                 if (clut->clut_id == reg->clut_id)
958                                         break;
959                                 clut = clut->next;
960                         }
961
962                         int clut_size = reg->region_buffer->surface->clut.colors = reg->region_depth == subtitle_region::bpp2 ?
963                                 4 : reg->region_depth == subtitle_region::bpp4 ? 16 : 256;
964
965                         reg->region_buffer->surface->clut.data = new gRGB[clut_size];
966 //                      eDebug("create clut data for region_buffer %p", &(*reg->region_buffer));
967
968                         gRGB *palette = reg->region_buffer->surface->clut.data;
969
970                         subtitle_clut_entry *entries=0;
971                         switch(reg->region_depth)
972                         {
973                                 case subtitle_region::bpp2:
974 //                                      eDebug("2BPP");
975                                         entries = clut->entries_2bit;
976                                         memset(palette, 0, 4*sizeof(gRGB));
977                                         palette[0].a = 0xFF;
978                                         palette[2].r = palette[2].g = palette[2].b = 0xFF;
979                                         palette[3].r = palette[3].g = palette[3].b = 0x80;
980                                         break;
981                                 case subtitle_region::bpp4:
982 //                                      eDebug("4BPP");
983                                         entries = clut->entries_4bit;
984                                         memset(palette, 0, 16*sizeof(gRGB));
985                                         for (int i=0; i < 16; ++i)
986                                         {
987                                                 if (!i)
988                                                         palette[i].a = 0xFF;
989                                                 else if (i & 1)
990                                                 {
991                                                         if (i & 8)
992                                                                 palette[i].r = 0x80;
993                                                         if (i & 4)
994                                                                 palette[i].g = 0x80;
995                                                         if (i & 2)
996                                                                 palette[i].b = 0x80;
997                                                 }
998                                                 else
999                                                 {
1000                                                         if (i & 8)
1001                                                                 palette[i].r = 0xFF;
1002                                                         if (i & 4)
1003                                                                 palette[i].g = 0xFF;
1004                                                         if (i & 2)
1005                                                                 palette[i].b = 0xFF;
1006                                                 }
1007                                         }
1008                                         break;
1009                                 case subtitle_region::bpp8:
1010 //                                      eDebug("8BPP");
1011                                         entries = clut->entries_8bit;
1012                                         memset(palette, 0, 16*sizeof(gRGB));
1013                                         for (int i=0; i < 256; ++i)
1014                                         {
1015                                                 switch (i & 17)
1016                                                 {
1017                                                 case 0: // b1 == 0 && b5 == 0
1018                                                         if (!(i & 14)) // b2 == 0 && b3 == 0 && b4 == 0
1019                                                         {
1020                                                                 if (!(i & 224)) // b6 == 0 && b7 == 0 && b8 == 0
1021                                                                         palette[i].a = 0xFF;
1022                                                                 else
1023                                                                 {
1024                                                                         if (i & 128) // R = 100% x b8
1025                                                                                 palette[i].r = 0xFF;
1026                                                                         if (i & 64) // G = 100% x b7
1027                                                                                 palette[i].g = 0xFF;
1028                                                                         if (i & 32) // B = 100% x b6
1029                                                                                 palette[i].b = 0xFF;
1030                                                                         palette[i].a = 0xBF; // T = 75%
1031                                                                 }
1032                                                                 break;
1033                                                         }
1034                                                         // fallthrough !!
1035                                                 case 16: // b1 == 0 && b5 == 1
1036                                                         if (i & 128) // R = 33% x b8
1037                                                                 palette[i].r = 0x55;
1038                                                         if (i & 64) // G = 33% x b7
1039                                                                 palette[i].g = 0x55;
1040                                                         if (i & 32) // B = 33% x b6
1041                                                                 palette[i].b = 0x55;
1042                                                         if (i & 8) // R + 66,7% x b4
1043                                                                 palette[i].r += 0xAA;
1044                                                         if (i & 4) // G + 66,7% x b3
1045                                                                 palette[i].g += 0xAA;
1046                                                         if (i & 2) // B + 66,7% x b2
1047                                                                 palette[i].b += 0xAA;
1048                                                         if (i & 16) // needed for fall through from case 0!!
1049                                                                 palette[i].a = 0x80; // T = 50%
1050                                                         break;
1051                                                 case 1: // b1 == 1 && b5 == 0
1052                                                         palette[i].r =
1053                                                         palette[i].g =
1054                                                         palette[i].b = 0x80; // 50%
1055                                                         // fall through!!
1056                                                 case 17: // b1 == 1 && b5 == 1
1057                                                         if (i & 128) // R += 16.7% x b8
1058                                                                 palette[i].r += 0x2A;
1059                                                         if (i & 64) // G += 16.7% x b7
1060                                                                 palette[i].g += 0x2A;
1061                                                         if (i & 32) // B += 16.7% x b6
1062                                                                 palette[i].b += 0x2A;
1063                                                         if (i & 8) // R += 33% x b4
1064                                                                 palette[i].r += 0x55;
1065                                                         if (i & 4) // G += 33% x b3
1066                                                                 palette[i].g += 0x55;
1067                                                         if (i & 2) // B += 33% x b2
1068                                                                 palette[i].b += 0x55;
1069                                                         break;
1070                                                 }
1071                                         }
1072                                         break;
1073                         }
1074
1075                         if (clut)
1076                         {
1077                                 for (int i=0; i<clut_size; ++i)
1078                                 {
1079                                         if (entries[i].valid)
1080                                         {
1081                                                 int y = entries[i].Y,
1082                                                         cr = entries[i].Cr,
1083                                                         cb = entries[i].Cb;
1084                                                 if (y > 0)
1085                                                 {
1086                                                         y -= 16;
1087                                                         cr -= 128;
1088                                                         cb -= 128;
1089                                                         palette[i].r = MAX(MIN(((298 * y            + 460 * cr) / 256), 255), 0);
1090                                                         palette[i].g = MAX(MIN(((298 * y -  55 * cb - 137 * cr) / 256), 255), 0);
1091                                                         palette[i].b = MAX(MIN(((298 * y + 543 * cb           ) / 256), 255), 0);
1092                                                         palette[i].a = (entries[i].T) & 0xFF;
1093 //                                                      eDebug("override clut entry %d RGBA %02x%02x%02x%02x", i,
1094 //                                                              palette[i].r, palette[i].g, palette[i].b, palette[i].a);
1095                                                 }
1096                                                 else
1097                                                 {
1098 //                                                      eDebug("mist %d", i);
1099                                                         palette[i].r = 0;
1100                                                         palette[i].g = 0;
1101                                                         palette[i].b = 0;
1102                                                         palette[i].a = 0xFF;
1103                                                 }
1104                                         }
1105                                 }
1106                         }
1107
1108 //                      eDebug("commit region_buffer %p", &(*reg->region_buffer));
1109                         eDVBSubtitleRegion Region;
1110                         Region.m_pixmap = reg->region_buffer;
1111                         Region.m_position.setX(x0);
1112                         Region.m_position.setY(y0);
1113                         Page.m_regions.push_back(Region);
1114                         reg->committed = true;
1115                 }
1116                 else
1117                         eDebug("region not found");
1118         }
1119         m_new_subtitle_page(Page);
1120         Page.m_regions.clear();
1121 //      eDebug("page timeout is %d", page->page_time_out);
1122 //      Page.m_show_time += (page->page_time_out * 90000);
1123 //      m_new_subtitle_page(Page);
1124         //eDebug("schon gut.");
1125 }
1126
1127 DEFINE_REF(eDVBSubtitleParser);
1128
1129 eDVBSubtitleParser::eDVBSubtitleParser(iDVBDemux *demux)
1130         :m_pages(0)
1131 {
1132         setStreamID(0xBD);
1133
1134         if (demux->createPESReader(eApp, m_pes_reader))
1135                 eDebug("failed to create dvb subtitle PES reader!");
1136         else
1137                 m_pes_reader->connectRead(slot(*this, &eDVBSubtitleParser::processData), m_read_connection);
1138 }
1139
1140 eDVBSubtitleParser::~eDVBSubtitleParser()
1141 {
1142         subtitle_reset();
1143 }
1144
1145 int eDVBSubtitleParser::stop()
1146 {
1147         if (m_pes_reader)
1148         {
1149                 eDebug("disable dvb subtitles");
1150                 return m_pes_reader->stop();
1151         }
1152         return -1;
1153 }
1154
1155 int eDVBSubtitleParser::start(int pid, int composition_page_id, int ancillary_page_id)
1156 {
1157         if (m_pes_reader)
1158         {
1159                 eDebug("start dvb subtitles on pid 0x%04x with composition_page_id %d and ancillary_page_id %d",
1160                         pid, composition_page_id, ancillary_page_id);
1161                 m_composition_page_id = composition_page_id;
1162                 m_ancillary_page_id = ancillary_page_id;
1163                 return m_pes_reader->start(pid);
1164         }
1165         return -1;
1166 }
1167
1168 void eDVBSubtitleParser::connectNewPage(const Slot1<void, const eDVBSubtitlePage&> &slot, ePtr<eConnection> &connection)
1169 {
1170         connection = new eConnection(this, m_new_subtitle_page.connect(slot));
1171 }