Revert "servicedvd.cpp: fix merge error (caused by the vob subtitle bug merge)"
[enigma2.git] / lib / python / Plugins / Extensions / DVDPlayer / src / servicedvd.cpp
1 /* yes, it's dvd  */
2 #include <lib/base/eerror.h>
3 #include <lib/base/object.h>
4 #include <lib/base/ebase.h>
5 #include <lib/base/nconfig.h>
6 #include <string>
7 #include <lib/service/service.h>
8 #include <lib/base/init_num.h>
9 #include <lib/base/init.h>
10 #include <lib/gui/esubtitle.h>
11 #include <lib/gdi/gpixmap.h>
12
13 #include <byteswap.h>
14 #include <netinet/in.h>
15 #ifndef BYTE_ORDER
16 #error no byte order defined!
17 #endif
18
19 extern "C" {
20 #include <dreamdvd/ddvdlib.h>
21 }
22 #include "servicedvd.h"
23
24 // eServiceFactoryDVD
25
26 eServiceFactoryDVD::eServiceFactoryDVD()
27 {
28         ePtr<eServiceCenter> sc;
29         
30         eServiceCenter::getPrivInstance(sc);
31         if (sc)
32         {
33                 std::list<std::string> extensions;
34                 extensions.push_back("iso");
35                 extensions.push_back("img");
36                 sc->addServiceFactory(eServiceFactoryDVD::id, this, extensions);
37         }
38 }
39
40 eServiceFactoryDVD::~eServiceFactoryDVD()
41 {
42         ePtr<eServiceCenter> sc;
43         
44         eServiceCenter::getPrivInstance(sc);
45         if (sc)
46                 sc->removeServiceFactory(eServiceFactoryDVD::id);
47 }
48
49 DEFINE_REF(eServiceFactoryDVD)
50
51         // iServiceHandler
52 RESULT eServiceFactoryDVD::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
53 {
54                 // check resources...
55         ptr = new eServiceDVD(ref);
56         return 0;
57 }
58
59 RESULT eServiceFactoryDVD::record(const eServiceReference &/*ref*/, ePtr<iRecordableService> &ptr)
60 {
61         ptr=0;
62         return -1;
63 }
64
65 RESULT eServiceFactoryDVD::list(const eServiceReference &, ePtr<iListableService> &ptr)
66 {
67         ptr=0;
68         return -1;
69 }
70
71
72 RESULT eServiceFactoryDVD::info(const eServiceReference &/*ref*/, ePtr<iStaticServiceInformation> &ptr)
73 {
74         ptr=0;
75         return -1;
76 }
77
78 RESULT eServiceFactoryDVD::offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &ptr)
79 {
80         ptr = 0;
81         return -1;
82 }
83
84 // eServiceDVD
85
86 DEFINE_REF(eServiceDVD);
87
88 eServiceDVD::eServiceDVD(eServiceReference ref):
89         m_ref(ref), m_ddvdconfig(ddvd_create()), m_subtitle_widget(0), m_state(stIdle),
90         m_current_trick(0), m_pump(eApp, 1), m_width(-1), m_height(-1),
91         m_aspect(-1), m_framerate(-1), m_progressive(-1)
92 {
93         int aspect = DDVD_16_9;
94         int policy = DDVD_PAN_SCAN;
95         int policy2 = DDVD_PAN_SCAN;
96
97         char tmp[255];
98         ssize_t rd;
99
100         m_sn = eSocketNotifier::create(eApp, ddvd_get_messagepipe_fd(m_ddvdconfig), eSocketNotifier::Read|eSocketNotifier::Priority|eSocketNotifier::Error|eSocketNotifier::Hungup);
101         eDebug("SERVICEDVD construct!");
102         // create handle
103         ddvd_set_dvd_path(m_ddvdconfig, ref.path.c_str());
104         ddvd_set_ac3thru(m_ddvdconfig, 0);
105
106         std::string ddvd_language;
107         if (!ePythonConfigQuery::getConfigValue("config.osd.language", ddvd_language))
108                 ddvd_set_language(m_ddvdconfig, (ddvd_language.substr(0,2)).c_str());
109
110         int fd = open("/proc/stb/video/aspect", O_RDONLY);
111         if (fd > -1)
112         {
113                 rd = read(fd, tmp, 255);
114                 if (rd > 2 && !strncmp(tmp, "4:3", 3))
115                         aspect = DDVD_4_3;
116                 else if (rd > 4 && !strncmp(tmp, "16:10", 5))
117                         aspect = DDVD_16_10;
118                 close(fd);
119         }
120
121         fd = open("/proc/stb/video/policy", O_RDONLY);
122         if (fd > -1)
123         {
124                 rd = read(fd, tmp, 255);
125                 if (rd > 6 && !strncmp(tmp, "bestfit", 7))
126                         policy = DDVD_JUSTSCALE;
127                 else if (rd > 8 && !strncmp(tmp, "letterbox", 9))
128                         policy = DDVD_LETTERBOX;
129                 close(fd);
130         }
131
132 #ifdef DDVD_SUPPORTS_16_10_SCALING
133         fd = open("/proc/stb/video/policy2", O_RDONLY);
134         if (fd > -1)
135         {
136                 rd = read(fd, tmp, 255);
137                 if (rd > 6 && !strncmp(tmp, "bestfit", 7))
138                         policy2 = DDVD_JUSTSCALE;
139                 else if (rd > 8 && !strncmp(tmp, "letterbox", 9))
140                         policy2 = DDVD_LETTERBOX;
141                 close(fd);
142         }
143         ddvd_set_video_ex(m_ddvdconfig, aspect, policy, policy2, DDVD_PAL /*unused*/);
144 #else
145         ddvd_set_video(m_ddvdconfig, aspect, policy, DDVD_PAL /*unused*/);
146 #warning please update libdreamdvd for 16:10 scaling support!
147 #endif
148
149         CONNECT(m_sn->activated, eServiceDVD::gotMessage);
150         CONNECT(m_pump.recv_msg, eServiceDVD::gotThreadMessage);
151         strcpy(m_ddvd_titlestring,"");
152         m_cue_pts = 0;
153         pause();
154 }
155
156 void eServiceDVD::gotThreadMessage(const int &msg)
157 {
158         switch(msg)
159         {
160         case 1: // thread stopped
161                 m_state = stStopped;
162                 m_event(this, evStopped);
163                 break;
164         }
165 }
166
167 void eServiceDVD::gotMessage(int /*what*/)
168 {
169         switch(ddvd_get_next_message(m_ddvdconfig,1))
170         {
171                 case DDVD_COLORTABLE_UPDATE:
172                 {
173 /*
174                         struct ddvd_color ctmp[4];
175                         ddvd_get_last_colortable(ddvdconfig, ctmp);
176                         int i=0;
177                         while (i < 4)
178                         {
179                                 rd1[252+i]=ctmp[i].red;
180                                 bl1[252+i]=ctmp[i].blue;
181                                 gn1[252+i]=ctmp[i].green;
182                                 tr1[252+i]=ctmp[i].trans;
183                                 i++;
184                         }
185                         if(ioctl(fb, FBIOPUTCMAP, &colormap) == -1)
186                         {
187                                 printf("Framebuffer: <FBIOPUTCMAP failed>\n");
188                                 return 1;
189                         }
190 */
191                         eDebug("no support for 8bpp framebuffer in dvdplayer yet!");
192                         break;
193                 }
194                 case DDVD_SCREEN_UPDATE:
195                         eDebug("DVD_SCREEN_UPDATE!");
196                         if (m_subtitle_widget) {
197                                 int x1,x2,y1,y2;
198                                 ddvd_get_last_blit_area(m_ddvdconfig, &x1, &x2, &y1, &y2);
199                                 
200                                 int x_offset = 0, y_offset = 0, width = 720, height = 576;
201
202 #ifdef DDVD_SUPPORTS_GET_BLIT_DESTINATION
203                                 ddvd_get_blit_destination(m_ddvdconfig, &x_offset, &y_offset, &width, &height);
204                                 eDebug("values got from ddvd: %d %d %d %d", x_offset, y_offset, width, height);
205                                 y_offset = -y_offset;
206                                 width -= x_offset * 2;
207                                 height -= y_offset * 2;
208 #endif
209                                 eRect dest(x_offset, y_offset, width, height);
210
211                                 if (dest.width() && dest.height())
212                                         m_subtitle_widget->setPixmap(m_pixmap, eRect(x1, y1, (x2-x1)+1, (y2-y1)+1), dest);
213                         }
214                         break;
215                 case DDVD_SHOWOSD_STATE_PLAY:
216                 {
217                         eDebug("DVD_SHOWOSD_STATE_PLAY!");
218                         m_current_trick = 0;
219                         m_event(this, evUser+1);
220                         break;
221                 }
222                 case DDVD_SHOWOSD_STATE_PAUSE:
223                 {
224                         eDebug("DVD_SHOWOSD_STATE_PAUSE!");
225                         m_event(this, evUser+2);
226                         break;
227                 }
228                 case DDVD_SHOWOSD_STATE_FFWD:
229                 {
230                         eDebug("DVD_SHOWOSD_STATE_FFWD!");
231                         m_event(this, evUser+3);
232                         break;
233                 }
234                 case DDVD_SHOWOSD_STATE_FBWD:
235                 {
236                         eDebug("DVD_SHOWOSD_STATE_FBWD!");
237                         m_event(this, evUser+4);
238                         break;
239                 }
240                 case DDVD_SHOWOSD_STRING:
241                 {
242                         eDebug("DVD_SHOWOSD_STRING!");
243                         m_event(this, evUser+5);
244                         break;
245                 }
246                 case DDVD_SHOWOSD_AUDIO:
247                 {
248                         eDebug("DVD_SHOWOSD_STRING!");
249                         m_event(this, evUser+6);
250                         break;
251                 }
252                 case DDVD_SHOWOSD_SUBTITLE:
253                 {
254                         eDebug("DVD_SHOWOSD_SUBTITLE!");
255                         m_event((iPlayableService*)this, evUpdatedInfo);
256                         m_event(this, evUser+7);
257                         break;
258                 }
259                 case DDVD_EOF_REACHED:
260                         eDebug("DVD_EOF_REACHED!");
261                         m_event(this, evEOF);
262                         break;
263                 case DDVD_SOF_REACHED:
264                         eDebug("DVD_SOF_REACHED!");
265                         m_event(this, evSOF);
266                         break;
267                 case DDVD_SHOWOSD_ANGLE:
268                 {
269                         int current, num;
270                         ddvd_get_angle_info(m_ddvdconfig, &current, &num);
271                         eDebug("DVD_ANGLE_INFO: %d / %d", current, num);
272                         m_event(this, evUser+13);
273                         break;
274                 }
275                 case DDVD_SHOWOSD_TIME:
276                 {
277                         static struct ddvd_time last_info;
278                         struct ddvd_time info;
279 //                      eDebug("DVD_SHOWOSD_TIME!");
280                         ddvd_get_last_time(m_ddvdconfig, &info);
281                         if ( info.pos_chapter != last_info.pos_chapter )
282                                 m_event(this, evUser+8); // chapterUpdated
283                         if ( info.pos_title != last_info.pos_title )
284                                 m_event(this, evUser+9); // titleUpdated
285                         memcpy(&last_info, &info, sizeof(struct ddvd_time));
286                         break;
287                 }
288                 case DDVD_SHOWOSD_TITLESTRING:
289                 {
290                         ddvd_get_title_string(m_ddvdconfig, m_ddvd_titlestring);
291                         eDebug("DDVD_SHOWOSD_TITLESTRING: %s",m_ddvd_titlestring);
292                         loadCuesheet();
293                         if (!m_cue_pts)
294                                 unpause();
295                         m_event(this, evStart);
296                         break;
297                 }
298                 case DDVD_MENU_OPENED:
299                         eDebug("DVD_MENU_OPENED!");
300                         m_state = stMenu;
301                         m_event(this, evSeekableStatusChanged);
302                         m_event(this, evUser+11);
303                         break;
304                 case DDVD_MENU_CLOSED:
305                         eDebug("DVD_MENU_CLOSED!");
306                         m_state = stRunning;
307                         m_event(this, evSeekableStatusChanged);
308                         m_event(this, evUser+12);
309                         break;
310 #ifdef DDVD_SUPPORTS_PICTURE_INFO
311                 case DDVD_SIZE_CHANGED:
312                 {
313                         int changed = m_width != -1 && m_height != -1 && m_aspect != -1;
314                         ddvd_get_last_size(m_ddvdconfig, &m_width, &m_height, &m_aspect);
315                         if (changed)
316                                 m_event((iPlayableService*)this, evVideoSizeChanged);
317                         break;
318                 }
319                 case DDVD_PROGRESSIVE_CHANGED:
320                 {
321                         int changed = m_progressive != -1;
322                         ddvd_get_last_progressive(m_ddvdconfig, &m_progressive);
323                         if (changed)
324                                 m_event((iPlayableService*)this, evVideoProgressiveChanged);
325                         break;
326                 }
327                 case DDVD_FRAMERATE_CHANGED:
328                 {
329                         int changed = m_framerate != -1;
330                         ddvd_get_last_framerate(m_ddvdconfig, &m_framerate);
331                         if (changed)
332                                 m_event((iPlayableService*)this, evVideoFramerateChanged);
333                         break;
334                 }
335 #endif
336                 default:
337                         break;
338         }
339 }
340
341 eServiceDVD::~eServiceDVD()
342 {
343         eDebug("SERVICEDVD destruct!");
344         kill();
345         saveCuesheet();
346         ddvd_close(m_ddvdconfig);
347         disableSubtitles(0);
348 }
349
350 RESULT eServiceDVD::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
351 {
352         connection = new eConnection((iPlayableService*)this, m_event.connect(event));
353         return 0;
354 }
355
356 RESULT eServiceDVD::start()
357 {
358         ASSERT(m_state == stIdle);
359         m_state = stRunning;
360         eDebug("eServiceDVD starting");
361 //      m_event(this, evStart);
362         return 0;
363 }
364
365 RESULT eServiceDVD::stop()
366 {
367         ASSERT(m_state != stIdle);
368         if (m_state == stStopped)
369                 return -1;
370         eDebug("DVD: stop %s", m_ref.path.c_str());
371         m_state = stStopped;
372         ddvd_send_key(m_ddvdconfig, DDVD_KEY_EXIT);
373
374         return 0;
375 }
376
377 RESULT eServiceDVD::setTarget(int /*target*/)
378 {
379         return -1;
380 }
381
382 RESULT eServiceDVD::pause(ePtr<iPauseableService> &ptr)
383 {
384         ptr=this;
385         return 0;
386 }
387
388 RESULT eServiceDVD::seek(ePtr<iSeekableService> &ptr)
389 {
390         ptr=this;
391         return 0;
392 }
393
394 RESULT eServiceDVD::subtitle(ePtr<iSubtitleOutput> &ptr)
395 {
396         ptr=this;
397         return 0;
398 }
399
400 RESULT eServiceDVD::audioTracks(ePtr<iAudioTrackSelection> &ptr)
401 {
402         ptr = this;
403         return 0;
404 }
405
406 int eServiceDVD::getNumberOfTracks()
407 {
408         int i = 0;
409         ddvd_get_audio_count(m_ddvdconfig, &i);
410         return i;
411 }
412
413 int eServiceDVD::getCurrentTrack()
414 {
415         int audio_id,audio_type;
416         uint16_t audio_lang;
417         ddvd_get_last_audio(m_ddvdconfig, &audio_id, &audio_lang, &audio_type);
418         return audio_id;
419 }
420
421 RESULT eServiceDVD::selectTrack(unsigned int i)
422 {
423         ddvd_set_audio(m_ddvdconfig, i);
424         return 0;
425 }
426
427 RESULT eServiceDVD::getTrackInfo(struct iAudioTrackInfo &info, unsigned int audio_id)
428 {
429         int audio_type;
430         uint16_t audio_lang;
431         ddvd_get_audio_byid(m_ddvdconfig, audio_id, &audio_lang, &audio_type);
432         char audio_string[3]={audio_lang >> 8, audio_lang, 0};
433         info.m_pid = audio_id+1;
434         info.m_language = audio_string;
435         switch(audio_type)
436         {
437                 case DDVD_MPEG:
438                         info.m_description = "MPEG";
439                         break;
440                 case DDVD_AC3:
441                         info.m_description = "AC3";
442                         break;
443                 case DDVD_DTS:
444                         info.m_description = "DTS";
445                         break;
446                 case DDVD_LPCM:
447                         info.m_description = "LPCM";
448                         break;
449                 default:
450                         info.m_description = "und";
451         }
452         return 0;
453 }
454
455 RESULT eServiceDVD::keys(ePtr<iServiceKeys> &ptr)
456 {
457         ptr=this;
458         return 0;
459 }
460
461         // iPausableService
462 RESULT eServiceDVD::setSlowMotion(int /*ratio*/)
463 {
464         return -1;
465 }
466
467 RESULT eServiceDVD::setFastForward(int trick)
468 {
469         eDebug("setTrickmode(%d)", trick);
470         while (m_current_trick > trick && m_current_trick != -64)
471         {
472                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_FBWD);
473                 if (m_current_trick == 0)
474                         m_current_trick = -2;
475                 else if (m_current_trick > 0)
476                 {
477                         m_current_trick /= 2;
478                         if (abs(m_current_trick) == 1)
479                                 m_current_trick=0;
480                 }
481                 else
482                         m_current_trick *= 2;
483         }
484         while (m_current_trick < trick && m_current_trick != 64)
485         {
486                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_FFWD);
487                 if (m_current_trick == 0)
488                         m_current_trick = 2;
489                 else if (m_current_trick < 0)
490                 {
491                         m_current_trick /= 2;
492                         if (abs(m_current_trick) == 1)
493                                 m_current_trick=0;
494                 }
495                 else
496                         m_current_trick *= 2;
497         }
498         return 0;
499 }
500
501 RESULT eServiceDVD::pause()
502 {
503         eDebug("set pause!\n");
504         ddvd_send_key(m_ddvdconfig, DDVD_KEY_PAUSE);
505         return 0;
506 }
507
508 RESULT eServiceDVD::unpause()
509 {
510         eDebug("set unpause!\n");
511         ddvd_send_key(m_ddvdconfig, DDVD_KEY_PLAY);
512         return 0;
513 }
514
515 void eServiceDVD::thread()
516 {
517         eDebug("eServiceDVD dvd thread started");
518         hasStarted();
519         ddvd_run(m_ddvdconfig);
520 }
521
522 void eServiceDVD::thread_finished()
523 {
524         eDebug("eServiceDVD dvd thread finished");
525         m_pump.send(1); // inform main thread
526 }
527
528 RESULT eServiceDVD::info(ePtr<iServiceInformation>&i)
529 {
530         i = this;
531         return 0;
532 }
533
534 RESULT eServiceDVD::getName(std::string &name)
535 {
536         if ( m_ddvd_titlestring[0] != '\0' )
537                 name = m_ddvd_titlestring;
538         else
539                 if ( !m_ref.name.empty() )
540                         name = m_ref.name;
541                 else
542                         name = m_ref.path;
543         return 0;
544 }
545
546 int eServiceDVD::getInfo(int w)
547 {
548         switch (w)
549         {
550                 case sCurrentChapter:
551                 {
552                         struct ddvd_time info;
553                         ddvd_get_last_time(m_ddvdconfig, &info);
554                         return info.pos_chapter;
555                 }
556                 case sTotalChapters:
557                 {
558                         struct ddvd_time info;
559                         ddvd_get_last_time(m_ddvdconfig, &info);
560                         return info.end_chapter;
561                 }
562                 case sCurrentTitle:
563                 {
564                         struct ddvd_time info;
565                         ddvd_get_last_time(m_ddvdconfig, &info);
566                         return info.pos_title;
567                 }
568                 case sTotalTitles:
569                 {
570                         struct ddvd_time info;
571                         ddvd_get_last_time(m_ddvdconfig, &info);
572                         return info.end_title;
573                 }
574                 case sTXTPID:   // we abuse HAS_TELEXT icon in InfoBar to signalize subtitles status
575                 {
576                         int spu_id;
577                         uint16_t spu_lang;
578                         ddvd_get_last_spu(m_ddvdconfig, &spu_id, &spu_lang);
579                         return spu_id;
580                 }
581                 case sUser+6:
582                 case sUser+7:
583                 case sUser+8:
584                         return resIsPyObject;
585 #ifdef DDVD_SUPPORTS_PICTURE_INFO
586                 case sVideoWidth:
587                         return m_width;
588                 case sVideoHeight:
589                         return m_height;
590                 case sAspect:
591                         return m_aspect;
592                 case sProgressive:
593                         return m_progressive;
594                 case sFrameRate:
595                         return m_framerate;
596 #endif
597                 default:
598                         return resNA;
599         }
600 }
601
602 std::string eServiceDVD::getInfoString(int w)
603 {
604         switch(w)
605         {
606                 case sServiceref:
607                         return m_ref.toString();
608                 default:
609                         eDebug("unhandled getInfoString(%d)", w);
610         }
611         return "";
612 }
613
614 PyObject *eServiceDVD::getInfoObject(int w)
615 {
616         switch(w)
617         {
618                 case sUser+6:
619                 {
620                         ePyObject tuple = PyTuple_New(3);
621                         int audio_id,audio_type;
622                         uint16_t audio_lang;
623                         ddvd_get_last_audio(m_ddvdconfig, &audio_id, &audio_lang, &audio_type);
624                         char audio_string[3]={audio_lang >> 8, audio_lang, 0};
625                         PyTuple_SetItem(tuple, 0, PyInt_FromLong(audio_id+1));
626                         PyTuple_SetItem(tuple, 1, PyString_FromString(audio_string));
627                         switch(audio_type)
628                         {
629                                 case DDVD_MPEG:
630                                         PyTuple_SetItem(tuple, 2, PyString_FromString("MPEG"));
631                                         break;
632                                 case DDVD_AC3:
633                                         PyTuple_SetItem(tuple, 2, PyString_FromString("AC3"));
634                                         break;
635                                 case DDVD_DTS:
636                                         PyTuple_SetItem(tuple, 2, PyString_FromString("DTS"));
637                                         break;
638                                 case DDVD_LPCM:
639                                         PyTuple_SetItem(tuple, 2, PyString_FromString("LPCM"));
640                                         break;
641                                 default:
642                                         PyTuple_SetItem(tuple, 2, PyString_FromString(""));
643                         }
644                         return tuple;
645                 }
646                 case sUser+7:
647                 {
648                         ePyObject tuple = PyTuple_New(2);
649                         int spu_id;
650                         uint16_t spu_lang;
651                         ddvd_get_last_spu(m_ddvdconfig, &spu_id, &spu_lang);
652                         char spu_string[3]={spu_lang >> 8, spu_lang, 0};
653                         if (spu_id == -1)
654                         {
655                                 PyTuple_SetItem(tuple, 0, PyInt_FromLong(0));
656                                 PyTuple_SetItem(tuple, 1, PyString_FromString(""));
657                         }
658                         else
659                         {
660                                 PyTuple_SetItem(tuple, 0, PyInt_FromLong(spu_id+1));
661                                 PyTuple_SetItem(tuple, 1, PyString_FromString(spu_string));
662                         }                               
663                         return tuple;
664                 }
665                 case sUser+8:
666                 {
667                         ePyObject tuple = PyTuple_New(2);
668                         int current, num;
669                         ddvd_get_angle_info(m_ddvdconfig, &current, &num);
670                         PyTuple_SetItem(tuple, 0, PyInt_FromLong(current));
671                         PyTuple_SetItem(tuple, 1, PyInt_FromLong(num));
672
673                         return tuple;
674                 }
675                 default:
676                         eDebug("unhandled getInfoObject(%d)", w);
677         }
678         Py_RETURN_NONE;
679 }
680
681 RESULT eServiceDVD::enableSubtitles(eWidget *parent, ePyObject tuple)
682 {
683         delete m_subtitle_widget;
684         eSize size = eSize(720, 576);
685
686         m_subtitle_widget = new eSubtitleWidget(parent);
687         m_subtitle_widget->resize(parent->size());
688
689         int pid = -1;
690
691         if ( tuple != Py_None )
692         {               
693                 ePyObject entry;
694                 int tuplesize = PyTuple_Size(tuple);
695                 if (!PyTuple_Check(tuple))
696                         goto error_out;
697                 if (tuplesize < 1)
698                         goto error_out;
699                 entry = PyTuple_GET_ITEM(tuple, 1);
700                 if (!PyInt_Check(entry))
701                         goto error_out;
702                 pid = PyInt_AsLong(entry)-1;
703
704                 ddvd_set_spu(m_ddvdconfig, pid);
705                 m_event(this, evUser+7);
706         }
707         eDebug("eServiceDVD::enableSubtitles %i", pid);
708
709         if (!m_pixmap)
710         {
711                 m_pixmap = new gPixmap(size, 32, 1); /* allocate accel surface (if possible) */
712 #ifdef DDVD_SUPPORTS_GET_BLIT_DESTINATION
713                 ddvd_set_lfb_ex(m_ddvdconfig, (unsigned char *)m_pixmap->surface->data, size.width(), size.height(), 4, size.width()*4, 1);
714 #else
715                 ddvd_set_lfb(m_ddvdconfig, (unsigned char *)m_pixmap->surface->data, size.width(), size.height(), 4, size.width()*4);
716 #warning please update libdreamdvd for fast scaling
717 #endif
718                 run(); // start the thread
719         }
720
721         m_subtitle_widget->setZPosition(-1);
722         m_subtitle_widget->show();
723
724         return 0;
725
726 error_out:
727         return -1;
728 }
729
730 RESULT eServiceDVD::disableSubtitles(eWidget */*parent*/)
731 {
732         delete m_subtitle_widget;
733         m_subtitle_widget = 0;
734         return 0;
735 }
736
737 PyObject *eServiceDVD::getSubtitleList()
738 {
739         ePyObject l = PyList_New(0);
740         unsigned int spu_count = 0;
741         ddvd_get_spu_count(m_ddvdconfig, &spu_count);
742
743         for ( unsigned int spu_id = 0; spu_id < spu_count; spu_id++ )
744         {
745                 uint16_t spu_lang;
746                 ddvd_get_spu_byid(m_ddvdconfig, spu_id, &spu_lang);
747                 char spu_string[3]={spu_lang >> 8, spu_lang, 0};
748
749                 ePyObject tuple = PyTuple_New(5);
750                 PyTuple_SetItem(tuple, 0, PyInt_FromLong(2));
751                 PyTuple_SetItem(tuple, 1, PyInt_FromLong(spu_id+1));
752                 PyTuple_SetItem(tuple, 2, PyInt_FromLong(3));
753                 PyTuple_SetItem(tuple, 3, PyInt_FromLong(0));
754                 PyTuple_SetItem(tuple, 4, PyString_FromString(spu_string));
755                 PyList_Append(l, tuple);
756                 Py_DECREF(tuple);
757         }
758         return l;
759 }
760
761 PyObject *eServiceDVD::getCachedSubtitle()
762 {
763         eDebug("eServiceDVD::getCachedSubtitle nyi");
764         Py_RETURN_NONE;
765 }
766
767 RESULT eServiceDVD::getLength(pts_t &len)
768 {
769 //      eDebug("eServiceDVD::getLength");
770         struct ddvd_time info;
771         ddvd_get_last_time(m_ddvdconfig, &info);
772         len = info.end_hours * 3600;
773         len += info.end_minutes * 60;
774         len += info.end_seconds;
775         len *= 90000;
776         return 0;
777 }
778
779 RESULT eServiceDVD::seekTo(pts_t to)
780 {
781         eDebug("eServiceDVD::seekTo(%lld)",to);
782         if ( to > 0 )
783         {
784                 eDebug("set_resume_pos: resume_info.title=%d, chapter=%d, block=%lu, audio_id=%d, audio_lock=%d, spu_id=%d, spu_lock=%d",m_resume_info.title,m_resume_info.chapter,m_resume_info.block,m_resume_info.audio_id, m_resume_info.audio_lock, m_resume_info.spu_id, m_resume_info.spu_lock);
785                 ddvd_set_resume_pos(m_ddvdconfig, m_resume_info);
786         }
787         return 0;
788 }
789
790 RESULT eServiceDVD::seekRelative(int direction, pts_t to)
791 {
792         int seconds = to / 90000;
793         seconds *= direction;
794         eDebug("seekRelative %d %d", direction, seconds);
795         ddvd_skip_seconds(m_ddvdconfig, seconds);
796         return 0;
797 }
798
799 RESULT eServiceDVD::getPlayPosition(pts_t &pos)
800 {
801         struct ddvd_time info;
802         ddvd_get_last_time(m_ddvdconfig, &info);
803         pos = info.pos_hours * 3600;
804         pos += info.pos_minutes * 60;
805         pos += info.pos_seconds;
806 //      eDebug("getPlayPosition %lld", pos);
807         pos *= 90000;
808         return 0;
809 }
810
811 RESULT eServiceDVD::seekTitle(int title)
812 {
813         eDebug("setTitle %d", title);
814         ddvd_set_title(m_ddvdconfig, title);
815         return 0;
816 }
817
818 RESULT eServiceDVD::seekChapter(int chapter)
819 {
820         eDebug("setChapter %d", chapter);
821         if ( chapter > 0 )
822                 ddvd_set_chapter(m_ddvdconfig, chapter);
823         return 0;
824 }
825
826 RESULT eServiceDVD::setTrickmode(int /*trick*/)
827 {
828         return -1;
829 }
830
831 RESULT eServiceDVD::isCurrentlySeekable()
832 {
833         return m_state == stRunning ? 3 : 0;
834 }
835
836 RESULT eServiceDVD::keyPressed(int key)
837 {
838         switch(key)
839         {
840         case iServiceKeys::keyLeft:
841                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_LEFT);
842                 break;
843         case iServiceKeys::keyRight:
844                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_RIGHT);
845                 break;
846         case iServiceKeys::keyUp:
847                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_UP);
848                 break;
849         case iServiceKeys::keyDown:
850                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_DOWN);
851                 break;
852         case iServiceKeys::keyOk:
853                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_OK);
854                 break;
855         case iServiceKeys::keyUser:
856                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_AUDIO);
857                 break;
858         case iServiceKeys::keyUser+1:
859                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_SUBTITLE);
860                 break;
861         case iServiceKeys::keyUser+2:
862                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_AUDIOMENU);
863                 break;
864         case iServiceKeys::keyUser+3:
865                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_NEXT_CHAPTER);
866                 break;
867         case iServiceKeys::keyUser+4:
868                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_PREV_CHAPTER);
869                 break;
870         case iServiceKeys::keyUser+5:
871                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_NEXT_TITLE);
872                 break;
873         case iServiceKeys::keyUser+6:
874                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_PREV_TITLE);
875                 break;
876         case iServiceKeys::keyUser+7:
877                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_MENU);
878                 break;
879         case iServiceKeys::keyUser+8:
880                 ddvd_send_key(m_ddvdconfig, DDVD_KEY_ANGLE);
881                 break;
882         default:
883                 return -1;
884         }
885         return 0;
886 }
887
888 RESULT eServiceDVD::cueSheet(ePtr<iCueSheet> &ptr)
889 {
890         if (m_cue_pts)
891         {
892                 ptr = this;
893                 return 0;
894         }
895         ptr = 0;
896         return -1;
897 }
898
899 PyObject *eServiceDVD::getCutList()
900 {
901         ePyObject list = PyList_New(1);
902         ePyObject tuple = PyTuple_New(2);
903         PyTuple_SetItem(tuple, 0, PyLong_FromLongLong(m_cue_pts));
904         PyTuple_SetItem(tuple, 1, PyInt_FromLong(3));
905         PyList_SetItem(list, 0, tuple);
906         return list;
907 }
908
909 void eServiceDVD::setCutList(ePyObject /*list*/)
910 {
911 }
912
913 void eServiceDVD::setCutListEnable(int /*enable*/)
914 {
915 }
916
917 void eServiceDVD::loadCuesheet()
918 {
919         char filename[128];
920         if ( m_ddvd_titlestring[0] != '\0' )
921                 snprintf(filename, 128, "/home/root/dvd-%s.cuts", m_ddvd_titlestring);
922         else
923                 snprintf(filename, 128, "%s/dvd.cuts", m_ref.path.c_str());
924
925         eDebug("eServiceDVD::loadCuesheet() filename=%s",filename);
926
927         FILE *f = fopen(filename, "rb");
928
929         if (f)
930         {
931                 unsigned long long where;
932                 unsigned int what;
933
934                 if (!fread(&where, sizeof(where), 1, f))
935                         return;
936                 if (!fread(&what, sizeof(what), 1, f))
937                         return;
938 #if BYTE_ORDER == LITTLE_ENDIAN
939                 where = bswap_64(where);
940 #endif
941                 what = ntohl(what);
942
943                 if (!fread(&m_resume_info, sizeof(struct ddvd_resume), 1, f))
944                         return;
945                 if (!fread(&what, sizeof(what), 1, f))
946                         return;
947
948                 what = ntohl(what);
949                 if (what != 4 )
950                         return;
951
952                 m_cue_pts = where;
953
954                 fclose(f);
955         } else
956                 eDebug("cutfile not found!");
957
958         if (m_cue_pts)
959         {
960                 m_event((iPlayableService*)this, evCuesheetChanged);
961                 eDebug("eServiceDVD::loadCuesheet() pts=%lld",m_cue_pts);
962         }
963 }
964
965 void eServiceDVD::saveCuesheet()
966 {
967         eDebug("eServiceDVD::saveCuesheet()");
968
969         struct ddvd_resume resume_info;
970         ddvd_get_resume_pos(m_ddvdconfig, &resume_info);
971
972         if (resume_info.title)
973         {
974                 struct ddvd_time info;
975                 ddvd_get_last_time(m_ddvdconfig, &info);
976                 pts_t pos;
977                 pos = info.pos_hours * 3600;
978                 pos += info.pos_minutes * 60;
979                 pos += info.pos_seconds;
980                 pos *= 90000;
981                 m_cue_pts = pos;
982                 eDebug("ddvd_get_resume_pos resume_info.title=%d, chapter=%d, block=%lu, audio_id=%d, audio_lock=%d, spu_id=%d, spu_lock=%d  (pts=%llu)",resume_info.title,resume_info.chapter,resume_info.block,resume_info.audio_id, resume_info.audio_lock, resume_info.spu_id, resume_info.spu_lock,m_cue_pts);
983         }
984         else
985         {
986                 eDebug("we're in a menu or somewhere else funny. so save cuesheet with pts=0");
987                 m_cue_pts = 0;
988         }
989
990         char filename[128];
991         if ( m_ddvd_titlestring[0] != '\0' )
992                 snprintf(filename, 128, "/home/root/dvd-%s.cuts", m_ddvd_titlestring);
993         else
994                 snprintf(filename, 128, "%s/dvd.cuts", m_ref.path.c_str());
995         
996         FILE *f = fopen(filename, "wb");
997
998         if (f)
999         {
1000                 unsigned long long where;
1001                 int what;
1002
1003 #if BYTE_ORDER == BIG_ENDIAN
1004                 where = m_cue_pts;
1005 #else
1006                 where = bswap_64(m_cue_pts);
1007 #endif
1008                 what = htonl(3);
1009                 fwrite(&where, sizeof(where), 1, f);
1010                 fwrite(&what, sizeof(what), 1, f);
1011                 
1012                 what = htonl(4);
1013                 fwrite(&resume_info, sizeof(struct ddvd_resume), 1, f);
1014                 fwrite(&what, sizeof(what), 1, f);
1015
1016                 fclose(f);
1017         }
1018 }
1019
1020 eAutoInitPtr<eServiceFactoryDVD> init_eServiceFactoryDVD(eAutoInitNumbers::service+1, "eServiceFactoryDVD");
1021
1022 PyMODINIT_FUNC
1023 initservicedvd(void)
1024 {
1025         Py_InitModule("servicedvd", NULL);
1026 }