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