]> git.vomp.tv Git - vompclient-marten.git/blob - dvbsubtitles.cc
Apply JTE subtitles patch for not destroying OSD
[vompclient-marten.git] / dvbsubtitles.cc
1 /*
2     Copyright 2008 Mark Calderbank
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software Foundation, Inc.,
18     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20 /*  Sections of code and general methods adopted from VDR version 1.6.0
21  *  dvbsubtitle.c (GPL version 2 or later)
22  *  Original author: Marco Schluessler <marco@lordzodiac.de>
23  *  With some input from the "subtitle plugin"
24  *  by Pekka Virtanen <pekka.virtanen@sci.fi>
25 */
26
27 /*  Reference ETSI EN 300 743 V1.3.1 (2006-11) */
28
29 #include "dvbsubtitles.h"
30 #include "demuxer.h"
31 #include "osdreceiver.h"
32 #include "video.h"
33 #include "log.h"
34
35 // --- cTimeMs ---------------------------------------------------------------
36 // Borrowed from the vdr tools
37
38 cTimeMs::cTimeMs(int Ms)
39 {
40   if (Ms >= 0)
41      Set(Ms);
42   else
43      begin = 0;
44      isFirstCheck = false;
45 }
46
47 uint64_t cTimeMs::Now(void)
48 {
49   struct timespec tp;
50 #ifndef WIN32
51   if (clock_gettime(CLOCK_REALTIME, &tp) == 0)
52     return (uint64_t(tp.tv_sec)) * 1000 + tp.tv_nsec / 1000000;
53   else
54     Log::getInstance()->log("SUBTITLES", Log::DEBUG, "cTimeMs: clock_gettime(CLOCK_REALTIME) failed");
55
56 #else
57   SYSTEMTIME systime;
58    __int64  filetime;
59    __int64  test;
60   GetSystemTime(&systime);
61   SystemTimeToFileTime(&systime,(FILETIME*)&filetime);
62   tp.tv_sec=(filetime-WINDOWS_TIME_BASE_OFFSET)/(10*1000*1000);
63   tp.tv_nsec=((filetime-WINDOWS_TIME_BASE_OFFSET)%(10*1000*1000))*100;
64   return (uint64_t(tp.tv_sec)) * 1000 + tp.tv_nsec / 1000000;
65 #endif
66 }
67
68 void cTimeMs::Set(int Ms)
69 {
70   isFirstCheck = true; // Timer set, the first check can be done once
71   begin = Now() + Ms;
72 }
73
74 bool cTimeMs::TimedOut(void)
75 {
76   if (isFirstCheck && (Now() >= begin))
77   {
78     isFirstCheck = false; // Timer timed out & the first check is done
79     return true;
80   }
81   else
82     return false;
83 }
84
85 uint64_t cTimeMs::Elapsed(void)
86 {
87   return Now() - begin;
88 }
89
90 cTimeMs SubtitleTimeout;
91 //-------- End of cTimeMs borrowed from the vdr tools --------
92
93 DVBSubtitleCLUT::DVBSubtitleCLUT()
94 : version(0xFF),
95   palette2(2),
96   palette4(4),
97   palette8(8)
98 {
99   for (int i = 0; i < 4; ++i) palette2.setColour(i, defaultPalette2[i]);
100   for (int i = 0; i < 16; ++i) palette4.setColour(i, defaultPalette4[i]);
101   for (int i = 0; i < 256; ++i) palette8.setColour(i, defaultPalette8[i]);
102 }
103
104 const ULONG DVBSubtitleCLUT::defaultPalette2[4] = {
105   0x00000000, 0xFFFFFFFF, 0xFF000000, 0xFF808080
106 };
107
108 const ULONG DVBSubtitleCLUT::defaultPalette4[16] = {
109   0x00000000, 0xFFFF0000, 0xFF00FF00, 0xFFFFFF00,
110   0xFF0000FF, 0xFFFF00FF, 0xFF00FFFF, 0xFFFFFFFF,
111   0xFF000000, 0xFF800000, 0xFF008000, 0xFF808000,
112   0xFF000080, 0xFF800080, 0xFF008080, 0xFF808080
113 };
114
115 const ULONG DVBSubtitleCLUT::defaultPalette8[256] = {
116   0x00000000, 0x40FF0000, 0x4000FF00, 0x40FFFF00, // 0000 0000
117   0x400000FF, 0x40FF00FF, 0x4000FFFF, 0x40FFFFFF, // 0000 0100
118   0x80000000, 0x80550000, 0x80005500, 0x80555500, // 0000 1000
119   0x80000055, 0x80550055, 0x80005555, 0x80555555, // 0000 1100
120   0xFFAA0000, 0xFFFF0000, 0xFFAA5500, 0xFFFF5500, // 0001 0000
121   0xFFAA0055, 0xFFFF0055, 0xFFAA5555, 0xFFFF5555, // 0001 0100
122   0x80AA0000, 0x80FF0000, 0x80AA5500, 0x80FF5500, // 0001 1000
123   0x80AA0055, 0x80FF0055, 0x80AA5555, 0x80FF5555, // 0001 1100
124   0xFF00AA00, 0xFF55AA00, 0xFF00FF00, 0xFF55FF00, // 0010 0000
125   0xFF00AA55, 0xFF55AA55, 0xFF00FF55, 0xFF55FF55, // 0010 0100
126   0x8000AA00, 0x8055AA00, 0x8000FF00, 0x8055FF00, // 0010 1000
127   0x8000AA55, 0x8055AA55, 0x8000FF55, 0x8055FF55, // 0010 1100
128   0xFFAAAA00, 0xFFFFAA00, 0xFFAAFF00, 0xFFFFFF00, // 0011 0000
129   0xFFAAAA55, 0xFFFFAA55, 0xFFAAFF55, 0xFFFFFF55, // 0011 0100
130   0x80AAAA00, 0x80FFAA00, 0x80AAFF00, 0x80FFFF00, // 0011 1000
131   0x80AAAA55, 0x80FFAA55, 0x80AAFF55, 0x80FFFF55, // 0011 1100
132   0xFF0000AA, 0xFF5500AA, 0xFF0055AA, 0xFF5555AA, // 0100 0000
133   0xFF0000FF, 0xFF5500FF, 0xFF0055FF, 0xFF5555FF, // 0100 0100
134   0x800000AA, 0x805500AA, 0x800055AA, 0x805555AA, // 0100 1000
135   0x800000FF, 0x805500FF, 0x800055FF, 0x805555FF, // 0100 1100
136   0xFFAA00AA, 0xFFFF00AA, 0xFFAA55AA, 0xFFFF55AA, // 0101 0000
137   0xFFAA00FF, 0xFFFF00FF, 0xFFAA55FF, 0xFFFF55FF, // 0101 0100
138   0x80AA00AA, 0x80FF00AA, 0x80AA55AA, 0x80FF55AA, // 0101 1000
139   0x80AA00FF, 0x80FF00FF, 0x80AA55FF, 0x80FF55FF, // 0101 1100
140   0xFF00AAAA, 0xFF55AAAA, 0xFF00FFAA, 0xFF55FFAA, // 0110 0000
141   0xFF00AAFF, 0xFF55AAFF, 0xFF00FFFF, 0xFF55FFFF, // 0110 0100
142   0x8000AAAA, 0x8055AAAA, 0x8000FFAA, 0x8055FFAA, // 0110 1000
143   0x8000AAFF, 0x8055AAFF, 0x8000FFFF, 0x8055FFFF, // 0110 1100
144   0xFFAAAAAA, 0xFFFFAAAA, 0xFFAAFFAA, 0xFFFFFFAA, // 0111 0000
145   0xFFAAAAFF, 0xFFFFAAFF, 0xFFAAFFFF, 0xFFFFFFFF, // 0111 0100
146   0x80AAAAAA, 0x80FFAAAA, 0x80AAFFAA, 0x80FFFFAA, // 0111 1000
147   0x80AAAAFF, 0x80FFAAFF, 0x80AAFFFF, 0x80FFFFFF, // 0111 1100
148   0xFF808080, 0xFFAA8080, 0xFF80AA80, 0xFFAAAA80, // 1000 0000
149   0xFF8080AA, 0xFFAA80AA, 0xFF80AAAA, 0xFFAAAAAA, // 1000 0100
150   0xFF000000, 0xFF2A0000, 0xFF002A00, 0xFF2A2A00, // 1000 1000
151   0xFF00002A, 0xFF2A002A, 0xFF002A2A, 0xFF2A2A2A, // 1000 1100
152   0xFFD58080, 0xFFFF8080, 0xFFD5AA80, 0xFFFFAA80, // 1001 0000
153   0xFFD580AA, 0xFFFF80AA, 0xFFD5AAAA, 0xFFFFAAAA, // 1001 0100
154   0xFF550000, 0xFF7F0000, 0xFF552A00, 0xFF7F2A00, // 1001 1000
155   0xFF55002A, 0xFF7F002A, 0xFF552A2A, 0xFF7F2A2A, // 1001 1100
156   0xFF80D580, 0xFFAAD580, 0xFF80FF80, 0xFFAAFF80, // 1010 0000
157   0xFF80D5AA, 0xFFAAD5AA, 0xFF80FFAA, 0xFFAAFFAA, // 1010 0100
158   0xFF005500, 0xFF2A5500, 0xFF007F00, 0xFF2A7F00, // 1010 1000
159   0xFF00552A, 0xFF2A552A, 0xFF007F2A, 0xFF2A7F2A, // 1010 1100
160   0xFFD5D580, 0xFFFFD580, 0xFFD5FF80, 0xFFFFFF80, // 1011 0000
161   0xFFD5D5AA, 0xFFFFD5AA, 0xFFD5FFAA, 0xFFFFFFAA, // 1011 0100
162   0xFF555500, 0xFF7F5500, 0xFF557F00, 0xFF7F7F00, // 1011 1000
163   0xFF55552A, 0xFF7F552A, 0xFF557F2A, 0xFF7F7F2A, // 1011 1100
164   0xFF8080D5, 0xFFAA80D5, 0xFF80AAD5, 0xFFAAAAD5, // 1100 0000
165   0xFF8080FF, 0xFFAA80FF, 0xFF80AAFF, 0xFFAAAAFF, // 1100 0100
166   0xFF000055, 0xFF2A0055, 0xFF002A55, 0xFF2A2A55, // 1100 1000
167   0xFF00007F, 0xFF2A007F, 0xFF002A7F, 0xFF2A2A7F, // 1100 1100
168   0xFFD580D5, 0xFFFF80D5, 0xFFD5AAD5, 0xFFFFAAD5, // 1101 0000
169   0xFFD580FF, 0xFFFF80FF, 0xFFD5AAFF, 0xFFFFAAFF, // 1101 0100
170   0xFF550055, 0xFF7F0055, 0xFF552A55, 0xFF7F2A55, // 1101 1000
171   0xFF55007F, 0xFF7F007F, 0xFF552A7F, 0xFF7F2A7F, // 1101 1100
172   0xFF80D5D5, 0xFFAAD5D5, 0xFF80FFD5, 0xFFAAFFD5, // 1110 0000
173   0xFF80D5FF, 0xFFAAD5FF, 0xFF80FFFF, 0xFFAAFFFF, // 1110 0100
174   0xFF005555, 0xFF2A5555, 0xFF007F55, 0xFF2A7F55, // 1110 1000
175   0xFF00557F, 0xFF2A557F, 0xFF007F7F, 0xFF2A7F7F, // 1110 1100
176   0xFFD5D5D5, 0xFFFFD5D5, 0xFFD5FFD5, 0xFFFFFFD5, // 1111 0000
177   0xFFD5D5FF, 0xFFFFD5FF, 0xFFD5FFFF, 0xFFFFFFFF, // 1111 0100
178   0xFF555555, 0xFF7F5555, 0xFF557F55, 0xFF7F7F55, // 1111 1000
179   0xFF55557F, 0xFF7F557F, 0xFF557F7F, 0xFF7F7F7F, // 1111 1100
180 };
181
182 void DVBSubtitleCLUT::setEntry(int bpp, UINT index, UCHAR Y, UCHAR Cr, UCHAR Cb, UCHAR T)
183 {
184   UCHAR Y2 = Y;
185   UCHAR A;
186   if (Y2 == 0) { Y2 = 16; A = 0; } else A = 255 - T;
187   switch (bpp)
188   {
189     case 2: palette2.setYCrCbA(index, Y2, Cr, Cb, A); break;
190     case 4: palette4.setYCrCbA(index, Y2, Cr, Cb, A); break;
191     case 8: palette8.setYCrCbA(index, Y2, Cr, Cb, A); break;
192   }
193 }
194
195 const Palette& DVBSubtitleCLUT::getPalette(int bpp) const
196 {
197   switch (bpp)
198   {
199     case 2: return palette2; break;
200     case 4: return palette4; break;
201     default: return palette8; break;
202   }
203 }
204
205 DVBSubtitleRegion::DVBSubtitleRegion()
206 : version(0xFF),
207   level(0),
208   CLUTid(0)
209 {}
210
211 void DVBSubtitleRegion::setDepth(UINT d)
212 {
213   if (d < 4) palette.setBpp(1 << d);
214 }
215
216 DVBSubtitlePage::DVBSubtitlePage()
217 : pts(0),
218   dirty(false),
219   version(0xFF),
220   timeout(0),
221   state(0),
222   serviceAcquired(false)
223 {}
224
225 void DVBSubtitlePage::setState(UCHAR s)
226 {
227   state = s;
228   if (state == 1) // Acquisition point - page refresh
229   if (!serviceAcquired) // Service not acquired lets treat this as mode change
230      state=2;
231   if (state == 2) // Mode change - new epoch
232   {
233     serviceAcquired = true;
234     dirty = true;
235     regions.clear();
236     currentDisplay.clear();
237     pendingDisplay.clear();
238     CLUTs.clear();
239   }
240 }
241
242 void DVBSubtitlePage::updateRegionPalettes(const DVBSubtitleCLUT& clut)
243 {
244   RegionMap::iterator region;
245   for (region = regions.begin(); region != regions.end(); ++region)
246     if (region->second.CLUTid == clut.CLUTid)
247       region->second.palette = clut.getPalette(region->second.palette.getBpp());
248 }
249
250 DVBSubtitleDisplayDefinition::DVBSubtitleDisplayDefinition()
251 {
252         version=0xFF;
253         displaywindow=false;
254 }
255
256 class DVBSubtitleObject
257 {
258   private:
259     UINT objectID;
260     UCHAR nonModColourFlag;
261     struct RegionRef
262     {
263       DVBSubtitleRegion* region;
264       UINT horizontalPosition;
265       UINT verticalPosition;
266     };
267     typedef std::vector<struct RegionRef> UseList;
268     UseList useList;
269     UCHAR map2to4[4];
270     UCHAR map2to8[4];
271     UCHAR map4to8[16];
272     void initMapTables();
273     UCHAR* currentMapTable;
274     UINT bitPos;
275     void drawLine(const RegionRef& use, UINT x, UINT y, UCHAR colour, UINT len);
276     UCHAR get2Bits(const UCHAR* data, UINT& index);
277     UCHAR get4Bits(const UCHAR* data, UINT& index);
278     bool decode2BppCodeString(const UCHAR* data, UINT& index, const struct RegionRef& use, UINT& x, UINT y);
279     bool decode4BppCodeString(const UCHAR* data, UINT& index, const struct RegionRef& use, UINT& x, UINT y);
280     bool decode8BppCodeString(const UCHAR* data, UINT& index, const struct RegionRef& use, UINT& x, UINT y);
281   public:
282     DVBSubtitleObject(UINT id = 0);
283     void setNonModColourFlag(UCHAR flag) { nonModColourFlag = flag; }
284     void findWhereUsed(DVBSubtitlePage&);
285     void decodeSubBlock(const UCHAR* data, UINT length, bool even);
286 };
287
288 DVBSubtitleObject::DVBSubtitleObject(UINT id)
289 : objectID(id),
290   nonModColourFlag(0),
291   currentMapTable(NULL),
292   bitPos(0)
293 {
294   initMapTables();
295 }
296
297 void DVBSubtitleObject::initMapTables()
298 {
299   map2to4[0] = 0x0; map2to4[1] = 0x7; map2to4[2] = 0x8; map2to4[3] = 0xF;
300   map2to8[0] = 0x00; map2to8[1] = 0x77; map2to8[2] = 0x88; map2to8[3] = 0xFF;
301   map4to8[0] = 0x00; map4to8[1] = 0x11; map4to8[2] = 0x22; map4to8[3] = 0x33;
302   map4to8[4] = 0x44; map4to8[5] = 0x55; map4to8[6] = 0x66; map4to8[7] = 0x77;
303   map4to8[8] = 0x88; map4to8[9] = 0x99; map4to8[10]= 0xAA; map4to8[11]= 0xBB;
304   map4to8[12]= 0xCC; map4to8[13]= 0xDD; map4to8[14]= 0xEE; map4to8[15]= 0xFF;
305 }
306
307 void DVBSubtitleObject::findWhereUsed(DVBSubtitlePage& page)
308 {
309   useList.clear();
310   DVBSubtitlePage::RegionMap::iterator i;
311   for (i = page.regions.begin(); i != page.regions.end(); ++i)
312   {
313     DVBSubtitleRegion::ObjectList::iterator j;
314     for (j = i->second.objects.begin(); j != i->second.objects.end(); ++j)
315     {
316       if (j->objectID == objectID)
317       {
318         struct RegionRef usage;
319         usage.region = &(i->second);
320         usage.horizontalPosition = j->horizontalPosition;
321         usage.verticalPosition = j->verticalPosition;
322         useList.push_back(usage);
323       }
324     }
325   }
326 }
327
328 void DVBSubtitleObject::drawLine(const RegionRef& use, UINT x, UINT y,
329                                  UCHAR colour, UINT len)
330 {
331   if (nonModColourFlag && colour == 1) return;
332   x += use.horizontalPosition;
333   y += use.verticalPosition;
334   for (UINT pos = x; pos < x + len; ++pos)
335     use.region->setIndex(pos, y, colour);
336 }
337
338 UCHAR DVBSubtitleObject::get2Bits(const UCHAR* data, UINT& index)
339 {
340   UCHAR result = data[index];
341   if (!bitPos)
342   {
343     index++;
344     bitPos = 8;
345   }
346   bitPos -= 2;
347   return (result >> bitPos) & 0x03;
348 }
349
350 UCHAR DVBSubtitleObject::get4Bits(const UCHAR* data, UINT& index)
351 {
352   UCHAR result = data[index];
353   if (!bitPos)
354   {
355     index++;
356     bitPos = 4;
357   }
358   else
359   {
360     result >>= 4;
361     bitPos -= 4;
362   }
363   return result & 0x0F;
364 }
365
366 bool DVBSubtitleObject::decode2BppCodeString(const UCHAR* data, UINT& index, const struct RegionRef& use, UINT& x, UINT y)
367 {
368   UINT rl = 0, colour = 0;
369   UCHAR code = get2Bits(data, index);
370   if (code)
371   {
372     colour = code;
373     rl = 1;
374   }
375   else
376   {
377     code = get2Bits(data, index);
378     if (code & 2) // Switch 1
379     {
380       rl = ((code & 1) << 2) + get2Bits(data, index) + 3;
381       colour = get2Bits(data, index);
382     }
383     else if (code & 1) rl = 1; // Colour 0
384     else
385     {
386       code = get2Bits(data, index);
387       switch (code)
388       {
389         case 0:
390           return false; // end of 2-bit/pixel_code_string
391         case 1:
392           rl = 2; // Colour 0
393           break;
394         case 2:
395           rl = (get2Bits(data, index) << 2) + get2Bits(data, index) + 12;
396           colour = get2Bits(data, index);
397           break;
398         case 3:
399           rl = (get2Bits(data, index) << 6) + (get2Bits(data, index) << 4) +
400                (get2Bits(data, index) << 2) + get2Bits(data, index) + 29;
401           colour = get2Bits(data, index);
402           break;
403       }
404     }
405   }
406   drawLine(use, x, y, colour, rl);
407   x += rl;
408   return true;
409 }
410
411 bool DVBSubtitleObject::decode4BppCodeString(const UCHAR* data, UINT& index, const struct RegionRef& use, UINT& x, UINT y)
412 {
413   UINT rl = 0, colour = 0;
414   UCHAR code = get4Bits(data, index);
415   if (code)
416   {
417     colour = code;
418     rl = 1;
419   }
420   else
421   {
422     code = get4Bits(data, index);
423     if (code & 8) // Switch 1
424     {
425       if (code & 4) // Switch 2
426       {
427         switch (code & 3) // Switch 3
428         {
429           case 0: // Colour 0
430             rl = 1;
431             break;
432           case 1: // Colour 0
433             rl = 2;
434             break;
435           case 2:
436             rl = get4Bits(data, index) + 9;
437             colour = get4Bits(data, index);
438             break;
439           case 3:
440             rl = (get4Bits(data, index) << 4) + get4Bits(data, index) + 25;
441             colour = get4Bits(data, index);
442             break;
443         }
444       }
445       else
446       {
447         rl = (code & 3) + 4;
448         colour = get4Bits(data, index);
449       }
450     }
451     else
452     {
453       if (!code) return false; // end of 4-bit/pixel_code_string
454       rl = code + 2; // Colour 0
455     }
456   }
457   drawLine(use, x, y, colour, rl);
458   x += rl;
459   return true;
460 }
461
462 bool DVBSubtitleObject::decode8BppCodeString(const UCHAR* data, UINT& index, const struct RegionRef& use, UINT& x, UINT y)
463 {
464   UINT rl = 0, colour = 0;
465   UCHAR code = data[index++];
466   if (code)
467   {
468     colour = code;
469     rl = 1;
470   }
471   else
472   {
473     code = data[index++];
474     rl = code & 0x7F;
475     if (code & 0x80)
476       colour = data[index++];
477     else if (!rl)
478       return false; // else colour 0
479   }
480   drawLine(use, x, y, colour, rl);
481   x += rl;
482   return true;
483 }
484
485 void DVBSubtitleObject::decodeSubBlock(const UCHAR* data, UINT length, bool even)
486 {
487   UseList::const_iterator use;
488   for (use = useList.begin(); use != useList.end(); ++use)
489   {
490     UINT x = 0; UINT y = even ? 0 : 1; UINT index = 0;
491     while (index < length)
492     {
493       switch (data[index++])
494       {
495         case 0x10:
496           switch (use->region->palette.getBpp())
497           {
498             case 8: currentMapTable = map2to8; break;
499             case 4: currentMapTable = map2to4; break;
500             default: currentMapTable = NULL;
501           }
502           bitPos = 8;
503           while (decode2BppCodeString(data, index, *use,x,y) && index < length);
504           if (!bitPos) index++;
505           break;
506         case 0x11:
507           if (use->region->palette.getBpp() == 8)
508             currentMapTable = map4to8;
509           else
510             currentMapTable = NULL;
511           bitPos = 4;
512           while (decode4BppCodeString(data, index, *use,x,y) && index < length);
513           if (!bitPos) index++;
514           break;
515         case 0x12:
516           while (decode8BppCodeString(data, index, *use,x,y) && index < length);
517           break;
518         case 0x20:
519           map2to4[0] = data[index] >> 4;
520           map2to4[1] = data[index++] & 0x0F;
521           map2to4[2] = data[index] >> 4;
522           map2to4[3] = data[index++] & 0x0F;
523           break;
524         case 0x21:
525           for (int i = 0; i < 4; i++) map2to8[i] = data[index++];
526           break;
527         case 0x22:
528           for (int i = 0; i < 16; i++) map4to8[i] = data[index++];
529           break;
530         case 0xF0:
531           x = 0; y += 2;
532           break;
533       }
534     }
535   }
536 }
537
538 static ULLONG PTSDifference(ULLONG pts1, ULLONG pts2)
539 {
540   // Assume pts1, pts2 < 2^33; calculate pts1 - pts2
541   if (pts1 > pts2)
542     return pts1 - pts2;
543   else
544     return (1LL<<33) + pts1 - pts2;
545 }
546
547 DVBSubtitles::DVBSubtitles(OSDReceiver* tosd)
548 : osd(tosd),
549   pageOnDisplay(65536),
550   running(false),
551   showing(false),
552   threadNudged(false)
553 {
554 #ifndef WIN32
555   pthread_mutex_init(&input_mutex, NULL);
556   pthread_mutex_init(&output_mutex, NULL);
557 #else
558   input_mutex=CreateMutex(NULL,FALSE,NULL);
559   output_mutex=CreateMutex(NULL,FALSE,NULL);
560 #endif
561 }
562
563 void DVBSubtitles::put(const PESPacket& packet)
564 {
565   lockInput();
566   if (running)
567   {
568     if (packet.getPTS() != PESPacket::PTS_INVALID)
569     {
570       worklist.push_back(packet);
571       nudge();
572     }
573   }
574   unlockInput();
575 }
576
577 bool DVBSubtitles::decodePacket(const PESPacket& packet)
578 {
579   const UCHAR* data = packet.getData();
580   UINT packetSize = packet.getSize();
581   if (packetSize < 9) return false;
582   UINT segmentOffset = data[8] + 11;
583   while (packetSize > segmentOffset)
584   {
585     if (data[segmentOffset] == 0xFF) return true; // 'End of PES' marker
586     if (data[segmentOffset] != 0x0F) return false; // Out of sync
587     if (packetSize <= segmentOffset + 5) return false; // Packet truncated
588     UCHAR segmentType = data[segmentOffset + 1];
589     UINT pageID = (data[segmentOffset + 2] << 8)
590                  + data[segmentOffset + 3];
591     UINT segmentLength = (data[segmentOffset + 4] << 8)
592                         + data[segmentOffset + 5];
593     if (pageOnDisplay == 65536) pageOnDisplay = pageID;
594     if (pageOnDisplay != pageID) return false;
595     if (packetSize <= segmentOffset + 5 + segmentLength) return false;
596     const UCHAR* segmentData = &data[segmentOffset + 6];
597     pages[pageID]; // Create this page if it doesn't exist
598     PageMap::iterator pageEntry = pages.find(pageID);
599     if (pageEntry == pages.end()) return false;
600     DVBSubtitlePage& page = pageEntry->second;
601     if (packet.getPTS() != PESPacket::PTS_INVALID) page.pts = packet.getPTS();
602     switch (segmentType)
603     {
604     case 0x10: // Page composition
605     {
606       if (segmentLength < 2) break;
607       page.setState((segmentData[1] & 0x0C) >> 2);
608       if (!page.serviceAcquired) break;
609       UCHAR pageVersion = (segmentData[1] & 0xF0) >> 4;
610       if (pageVersion == page.version) break; // No update
611       page.version = pageVersion;
612       page.timeout = segmentData[0];
613       page.pendingDisplay.clear();
614       UINT parsePos = 2;
615       while (segmentLength > parsePos + 5)
616       {
617         UCHAR regionID = segmentData[parsePos];
618         page.regions[regionID]; // Create the region if it doesn't exist
619         DVBSubtitlePage::Coords coords;
620         coords.x = (segmentData[parsePos + 2] << 8) +
621                     segmentData[parsePos + 3];
622         coords.y = (segmentData[parsePos + 4] << 8) +
623                     segmentData[parsePos + 5];
624         page.pendingDisplay[regionID] = coords;
625         parsePos += 6;
626       }
627       break;
628     }
629     case 0x11: // Region composition
630     {
631       if (segmentLength < 10) break;
632       UCHAR regionID = segmentData[0];
633       page.regions[regionID]; // Create the region if it doesn't exist
634       DVBSubtitlePage::RegionMap::iterator regionEntry;
635       regionEntry = page.regions.find(regionID);
636       if (regionEntry == page.regions.end()) return false;
637       DVBSubtitleRegion& region = regionEntry->second;
638       UCHAR regionVersion = (segmentData[1] & 0xF0) >> 4;
639       if (regionVersion == region.version) break; // No update
640       region.version = regionVersion;
641       bool regionFillFlag = (segmentData[1] & 0x08) >> 3;
642       UINT regionWidth  = (segmentData[2] << 8) + segmentData[3];
643       UINT regionHeight = (segmentData[4] << 8) + segmentData[5];
644       region.setSize(regionWidth, regionHeight);
645       region.level = (segmentData[6] & 0xE0) >> 5;
646       region.setDepth((segmentData[6] & 0x1C) >> 2);
647       region.CLUTid = segmentData[7];
648       page.CLUTs[region.CLUTid]; // Create the CLUT if it doesn't exist
649       DVBSubtitlePage::CLUTMap::iterator clut;
650       clut = page.CLUTs.find(region.CLUTid);
651       if (clut == page.CLUTs.end()) return false;
652       region.palette = clut->second.getPalette(region.palette.getBpp());
653       if (regionFillFlag) switch (region.palette.getBpp())
654       {
655         case 2: region.setAllIndices((segmentData[9] & 0x0C) >> 2); break;
656         case 4: region.setAllIndices((segmentData[9] & 0xF0) >> 4); break;
657         case 8: region.setAllIndices(segmentData[8]); break;
658       }
659       region.objects.clear();
660       UINT parsePos = 10;
661       while (segmentLength > parsePos + 5)
662       {
663         UINT objectID = (segmentData[parsePos] << 8) +
664                          segmentData[parsePos + 1];
665         DVBSubtitleRegion::ObjectRef objref;
666         objref.objectID = objectID;
667         UINT objectType = (segmentData[parsePos + 2] & 0xC0) >> 6;
668         objref.horizontalPosition = ((segmentData[parsePos + 2] & 0x0F) << 8) +
669                                       segmentData[parsePos + 3];
670         objref.verticalPosition = ((segmentData[parsePos + 4] & 0x0F) << 8) +
671                                     segmentData[parsePos + 5];
672         if (objectType == 0) region.objects.push_back(objref);
673         parsePos += 6;
674       }
675       break; // case 0x11
676     }
677     case 0x12: // CLUT definition
678     {
679       if (segmentLength < 2) break;
680       UCHAR CLUTid = segmentData[0];
681       DVBSubtitlePage::CLUTMap::iterator clutEntry;
682       clutEntry = page.CLUTs.find(CLUTid);
683       if (clutEntry == page.CLUTs.end()) return false;
684       DVBSubtitleCLUT& clut = clutEntry->second;
685       clut.CLUTid = CLUTid;
686       UCHAR clutVersion = (segmentData[1] & 0xF0) >> 4;
687       if (clutVersion == clut.version) break; // No update
688       clut.version = clutVersion;
689       UINT parsePos = 2;
690       while (segmentLength > parsePos + 3)
691       {
692         UCHAR clutEntryID = segmentData[parsePos];
693         bool fullRangeFlag = segmentData[parsePos + 1] & 0x01;
694         UCHAR Y, Cr, Cb, T;
695         if (fullRangeFlag)
696         {
697           if (segmentLength <= parsePos + 5) break;
698           Y  = segmentData[parsePos + 2];
699           Cr = segmentData[parsePos + 3];
700           Cb = segmentData[parsePos + 4];
701           T  = segmentData[parsePos + 5];
702         }
703         else
704         {
705           Y   =  segmentData[parsePos + 2] & 0xFC;
706           Cr  = (segmentData[parsePos + 2] & 0x03) << 6;
707           Cr |= (segmentData[parsePos + 3] & 0xC0) >> 2;
708           Cb  = (segmentData[parsePos + 3] & 0x3C) << 2;
709           T   = (segmentData[parsePos + 3] & 0x03) << 6;
710         }
711         UCHAR entryFlags = segmentData[parsePos + 1];
712         if (entryFlags & 0x80) clut.setEntry(2, clutEntryID, Y,Cr,Cb,T);
713         if (entryFlags & 0x40) clut.setEntry(4, clutEntryID, Y,Cr,Cb,T);
714         if (entryFlags & 0x20) clut.setEntry(8, clutEntryID, Y,Cr,Cb,T);
715         parsePos += fullRangeFlag ? 6 : 4;
716       }
717       page.updateRegionPalettes(clut);
718       break; // case 0x12
719     }
720     case 0x13: // Object data
721     {
722       if (segmentLength < 3) break;
723       UINT objectID = (segmentData[0] << 8) + segmentData[1];
724       DVBSubtitleObject object(objectID);
725       object.findWhereUsed(page);
726       UCHAR codingMethod = (segmentData[2] & 0x0C) >> 2;
727       object.setNonModColourFlag(segmentData[2] & 0x01);
728       if (codingMethod == 0x00) // Coding of pixels
729       {
730         if (segmentLength < 7) break;
731         UINT topFieldLen     = (segmentData[3] << 8) + segmentData[4];
732         UINT bottomFieldLen  = (segmentData[5] << 8) + segmentData[6];
733         if (segmentLength < 7 + topFieldLen + bottomFieldLen) break;
734         object.decodeSubBlock(segmentData + 7, topFieldLen, true);
735         if (bottomFieldLen)
736           object.decodeSubBlock(segmentData + 7 + topFieldLen,
737                                 bottomFieldLen, false);
738         else
739           object.decodeSubBlock(segmentData + 7, topFieldLen, false);
740       }
741       else if (codingMethod == 0x01) // Coded as a string of characters
742         ; // TODO
743       break;
744     }
745     case 0x14: {// Display definition
746         if (segmentLength<5) break;
747         UINT ddsversion=(segmentData[0]&0xf0)>>4;
748         if (ddsversion==dds.version) break; // no update ncessary
749         dds.version=ddsversion;
750         dds.displaywindow=!(!(segmentData[0]&0x08));
751         dds.framewidth=(segmentData[1] << 8) + segmentData[2];
752         dds.frameheight=(segmentData[3] << 8) + segmentData[4];
753         if (segmentLength<13) break;
754         if (dds.displaywindow) {
755                 dds.windowx=(segmentData[4] << 8) + segmentData[5];
756                 dds.windoww=(segmentData[6] << 8) + segmentData[7]-dds.windowx;
757                 dds.windowy=(segmentData[8] << 8) + segmentData[9];
758                 dds.windowh=(segmentData[10] << 8) + segmentData[11]-dds.windowy;
759         } else {
760                 dds.windowx=0;
761                 dds.windowy=0;
762                 dds.windoww=dds.framewidth;
763                 dds.windowh=dds.frameheight;
764         }
765       break;
766     }
767     case 0x80: // End of display set
768       finishPage(page);
769       page.dirty = false;
770       page.currentDisplay = page.pendingDisplay;
771       break;
772     }
773     segmentOffset += (segmentLength + 6);
774   }
775   return false; // Fall through from while loop: we ran out of data
776 }
777
778 void DVBSubtitles::finishPage(const DVBSubtitlePage& page)
779 {
780   if (page.dirty && !osdMenuShowing) 
781   {
782     osd->clearOSD();
783   }
784
785   DVBSubtitlePage::DisplayMap::const_iterator i,j;
786   for (i = page.currentDisplay.begin(); i != page.currentDisplay.end(); ++i)
787   { // For each currently displayed region, if the region has been
788     // moved or removed, blank out its previous screen position
789     j = page.pendingDisplay.find(i->first);
790     if (j == page.pendingDisplay.end() ||
791         j->second.x != i->second.x ||
792         j->second.y != i->second.y)
793     {
794       DVBSubtitlePage::RegionMap::const_iterator region_iter;
795       region_iter = page.regions.find(i->first);
796       if (region_iter == page.regions.end()) continue;
797       Log::getInstance()->log("SUBTITLES", Log::DEBUG, "Clear region %d", i->first);
798       if (!osdMenuShowing) osd->clearOSDArea(i->second.x, i->second.y,
799            region_iter->second.getWidth(), region_iter->second.getHeight(),dds);
800     }
801   }
802
803   for (i = page.pendingDisplay.begin(); i != page.pendingDisplay.end(); ++i)
804   { // Display each pending region
805     DVBSubtitlePage::RegionMap::const_iterator region_iter;
806     region_iter = page.regions.find(i->first);
807     if (region_iter == page.regions.end()) continue;
808     Log::getInstance()->log("SUBTITLES", Log::DEBUG, "Display region %d", i->first);
809     if (!osdMenuShowing) osd->drawOSDBitmap(i->second.x, i->second.y,
810          region_iter->second,dds);
811   }
812 // after displaying regions set the page timeout timer
813   SubtitleTimeout.Set(page.timeout * 1000);
814   Log::getInstance()->log("SUBTITLES", Log::DEBUG, "SubtitleTimeout %d", page.timeout);
815 }
816
817 void DVBSubtitles::lockInput()
818 {
819 #ifndef WIN32
820   pthread_mutex_lock(&input_mutex);
821 #else
822   WaitForSingleObject(input_mutex, INFINITE);
823 #endif
824 }
825
826 void DVBSubtitles::unlockInput()
827 {
828 #ifndef WIN32
829   pthread_mutex_unlock(&input_mutex);
830 #else
831   ReleaseMutex(input_mutex);
832 #endif
833 }
834
835 void DVBSubtitles::lockOutput()
836 {
837 #ifndef WIN32
838   pthread_mutex_lock(&output_mutex);
839 #else
840   WaitForSingleObject(output_mutex, INFINITE);
841 #endif
842 }
843
844 void DVBSubtitles::unlockOutput()
845 {
846 #ifndef WIN32
847   pthread_mutex_unlock(&output_mutex);
848 #else
849   ReleaseMutex(output_mutex);
850 #endif
851 }
852
853 int DVBSubtitles::start()
854 {
855   lockInput();
856   dds=DVBSubtitleDisplayDefinition();
857   running = true;
858   unlockInput();
859   return threadStart();
860 }
861
862 void DVBSubtitles::stop()
863 {
864   threadStop();
865   lockInput();
866   running = false;
867   worklist.clear();
868   unlockInput();
869   lockOutput();
870   PageMap::const_iterator pageEntry = pages.find(pageOnDisplay);
871   if (pageEntry != pages.end())
872   {
873     const DVBSubtitlePage& page = pageEntry->second;
874     DVBSubtitlePage::DisplayMap::const_iterator i;
875     for (i = page.currentDisplay.begin(); i != page.currentDisplay.end(); ++i)
876     {
877       DVBSubtitlePage::RegionMap::const_iterator region_iter;
878       region_iter = page.regions.find(i->first);
879       if (region_iter == page.regions.end()) continue;
880       if (!osdMenuShowing) osd->clearOSDArea(i->second.x, i->second.y,
881            region_iter->second.getWidth(), region_iter->second.getHeight(),dds);
882     }
883   }
884   pages.clear();
885   pageOnDisplay = 65536;
886   unlockOutput();
887   threadNudged = false;
888 }
889
890 void DVBSubtitles::show()
891 {
892   lockOutput();
893   showing = true;
894   unlockOutput();
895 }
896
897 void DVBSubtitles::hide()
898 {
899   lockOutput();
900   showing = false;
901   PageMap::const_iterator pageEntry = pages.find(pageOnDisplay);
902   if (pageEntry != pages.end())
903   {
904     const DVBSubtitlePage& page = pageEntry->second;
905     DVBSubtitlePage::DisplayMap::const_iterator i;
906     for (i = page.currentDisplay.begin(); i != page.currentDisplay.end(); ++i)
907     {
908       DVBSubtitlePage::RegionMap::const_iterator region_iter;
909       region_iter = page.regions.find(i->first);
910       if (region_iter == page.regions.end()) continue;
911       if (!osdMenuShowing) osd->clearOSDArea(i->second.x, i->second.y,
912            region_iter->second.getWidth(), region_iter->second.getHeight(),dds);
913     }
914   }
915   pages.clear();
916   pageOnDisplay = 65536;
917   unlockOutput();
918 }
919
920 void DVBSubtitles::nudge()
921 {
922 #ifndef WIN32
923   pthread_mutex_lock(&threadCondMutex);
924   threadNudged = true;
925   pthread_cond_signal(&threadCond);
926   pthread_mutex_unlock(&threadCondMutex);
927 #else
928   WaitForSingleObject(threadCondMutex, INFINITE);
929   threadNudged = true;
930   SetEvent(threadCond);
931   ReleaseMutex(threadCondMutex);
932 #endif
933 }
934
935 #define SUBTITLE_TIMEOUT_MS 750 
936 // How often do we check if subtitles have been timed out.
937
938 void DVBSubtitles::threadMethod()
939 {
940   struct timespec sleeptime;
941   sleeptime.tv_sec = 0;
942   sleeptime.tv_nsec = 0;
943   uint64_t wakeup = 0;
944   while (1)
945   {
946     if (SubtitleTimeout.TimedOut())  // do we have a subtitle timeout
947     {
948       lockOutput();
949       if (showing && !osdMenuShowing)  
950        osd->clearOSD();      // if we have the timeout, lets clear the OSD
951       unlockOutput();
952     }
953     else                    // if not lets check when will we have it
954     {
955        wakeup = -(SubtitleTimeout.Elapsed());
956        if (wakeup > 0 && sleeptime.tv_nsec == 0 && sleeptime.tv_sec == 0)
957        // We are not done, we still have a Subtitle Timeout!
958        {
959          sleeptime.tv_sec = (int)(wakeup / 1000);
960          sleeptime.tv_nsec = (long)(wakeup % 1000) * 10000L / 1000L * 100000L;
961        }
962     }
963     threadCheckExit();
964     threadLock();
965     if (!threadNudged)
966     { // We have done the current work and no more has arrived. Sleep.
967       if (sleeptime.tv_sec == 0 && sleeptime.tv_nsec == 0)
968       {
969         Log::getInstance()->log("SUBTITLES", Log::DEBUG, "Sleeping until nudged.");
970         threadWaitForSignal();
971       }
972       else
973       {
974         Log::getInstance()->log("SUBTITLES", Log::DEBUG, "Sleeping for %d and %d", sleeptime.tv_sec, sleeptime.tv_nsec);
975         struct timespec targetTime;
976 #ifndef WIN32
977         clock_gettime(CLOCK_REALTIME, &targetTime);
978 #else
979         SYSTEMTIME systime;
980         __int64  filetime;
981         __int64  test;
982         GetSystemTime(&systime);
983         SystemTimeToFileTime(&systime,(FILETIME*)&filetime);
984         targetTime.tv_sec=(filetime-WINDOWS_TIME_BASE_OFFSET)/(10*1000*1000);
985         targetTime.tv_nsec=((filetime-WINDOWS_TIME_BASE_OFFSET)%(10*1000*1000))*100;
986 #endif
987         targetTime.tv_nsec += sleeptime.tv_nsec;
988         if (targetTime.tv_nsec > 999999999)
989         {
990           targetTime.tv_sec += 1;
991           targetTime.tv_nsec -= 1000000000;
992         }
993         targetTime.tv_sec += sleeptime.tv_sec;
994         threadWaitForSignalTimed(&targetTime);
995       }
996     }
997     threadNudged = false;
998     threadUnlock();
999     bool finished = false;
1000     ULLONG nowPTS, pktPTS;
1001     int wait;
1002     while (!finished)
1003     {
1004       threadCheckExit();
1005       finished = true;
1006       pktPTS = PESPacket::PTS_INVALID;
1007       lockInput();
1008       if (!worklist.empty())
1009         pktPTS = worklist.front().getPTS();
1010       unlockInput();
1011       if (pktPTS != PESPacket::PTS_INVALID)
1012       { // An entry exists in the work list
1013         nowPTS = Video::getInstance()->getCurrentTimestamp();
1014         if (PTSDifference(nowPTS, pktPTS) < 2*90000 ||
1015             PTSDifference(pktPTS, nowPTS) < 4000)
1016         { // It is due for processing or discarding.
1017           finished = false;
1018           lockInput();
1019           if (!worklist.empty())
1020           {
1021             PESPacket packet = worklist.front();
1022             worklist.pop_front();
1023             unlockInput();
1024             lockOutput();
1025             if (showing) decodePacket(packet);
1026             unlockOutput();
1027           }
1028           else unlockInput();
1029         }
1030         else if (PTSDifference(pktPTS, nowPTS) >= 60*90000)
1031         { // Seems like a bad or very old entry. Get rid of it.
1032           finished = false;
1033           lockInput();
1034           if (!worklist.empty()) worklist.pop_front();
1035           unlockInput();
1036         }
1037       }
1038     }
1039     // Calculate how long to sleep for
1040     wait = SUBTITLE_TIMEOUT_MS; // Max sleep while checking subtitle timeout 
1041     sleeptime.tv_sec = 0;
1042     sleeptime.tv_nsec = 0;
1043     if (pktPTS != PESPacket::PTS_INVALID)
1044     { // A future action exists
1045       nowPTS = Video::getInstance()->getCurrentTimestamp();
1046       ULLONG diff = PTSDifference(pktPTS, nowPTS);
1047       diff /= 90; // convert diff in ms as PTS difference in 1/90000s
1048       if (diff < 60 * 1000)
1049       {
1050         if (diff < (ULLONG)wait)
1051           wait = (int)diff;
1052         sleeptime.tv_nsec = (long)(wait % 1000) * 10000L / 1000L * 100000L;
1053       }
1054       else
1055         { // We have a problem. An action so far in the future should have
1056         // been culled. Probably the action is already due and PTSDifference
1057         // wrapped around. Therefore we sleep for a minimal time instead.
1058         sleeptime.tv_nsec = 1;
1059       }
1060     }
1061   }
1062 }
1063
1064 void DVBSubtitles::setOSDMenuVisibility(bool visible)
1065 {
1066   lockOutput();
1067   osdMenuShowing = visible;
1068   unlockOutput();
1069 }
1070