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