vdr.cc

   1 /*
   2     Copyright 2004-2019 Chris Tallon
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP.  If not, see <https://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "vdr.h"
  21
  22 #include "recman.h"
  23 #include "tcp.h"
  24 #include "log.h"
  25 #include "recinfo.h"
  26 #include "dsock.h"
  27 #include "channel.h"
  28 #include "event.h"
  29 #include "wol.h"
  30 #include "vdrrequestpacket.h"
  31 #include "vdrresponsepacket.h"
  32 #include "command.h"
  33 #include "vdp6.h"
  34 #ifdef VOMP_MEDIAPLAYER
  35 #include "media.h"
  36 #include "mediaprovider.h"
  37 #include "mediaproviderids.h"
  38 #endif
  39 #include "vdrcommand.h"
  40 #include "video.h"
  41 #include "osd.h"
  42 #include "movieinfo.h"
  43 #include "seriesinfo.h"
  44 #include "osdvector.h"
  45 #include "tvmedia.h"
  46 #include <climits>
  47
  48 #define VOMP_PROTOCOL_VERSION 0x00000500
  49
  50 VDR* VDR::instance = NULL;
  51 #ifdef VOMP_MEDIAPLAYER
  52 //prepare a request
  53 //will create a request package from a command variable and fill this
  54 //caller has to destroy buffer
  55 static SerializeBuffer * prepareRequest(VDR_Command *cmd) {
  56   SerializeBuffer *buf=new SerializeBuffer(512,false,true);
  57   if (cmd->serialize(buf) != 0) {
  58     delete buf;
  59     return NULL;
  60   }
  61   return buf;
  62 }
  63
  64 //handle request/response
  65 //TODO avoid copy of buffer (needs extension of requestpacket)
  66 //TODO avoid command 2x (needs some more restructuring)
  67 SerializeBuffer * VDR::doRequestResponse(SerializeBuffer *rq,int cmd) {
  68   VDR_RequestPacket *rt=new VDR_RequestPacket;
  69   if (! rt) {
  70     delete rq;
  71     return NULL;
  72   }
  73   if (! rt->init(cmd,true,rq->getCurrent()-rq->getStart())) {
  74     delete rq;
  75     delete rt;
  76     return NULL;
  77   }
  78   if (! rt->copyin(rq->getStart(),(ULONG)(rq->getCurrent()-rq->getStart()))) {
  79     delete rq;
  80     delete rt;
  81     return NULL;
  82   }
  83   delete rq;
  84   VDR_ResponsePacket *rp=RequestResponse(rt);
  85   logger->log("doRequestResponse",Log::DEBUG,"got response %p",rp);
  86   if ( !rp) {
  87     delete rt;
  88     return NULL;
  89   }
  90   SerializeBuffer *buf=new SerializeBuffer(rp->getUserData(),rp->getUserDataLength(),true,true,false);
  91   delete rp;
  92   return buf;
  93 }
  94
  95
  96
  97 //deserialize a received response
  98 //delete the package
  99 //return !=0 on error
 100 static int decodeResponse(SerializeBuffer *rp,VDR_Command *c) {
 101   ULONG expected=c->command;
 102   if (c->deserialize(rp) != 0) {
 103     delete rp;
 104     Log::getInstance()->log("VDR", Log::ERR, "decodeResponse unable to deserialize for command %lu",expected);
 105     return -1;
 106   }
 107   delete rp;
 108   if (c->command != expected) {
 109    Log::getInstance()->log("VDR", Log::ERR, "decodeResponse unexpected response received 0x%lx, expected 0x%lx",c->command,expected);
 110     return -1;
 111   }
 112   Log::getInstance()->log("VDR", Log::DEBUG, "decodeResponse successfully decoded command 0x%lx",expected);
 113   return 0;
 114 }
 115
 116 #endif
 117
 118 VDR::VDR()
 119 {
 120   if (instance) return;
 121   instance = this;
 122
 123   TEMP_SINGLE_VDR_PR = NULL;
 124 #ifdef VOMP_MEDIAPLAYER
 125   providerId=MPROVIDERID_VDR;
 126   subRange=MPROVIDERRANGE_VDR;
 127   MediaPlayerRegister::getInstance()->registerMediaProvider(this,MPROVIDERID_VDR,MPROVIDERRANGE_VDR);
 128 #endif
 129 }
 130
 131 VDR::~VDR()
 132 {
 133   instance = NULL;
 134   if (initted) shutdown();
 135 }
 136
 137 VDR* VDR::getInstance()
 138 {
 139   return instance;
 140 }
 141
 142 int VDR::init()
 143 {
 144   if (initted) return 0;
 145   initted = 1;
 146   logger = Log::getInstance();
 147   return 1;
 148 }
 149
 150 int VDR::shutdown()
 151 {
 152   if (!initted) return 0;
 153   initted = 0;
 154   disconnect();
 155   return 1;
 156 }
 157
 158 void VDR::findServers(std::vector<VDRServer>& servers)
 159 {
 160   Wol* wol = Wol::getInstance();
 161   findingServer = 1;
 162   char message[15];
 163   memset(message, 0, 15);
 164   strcpy(message, "VDP-0001");
 165   /*tcp->getMAC(&message[9]); put mac here when TCP modified to do this*/
 166
 167 #if IPV6
 168   // FIXME Horrible hack. Rewrite all this.
 169   // Change away from relying on the dsock select to do the timing
 170   // Do timing here and let UDP4 / UDP6 objects/threads just wait
 171   // for responses
 172   VDP6 vdp6;
 173   vdp6.run();
 174 #endif
 175
 176   DatagramSocket ds(0);
 177   int haveAtLeastOne = 0;
 178   int retval;
 179   UCHAR waitType = 1;
 180   bool firstloop = true;
 181   while(findingServer)
 182   {
 183     if (waitType == 1)
 184     {
 185       ds.shutdown();
 186       ds.init();
 187       logger->log("VDR", Log::NOTICE, "Broadcasting for server");
 188       ds.send("255.255.255.255", 51051U, message, 15);
 189       ds.send("255.255.255.255", 51052U, message, 15);
 190       ds.send("255.255.255.255", 51053U, message, 15);
 191       ds.send("255.255.255.255", 51054U, message, 15);
 192       ds.send("255.255.255.255", 51055U, message, 15);
 193       if(!firstloop) wol->doWakeUp();
 194     }
 195     retval = ds.waitforMessage(waitType);
 196
 197     if (retval == 2) // we got a reply
 198     {
 199       waitType = 2;
 200
 201       const char* vdpreply = static_cast<const char*>(ds.getData());
 202       if ((ds.getDataLength() >= 24) && !strncmp(vdpreply, "VDP-0002", 8))
 203       {
 204         VDRServer newServer;
 205         // FIXME upgrade this to look for a return IP in the reply packet
 206         newServer.ip = new char[16];
 207         strcpy(newServer.ip, ds.getFromIPA());
 208
 209         USHORT newServerPort;
 210         memcpy(&newServerPort, &vdpreply[26], 2);
 211         newServer.port = ntohs(newServerPort);
 212
 213         ULONG newServerVersion;
 214         memcpy(&newServerVersion, &vdpreply[28], 4);
 215         newServer.version = ntohl(newServerVersion);
 216
 217         int newServerNameLength = ds.getDataLength() - 32;
 218         newServer.name = new char[newServerNameLength];
 219         strcpy(newServer.name, &vdpreply[32]);
 220
 221         servers.push_back(newServer);
 222         haveAtLeastOne = 1;
 223       }
 224     }
 225     else
 226     {
 227       if (haveAtLeastOne) break;
 228 #if IPV6
 229       if (vdp6.numFound()) break;
 230 #endif
 231
 232       waitType = 1;
 233       firstloop = false;
 234 /* For DEBUGGING *
 235       { VDRServer newServer;
 236       newServer.ip = new char[16];
 237       strcpy(newServer.ip, "192.168.1.7");
 238       newServer.name = new char[6];
 239       strcpy(newServer.name,"debug");
 240       servers.push_back(newServer);
 241       waitType = 2;
 242       haveAtLeastOne = 1;}/ * */
 243     }
 244   }
 245   logger->log("VDR", Log::NOTICE, "END loop");
 246
 247 #if IPV6
 248   vdp6.stop();
 249   std::vector<VDRServer>* servers6 = vdp6.getServers();
 250
 251   // Add IPv6 found servers to servers vector, if not in servers already
 252   // Free buffers from VDRServer objects if not taken. (Itching for that rewrite already).
 253
 254   for(auto i6 = servers6->begin(); i6 != servers6->end(); i6++)
 255   {
 256     bool found = false;
 257
 258     for(auto i4 = servers.begin(); i4 != servers.end(); i4++)
 259     {
 260       if (!strcmp(i4->name, i6->name)) { found = true; break; }
 261     }
 262
 263     if (found)
 264     {
 265       delete[] i6->name;
 266       delete[] i6->ip;
 267     }
 268     else
 269     {
 270       servers.push_back(*i6);
 271     }
 272   }
 273
 274 #endif
 275
 276   sort(servers.begin(), servers.end(), ServerSorter());
 277 }
 278
 279 void VDR::cancelFindingServer()
 280 {
 281   findingServer = 0;
 282 }
 283
 284 void VDR::setServerIP(char* newIP)
 285 {
 286   strcpy(serverIP, newIP);
 287 }
 288
 289 void VDR::setServerPort(USHORT newPort)
 290 {
 291   serverPort = newPort;
 292 }
 293
 294 int VDR::connect()
 295 {
 296   maxChannelNumber = 0;
 297   channelNumberWidth = 1;
 298
 299   if (tcp) delete tcp;
 300   tcp = new TCP();
 301   if (tcp->connectTo(serverIP, serverPort))
 302   {
 303     connected = true;
 304     threadStart();
 305     return 1;
 306   }
 307   else
 308   {
 309     return 0;
 310   }
 311 }
 312
 313 void VDR::disconnect()
 314 {
 315   threadCancel();
 316   if (tcp) delete tcp;
 317   tcp = NULL;
 318   connected = false;
 319   logger->log("VDR", Log::DEBUG, "Disconnect");
 320 }
 321
 322 void VDR::setReceiveWindow(size_t size)
 323 {
 324   if (connected && size) tcp->setReceiveWindow(size);
 325 }
 326
 327 ///////////////////////////////////////////////////////
 328
 329 void VDR::threadMethod()
 330 {
 331   logger->log("VDR", Log::DEBUG, "VDR RUN");
 332
 333   threadSetKillable(); // FIXME - change this to deal with the EDRs
 334
 335   ULONG channelID;
 336
 337   ULONG requestID;
 338   ULONG userDataLength;
 339   void* userData;
 340
 341   ULONG streamID;
 342   ULONG flag;
 343
 344   VDR_ResponsePacket* vresp;
 345
 346   ULONG timeNow = 0;
 347   ULONG lastKAsent = 0;
 348   ULONG lastKArecv = time(NULL);
 349   int readSuccess;
 350
 351   while(1)
 352   {
 353     timeNow = time(NULL);
 354
 355     readSuccess = tcp->readData(&channelID, sizeof(ULONG));  // 2s timeout atm
 356
 357     if (!readSuccess)
 358     {
 359       //logger->log("VDR", Log::DEBUG, "Net read timeout");
 360       if (!tcp->isConnected()) { connectionDied(); return; } // return to stop this thread
 361     }
 362
 363     // Error or timeout.
 364
 365     if (!lastKAsent) // have not sent a KA
 366     {
 367       if (lastKArecv < (timeNow - 5))
 368       {
 369         logger->log("VDR", Log::DEBUG, "Sending KA packet");
 370         if (!sendKA(timeNow))
 371         {
 372           logger->log("VDR", Log::DEBUG, "Could not send KA, calling connectionDied");
 373           connectionDied();
 374           return;
 375         }
 376         lastKAsent = timeNow;
 377       }
 378     }
 379     else
 380     {
 381       if (lastKAsent <= (timeNow - 10))
 382       {
 383         logger->log("VDR", Log::DEBUG, "lastKA over 10s ago, calling connectionDied");
 384         connectionDied();
 385         return;
 386       }
 387     }
 388
 389     if (!readSuccess) continue; // no data was read but the connection is ok.
 390
 391     // Data was read
 392
 393     channelID = ntohl(channelID);
 394
 395     if (channelID == CHANNEL_REQUEST_RESPONSE)
 396     {
 397       if (!tcp->readData(&requestID, sizeof(ULONG))) break;
 398       requestID = ntohl(requestID);
 399       if (!tcp->readData(&userDataLength, sizeof(ULONG))) break;
 400       userDataLength = ntohl(userDataLength);
 401       if (userDataLength > 5000000) break; // how big can these packets get?
 402       userData = NULL;
 403       if (userDataLength > 0)
 404       {
 405         userData = malloc(userDataLength);
 406         if (!userData) break;
 407         if (!tcp->readData(userData, userDataLength)) break;
 408       }
 409
 410       vresp = new VDR_ResponsePacket();
 411       vresp->setResponse(requestID, reinterpret_cast<UCHAR*>(userData), userDataLength);
 412       logger->log("VDR", Log::DEBUG, "Rxd a response packet, requestID=%lu, len=%lu", requestID, userDataLength);
 413
 414       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
 415       {
 416         // If edFindAndCall returns true, edr was called and vresp was handed off.
 417         // else, delete vresp here.
 418         delete vresp;
 419       }
 420     }
 421     else if (channelID == CHANNEL_STREAM || channelID == CHANNEL_TVMEDIA)
 422     {
 423       if (!tcp->readData(&streamID, sizeof(ULONG))) break;
 424       streamID = ntohl(streamID);
 425
 426       if (!tcp->readData(&flag, sizeof(ULONG))) break;
 427       flag = ntohl(flag);
 428
 429       if (!tcp->readData(&userDataLength, sizeof(ULONG))) break;
 430       userDataLength = ntohl(userDataLength);
 431       userData = NULL;
 432       if (userDataLength > 0)
 433       {
 434         userData = malloc(userDataLength);
 435         if (!userData) break;
 436         if (!tcp->readData(userData, userDataLength)) break;
 437       }
 438
 439       vresp = new VDR_ResponsePacket();
 440       vresp->setStream(streamID, flag, reinterpret_cast<UCHAR*>(userData), userDataLength, channelID);
 441       //logger->log("VDR", Log::DEBUG, "Rxd a stream packet, streamID=%lu, flag=%lu, len=%lu", streamID, flag, userDataLength);
 442
 443       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
 444       {
 445         // If edFindAndCall returns true, edr was called and vresp was handed off.
 446         // else, delete vresp here.
 447         delete vresp;
 448       }
 449     }
 450     else if (channelID == CHANNEL_KEEPALIVE)
 451     {
 452       ULONG KAreply = 0;
 453       if (!tcp->readData(&KAreply, sizeof(ULONG))) break;
 454       KAreply = ntohl(KAreply);
 455       if (KAreply == lastKAsent) // successful KA response
 456       {
 457         lastKAsent = 0;
 458         lastKArecv = KAreply;
 459         logger->log("VDR", Log::DEBUG, "Rxd correct KA reply");
 460       }
 461     }
 462     else
 463     {
 464       logger->log("VDR", Log::ERR, "Rxd a response packet on channel %lu !!", channelID);
 465       break;
 466     }
 467     threadCheckExit();
 468
 469
 470     // Who deletes vresp?
 471     // If RR, the individual protocol functions must delete vresp.
 472     // If stream, the data and length is taken out in ed_cb_call and vresp is deleted there.
 473   }
 474
 475   connectionDied();
 476 }
 477
 478 void VDR::connectionDied()
 479 {
 480   // Called from within threadMethod to do cleanup if it decides the connection has died
 481
 482   connected = false; // though actually it could still be connected until someone calls vdr->disconnect
 483
 484   // Need to wake up any waiting channel 1 request-response threads
 485   // Normally this is done by a packet coming in with channelid and requestid
 486   // Instead, go through the list and for each channel 1 edr, make an empty vresp
 487   // An empty vresp will have userData == NULL, which means vresp->noResponse() == true
 488
 489   // If it's a stream receiver, generate a stream packet with flag == connection_lost
 490
 491   edLock();
 492   VDR_PacketReceiver* vdrpr;
 493   VDR_ResponsePacket* vresp;
 494   while(receivers.size())
 495   {
 496     vdrpr = dynamic_cast<VDR_PacketReceiver*>(*(receivers.begin()));
 497     if (vdrpr->receiverChannel == CHANNEL_REQUEST_RESPONSE)
 498     {
 499       vresp = new VDR_ResponsePacket();
 500       vresp->setResponse(vdrpr->requestSerialNumber, NULL, 0);
 501       logger->log("VDR", Log::DEBUG, "Timeouts: created blank response packet for request serial %lu", vdrpr->requestSerialNumber);
 502       edUnlock();
 503       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
 504       {
 505         // If edFindAndCall returns true, edr was called and vresp was handed off.
 506         // else, delete vresp here.
 507         logger->log("VDR", Log::ERR, "Timeouts: no waiting thread found for request serial %lu !!!", vdrpr->requestSerialNumber);
 508         delete vresp;
 509       }
 510       edLock();
 511     }
 512     else if (vdrpr->receiverChannel == CHANNEL_STREAM || vdrpr->receiverChannel == CHANNEL_TVMEDIA)
 513     {
 514       vresp = new VDR_ResponsePacket();
 515       vresp->setStream(vdrpr->streamID, 2 /* connection-lost flag */ , NULL, 0, vdrpr->receiverChannel);
 516       logger->log("VDR", Log::DEBUG, "Timeouts: created blank response packet for streamid %lu", vdrpr->streamID);
 517       edUnlock();
 518       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
 519       {
 520         // If edFindAndCall returns true, edr was called and vresp was handed off.
 521         // else, delete vresp here.
 522         logger->log("VDR", Log::ERR, "Timeouts: no waiting stream receiver found for streamid %lu !!!", vdrpr->streamID);
 523         delete vresp;
 524       }
 525       edLock();
 526
 527       for(EDRL::iterator i = receivers.begin(); i != receivers.end(); i++)
 528         if (dynamic_cast<VDR_PacketReceiver*>(*i) == vdrpr) { receivers.erase(i); break; }
 529     }
 530   }
 531   edUnlock();
 532   // Ok, all event receviers should be dealt with. just in case there weren't any, inform command
 533   logger->log("VDR", Log::DEBUG, "edUnlock at end of connectionDied");
 534
 535   Command::getInstance()->connectionLost();
 536 }
 537
 538 bool VDR::ed_cb_find(EDReceiver* edr, void* userTag)
 539 {
 540   // edr is a VDR_PacketReceiver object made in VDR::RequestResponse
 541   // userTag is a VDR_ResponsePacket made in threadMethod
 542
 543   VDR_PacketReceiver* vdrpr = dynamic_cast<VDR_PacketReceiver*>(edr);
 544   VDR_ResponsePacket* vresp = reinterpret_cast<VDR_ResponsePacket*>(userTag);
 545
 546   // Is vresp for vdrpr ?
 547
 548   ULONG packetChannel = vresp->getChannelID();
 549   //logger->log("VDR", Log::DEBUG, "TVMedia debug %d %d %x", vdrpr->receiverChannel,packetChannel,vdrpr);
 550   if (vdrpr->receiverChannel != packetChannel) return false;
 551
 552   if (packetChannel == CHANNEL_REQUEST_RESPONSE)
 553   {
 554     if (vdrpr->requestSerialNumber == vresp->getRequestID()) return true;
 555   }
 556   else if (packetChannel == CHANNEL_STREAM)
 557   {
 558     if (vdrpr->streamID == vresp->getStreamID()) return true;
 559   }
 560   else if (packetChannel == CHANNEL_TVMEDIA)
 561   {
 562     if (vdrpr->streamID == vresp->getStreamID()) return true;
 563   }
 564
 565   return false;
 566 }
 567
 568 VDR_ResponsePacket* VDR::RequestResponse(VDR_RequestPacket* vrp)
 569 {
 570   //logger->log("VDR", Log::DEBUG, "RR %lu", vrp->getOpcode());
 571
 572   if (!connected)
 573   {
 574     logger->log("VDR", Log::DEBUG, "RR when !connected");
 575     VDR_ResponsePacket* vresp = new VDR_ResponsePacket();
 576     return vresp; // "no-response" return
 577   }
 578
 579   // ED make new VDR and register
 580   // make a VDR_PacketReceiver
 581   // - init with serial number of request packet
 582
 583   VDR_PacketReceiver vdrpr;
 584 //  vdrpr.requestTime = time(NULL);
 585   vdrpr.receiverChannel = VDR::CHANNEL_REQUEST_RESPONSE;
 586   vdrpr.requestSerialNumber = vrp->getSerial();
 587
 588   edRegister(&vdrpr);
 589
 590   edLock();
 591
 592   if ((ULONG)tcp->sendData(vrp->getPtr(), vrp->getLen()) != vrp->getLen())
 593   {
 594     edUnlock();
 595     edUnregister(&vdrpr);
 596     VDR_ResponsePacket* vresp = new VDR_ResponsePacket();
 597     return vresp; // "no-response" return
 598   }
 599
 600   // Sleep and block this thread. The sleep unlocks the mutex
 601 //  logger->log("VDR", Log::DEBUG, "RR sleep - opcode %lu", vrp->getOpcode());
 602   edSleepThisReceiver(&vdrpr);
 603 //  logger->log("VDR", Log::DEBUG, "RR unsleep");
 604
 605   // Woken because a response packet has arrived, mutex will be locked
 606 //  logger->log("VDR", Log::DEBUG, "Packet delivered to me, requestID: %lu", vdrpr.save_vresp->getRequestID());
 607
 608   edUnlock();
 609   return vdrpr.save_vresp;
 610 }
 611
 612 bool VDR::sendKA(ULONG timeStamp)
 613 {
 614   char buffer[8];
 615
 616   int pos=0;
 617   ULONG ul=CHANNEL_KEEPALIVE;
 618   buffer[pos++]=(ul>>24)&0xff;
 619   buffer[pos++]=(ul>>16)&0xff;
 620   buffer[pos++]=(ul>>8)&0xff;
 621   buffer[pos++]=ul &0xff;
 622   ul=timeStamp;
 623   buffer[pos++]=(ul>>24)&0xff;
 624   buffer[pos++]=(ul>>16)&0xff;
 625   buffer[pos++]=(ul>>8)&0xff;
 626   buffer[pos++]=ul &0xff;
 627   if ((ULONG)tcp->sendData(buffer, 8) != 8) return false;
 628   return true;
 629 }
 630
 631 /////////////////////////////////////////////////////////////////////////////
 632
 633 // Here VDR takes a break for the VDR_PacketReceiver helper class
 634
 635 void VDR_PacketReceiver::call(void* userTag, bool& r_deregisterEDR, bool& r_wakeThread, bool& r_deleteEDR)
 636 {
 637   if (receiverChannel == VDR::CHANNEL_REQUEST_RESPONSE)
 638   {
 639     // It's a RR. Save vresp and, signal the waiting thread and return.
 640     // VDR::RequestResponse will be blocking waiting for this to happen.
 641     // That function has a pointer to this object and can read save_vresp.
 642     save_vresp = reinterpret_cast<VDR_ResponsePacket*>(userTag);
 643
 644     r_deregisterEDR = true;
 645     r_wakeThread = true;
 646     r_deleteEDR = false;
 647   }
 648   else if (receiverChannel == VDR::CHANNEL_STREAM)
 649   {
 650     // It's a stream packet. Pass off the stream data to streamReceiver,
 651     // delete the vresp. Keep this PacketReceiver for the next stream packet.
 652     VDR_ResponsePacket* vresp = reinterpret_cast<VDR_ResponsePacket*>(userTag);
 653     streamReceiver->streamReceive(vresp->getFlag(), vresp->getUserData(), vresp->getUserDataLength());
 654     delete vresp;
 655
 656     r_deregisterEDR = false;
 657     r_wakeThread = false;
 658     r_deleteEDR = false;
 659   }
 660   else if (receiverChannel == VDR::CHANNEL_TVMEDIA)
 661   {
 662     // It's TVMedia
 663     // Pass off the vresp object to OSDVector
 664     // This used to return true which would signal the cond (wake the thread)
 665     // but am going to try setting this to false because I don't know that there is a thread to signal
 666     // delete the EDR. It's made once per media requested and wasn't owned/deleted by anything before
 667
 668     VDR_ResponsePacket* vresp = reinterpret_cast<VDR_ResponsePacket*>(userTag);
 669     Log::getInstance()->log("VDR", Log::DEBUG, "TVMedia Pictures arrived VDR %x", vresp->getStreamID());
 670     OsdVector *osd=dynamic_cast<OsdVector*>(Osd::getInstance());
 671     if (osd) osd->getPictReader()->receivePicture(vresp);
 672     // else delete vresp; //nonsense // only rpi does CHANNEL_TVMEDIA, rpi has osdvector. therefore, can't get here.
 673
 674     r_deregisterEDR = true;
 675     r_wakeThread = false;
 676     r_deleteEDR = true;
 677   }
 678   else abort(); // unknown receiverChannel, should not happen
 679 }
 680
 681 /////////////////////////////////////////////////////////////////////////////
 682
 683 int VDR::doLogin(unsigned int* v_server_min, unsigned int* v_server_max, unsigned int* v_client,
 684                 ASLPrefList& list, int &subtitles)
 685 {
 686   VDR_RequestPacket vrp;
 687   if (!vrp.init(VDR_LOGIN, true, 6)) return 0;
 688
 689   char* mactemp[6];
 690   tcp->getMAC((char*)mactemp);
 691   if (!vrp.copyin((UCHAR*)mactemp, 6)) return 0;
 692
 693   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 694   if (vresp->noResponse()) { delete vresp; return 0; }
 695
 696   ULONG vdrTime = vresp->extractULONG();
 697   logger->log("VDR", Log::DEBUG, "vdrtime = %lu", vdrTime);
 698   long vdrTimeOffset = vresp->extractLONG();
 699   logger->log("VDR", Log::DEBUG, "offset = %i", vdrTimeOffset);
 700
 701   unsigned int version_min=vresp->extractULONG();
 702
 703   *v_server_min=version_min;
 704   unsigned int version_max=vresp->extractULONG();
 705   *v_server_max=version_max;
 706   *v_client=VOMP_PROTOCOL_VERSION;
 707
 708   if (0x00000302 <= version_max) {
 709           unsigned int numlangcodes = vresp->extractULONG();
 710           subtitles = vresp->extractULONG();
 711           list.clear();
 712           for (unsigned int i=0; i<numlangcodes; i++) {
 713                   ASLPref newpref;
 714                   newpref.audiopref = vresp->extractLONG();
 715                   newpref.subtitlepref = vresp->extractLONG();
 716                   newpref.langcode = vresp->extractStdString();
 717                   //logger->log("VDR", Log::DEBUG, "Langpref %s %d %d", newpref.langcode.c_str(),  newpref.audiopref,  newpref.subtitlepref);
 718                   list.push_back(newpref);
 719           }
 720   }
 721
 722
 723   delete vresp;
 724
 725   if ((version_min > VOMP_PROTOCOL_VERSION)
 726                   || (version_max < VOMP_PROTOCOL_VERSION) ) {
 727
 728           return 0;
 729
 730   }
 731
 732   // Set the time and zone on the MVP only
 733
 734 #if !defined(WIN32) && !defined(__ANDROID__)
 735   struct timespec currentTime;
 736   currentTime.tv_sec = vdrTime;
 737   currentTime.tv_nsec = 0;
 738
 739   int b = clock_settime(CLOCK_REALTIME, &currentTime);
 740
 741   logger->log("VDR", Log::DEBUG, "set clock = %u", b);
 742
 743   // now make a TZ variable and set it
 744   char sign;
 745   int hours;
 746   int minutes;
 747   if (vdrTimeOffset > 0) sign = '-';
 748   else sign = '+';
 749
 750   vdrTimeOffset = abs(vdrTimeOffset);
 751
 752   hours = (int)vdrTimeOffset / 3600;
 753   minutes = vdrTimeOffset % 3600;
 754
 755   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
 756
 757   minutes = (int)minutes / 60;
 758
 759   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
 760
 761   char newTZ[30];
 762   sprintf(newTZ, "MVP%c%i:%i", sign, hours, minutes);
 763   setenv("TZ", newTZ, 1);
 764
 765   logger->log("VDR", Log::DEBUG, "Timezone data: %s", newTZ);
 766 #endif
 767
 768   setCharset(Osd::getInstance()->charSet());
 769
 770   return 1;
 771 }
 772
 773 bool VDR::LogExtern(const char* logString)
 774 {
 775   if (!connected) return false;
 776   int stringLength = strlen(logString);
 777   int packetLength = stringLength + 8;
 778   char *buffer=new char[packetLength + 1];
 779   int pos=0;
 780   ULONG ul=CHANNEL_NETLOG;
 781   buffer[pos++]=(ul>>24)&0xff;
 782   buffer[pos++]=(ul>>16)&0xff;
 783   buffer[pos++]=(ul>>8)&0xff;
 784   buffer[pos++]=ul &0xff;
 785   ul=stringLength;
 786   buffer[pos++]=(ul>>24)&0xff;
 787   buffer[pos++]=(ul>>16)&0xff;
 788   buffer[pos++]=(ul>>8)&0xff;
 789   buffer[pos++]=ul &0xff;
 790
 791   strcpy(&buffer[8], logString);
 792
 793   if (tcp->sendData(buffer, packetLength) != packetLength)
 794   {
 795     connected = false; // stop the rest of the connection
 796     delete [] buffer;
 797     return false;
 798   }
 799   delete [] buffer;
 800   return true;
 801 }
 802
 803 bool VDR::setCharset(int charset)
 804 {
 805   VDR_RequestPacket vrp;
 806   if (!vrp.init(VDR_SETCHARSET, true, sizeof(ULONG))) return false;
 807   if (!vrp.addULONG(charset)) return false;
 808
 809   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 810   if (vresp->noResponse()) { delete vresp; return false; }
 811
 812   ULONG success = vresp->extractULONG();
 813   delete vresp;
 814
 815   if (!success) return false;
 816
 817   return true;
 818 }
 819
 820 bool VDR::getRecordingsList(RecMan* recman)
 821 {
 822   VDR_RequestPacket vrp;
 823   if (!vrp.init(VDR_GETRECORDINGLIST, true, 0)) return false;
 824
 825   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 826   if (vresp->noResponse()) { delete vresp; return false; }
 827
 828   ULONG totalSpace = vresp->extractULONG();
 829   ULONG freeSpace = vresp->extractULONG();
 830   ULONG percent = vresp->extractULONG();
 831
 832   recman->setStats(totalSpace, freeSpace, percent);
 833
 834   ULONG start;
 835   UCHAR isNew;
 836   char* name;
 837   char* fileName;
 838
 839   while (!vresp->end())
 840   {
 841     start = vresp->extractULONG();
 842     isNew = vresp->extractUCHAR();
 843     name = vresp->extractString();
 844     fileName = vresp->extractString();
 845     recman->addEntry(isNew, start, name, fileName);
 846     delete[] name;
 847     delete[] fileName;
 848   }
 849   delete vresp;
 850
 851   return true;
 852 }
 853
 854 int VDR::deleteRecording(char* fileName)
 855 {
 856   VDR_RequestPacket vrp;
 857   if (!vrp.init(VDR_DELETERECORDING, true, strlen(fileName) + 1)) return 0;
 858   if (!vrp.addString(fileName)) return 0;
 859
 860   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 861   if (vresp->noResponse()) { delete vresp; return 0; }
 862
 863   int toReturn = (int)vresp->extractULONG();
 864   delete vresp;
 865
 866   return toReturn;
 867 }
 868
 869 int VDR::deleteRecResume(char* fileName)
 870 {
 871   VDR_RequestPacket vrp;
 872   if (!vrp.init(VDR_DELETERECRESUME, true, strlen(fileName) + 1)) return 0;
 873   if (!vrp.addString(fileName)) return 0;
 874
 875   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 876   if (vresp->noResponse()) { delete vresp; return 0; }
 877
 878   int toReturn = (int)vresp->extractULONG();
 879   delete vresp;
 880
 881   return toReturn;
 882 }
 883
 884 char* VDR::moveRecording(char* fileName, char* newPath)
 885 {
 886   VDR_RequestPacket vrp;
 887   if (!vrp.init(VDR_MOVERECORDING, true, strlen(fileName) + 1 + strlen(newPath) + 1)) return NULL;
 888   if (!vrp.addString(fileName)) return NULL;
 889   if (!vrp.addString(newPath)) return NULL;
 890
 891   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 892   if (vresp->noResponse()) { delete vresp; return NULL; }
 893
 894   char* toReturn = NULL;
 895   int success = (int)vresp->extractULONG();
 896   if (success == 1)
 897   {
 898     toReturn = vresp->extractString();
 899   }
 900
 901   delete vresp;
 902
 903   return toReturn;
 904 }
 905
 906 ChannelList* VDR::getChannelsList(ULONG type)
 907 {
 908   VDR_RequestPacket vrp;
 909   if (!vrp.init(VDR_GETCHANNELLIST, true, 0)) return NULL;
 910
 911   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 912   if (vresp->noResponse()) { delete vresp; return NULL; }
 913
 914   ChannelList* chanList = new ChannelList();
 915
 916   bool h264support=Video::getInstance()->supportsh264();
 917   bool mpeg2support=Video::getInstance()->supportsmpeg2();
 918
 919   while (!vresp->end())
 920   {
 921     Channel* chan = new Channel();
 922     chan->number = vresp->extractULONG();
 923     chan->type = vresp->extractULONG();
 924     chan->name = vresp->extractString();
 925     chan->vstreamtype = vresp->extractULONG();
 926
 927     if (chan->type == type && ((chan->vstreamtype==0x1b && h264support)|| (chan->vstreamtype!=0x1b &&mpeg2support)) )
 928     {
 929       chanList->push_back(chan);
 930       logger->log("VDR", Log::DEBUG, "Have added a channel to list. %lu %lu %s", chan->number, chan->type, chan->name);
 931       if (chan->number > maxChannelNumber) maxChannelNumber = chan->number;
 932     }
 933     else
 934     {
 935       delete chan;
 936     }
 937   }
 938
 939   delete vresp;
 940
 941   if (maxChannelNumber > 99999)
 942     channelNumberWidth = 6;
 943   else if (maxChannelNumber > 9999)
 944     channelNumberWidth = 5;
 945   else if (maxChannelNumber > 999)
 946     channelNumberWidth = 4;
 947   else if (maxChannelNumber > 99)
 948     channelNumberWidth = 3;
 949   else if (maxChannelNumber > 9)
 950     channelNumberWidth = 2;
 951   else
 952     channelNumberWidth = 1;
 953
 954   return chanList;
 955 }
 956
 957 int VDR::streamChannel(ULONG number, StreamReceiver* tstreamReceiver)
 958 {
 959   VDR_RequestPacket vrp;
 960   if (!vrp.init(VDR_STREAMCHANNEL, true, sizeof(ULONG))) return 0;
 961   if (!vrp.addULONG(number)) return 0;
 962
 963
 964   VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
 965   vdrpr->receiverChannel = VDR::CHANNEL_STREAM;
 966   vdrpr->streamID = vrp.getSerial();
 967   vdrpr->streamReceiver = tstreamReceiver;
 968   edRegister(vdrpr);
 969   TEMP_SINGLE_VDR_PR = vdrpr;
 970
 971   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 972   if (vresp->noResponse())
 973   {
 974     delete vresp;
 975     edUnregister(vdrpr);
 976     delete vdrpr;
 977     return 0;
 978   }
 979
 980   int toReturn = (int)vresp->extractULONG();
 981   logger->log("VDR", Log::DEBUG, "VDR said %lu to start streaming request", toReturn);
 982   delete vresp;
 983
 984   return toReturn;
 985 }
 986
 987 int VDR::stopStreaming()
 988 {
 989   VDR_RequestPacket vrp;
 990   if (!vrp.init(VDR_STOPSTREAMING, true, 0)) return 0;
 991
 992   if (TEMP_SINGLE_VDR_PR) // this block only needs to be done if it was a live stream
 993                           // TEMP_SINGLE_VDR_PR will not be set unless we are streaming a channel
 994   {
 995     edUnregister(TEMP_SINGLE_VDR_PR);
 996     delete TEMP_SINGLE_VDR_PR;
 997     TEMP_SINGLE_VDR_PR = NULL;
 998   }
 999
1000   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1001   if (vresp->noResponse()) { delete vresp; return 0; }
1002
1003   int toReturn = (int)vresp->extractULONG();
1004   delete vresp;
1005
1006   return toReturn;
1007 }
1008
1009 UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived)
1010 {
1011   VDR_RequestPacket vrp;
1012   if (!vrp.init(VDR_GETBLOCK, true, sizeof(ULLONG) + sizeof(ULONG))) return NULL;
1013   if (!vrp.addULLONG(position)) return NULL;
1014   if (!vrp.addULONG(maxAmount)) return NULL;
1015
1016   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1017   if (vresp->noResponse()) { delete vresp; return NULL; }
1018
1019   if (vresp->serverError())
1020   {
1021     logger->log("VDR", Log::DEBUG, "Detected getblock 0");
1022     *amountReceived = 0;
1023     delete vresp;
1024     return NULL;
1025   }
1026
1027   // Special handling for getblock
1028   UCHAR* toReturn = vresp->getUserData();
1029   *amountReceived = vresp->getUserDataLength();
1030
1031   delete vresp;
1032
1033   return toReturn;
1034 }
1035
1036 ULLONG VDR::streamRecording(char* fileName, ULONG* totalFrames, bool* IsPesRecording)
1037 {
1038   VDR_RequestPacket vrp;
1039   if (!vrp.init(VDR_STREAMRECORDING, true, strlen(fileName) + 1)) return 0;
1040   if (!vrp.addString(fileName)) return 0;
1041
1042   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1043   if (vresp->noResponse()) { delete vresp; return 0; }
1044
1045   ULLONG lengthBytes = vresp->extractULLONG();
1046   ULONG lengthFrames = vresp->extractULONG();
1047   UCHAR isPesRecording = vresp->extractUCHAR();
1048   delete vresp;
1049
1050   *totalFrames = lengthFrames;
1051   *IsPesRecording = (isPesRecording);//convert Uchar to bool
1052
1053   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu, IsPesRecording %x", lengthBytes, lengthFrames, *IsPesRecording);
1054
1055   return lengthBytes;
1056 }
1057
1058 ULLONG VDR::positionFromFrameNumber(ULONG frameNumber)
1059 {
1060   VDR_RequestPacket vrp;
1061   if (!vrp.init(VDR_POSFROMFRAME, true, sizeof(ULONG))) return 0;
1062   if (!vrp.addULONG(frameNumber)) return 0;
1063
1064   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1065   if (vresp->noResponse()) { delete vresp; return 0; }
1066
1067   ULLONG position = vresp->extractULLONG();
1068   delete vresp;
1069
1070   logger->log("VDR", Log::DEBUG, "VDR said new position is: %llu", position);
1071
1072   return position;
1073 }
1074
1075 ULONG VDR::frameNumberFromPosition(ULLONG position)
1076 {
1077   VDR_RequestPacket vrp;
1078   if (!vrp.init(VDR_FRAMEFROMPOS, true, sizeof(ULLONG))) return 0;
1079   if (!vrp.addULLONG(position)) return 0;
1080
1081   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1082   if (vresp->noResponse()) { delete vresp; return 0; }
1083
1084   ULONG framenumber = vresp->extractULONG();
1085   delete vresp;
1086
1087   logger->log("VDR", Log::DEBUG, "VDR said new framenumber is: %u", framenumber);
1088
1089   return framenumber;
1090 }
1091
1092 bool VDR::getNextIFrame(ULONG frameNumber, ULONG direction, ULLONG* rfilePosition, ULONG* rframeNumber, ULONG* rframeLength)
1093 {
1094   VDR_RequestPacket vrp;
1095   if (!vrp.init(VDR_GETNEXTIFRAME, true, sizeof(ULONG)*2)) return false;
1096   if (!vrp.addULONG(frameNumber)) return false;
1097   if (!vrp.addULONG(direction)) return false;
1098
1099   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1100   if (vresp->noResponse()) { delete vresp; return false; }
1101
1102   if (vresp->serverError())
1103   {
1104     logger->log("VDR", Log::DEBUG, "Detected getNextIFrame error");
1105     delete vresp;
1106     return false;
1107   }
1108
1109   *rfilePosition = vresp->extractULLONG();
1110   *rframeNumber = vresp->extractULONG();
1111   *rframeLength = vresp->extractULONG();
1112
1113   delete vresp;
1114
1115   logger->log("VDR", Log::DEBUG, "VDR GNIF said %llu %lu %lu", *rfilePosition, *rframeNumber, *rframeLength);
1116
1117   return true;
1118 }
1119
1120 EventList* VDR::getChannelSchedule(ULONG number)
1121 {
1122   time_t now;
1123   time(&now);
1124   return getChannelSchedule(number, now, 24 * 60 * 60);
1125 }
1126
1127 EventList* VDR::getChannelSchedule(ULONG number, time_t start, ULONG duration)
1128 {
1129 // retrieve event list (vector of events) from vdr within filter window. duration is in seconds
1130
1131   VDR_RequestPacket vrp;
1132   if (!vrp.init(VDR_GETCHANNELSCHEDULE, true, sizeof(ULONG)*3)) return NULL;
1133   if (!vrp.addULONG(number)) return NULL;
1134   if (!vrp.addULONG(start)) return NULL;
1135   if (!vrp.addULONG(duration)) return NULL;
1136
1137   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1138   if (vresp->noResponse()) { delete vresp; return NULL; }
1139
1140   // received a ulong(0) - schedules error in the plugin
1141   if (vresp->serverError())
1142   {
1143     delete vresp;
1144     return NULL;
1145   }
1146
1147   EventList* eventList = new EventList();
1148
1149   while (!vresp->end())
1150   {
1151     Event* event = new Event();
1152     event->id = vresp->extractULONG();
1153     event->time = vresp->extractULONG();
1154     event->duration = vresp->extractULONG();
1155     event->title = vresp->extractString();
1156     event->subtitle = vresp->extractString();
1157     event->description = vresp->extractString();
1158     eventList->push_back(event);
1159   }
1160
1161   delete vresp;
1162
1163   logger->log("VDR", Log::DEBUG, "Success got to end of getChannelSchedule");
1164   return eventList;
1165 }
1166
1167 int VDR::configSave(const char* section, const char* key, const char* value)
1168 {
1169   VDR_RequestPacket vrp;
1170   if (!vrp.init(VDR_CONFIGSAVE, false, 0)) return 0;
1171   if (!vrp.addString(section)) return 0;
1172   if (!vrp.addString(key)) return 0;
1173   if (!vrp.addString(value)) return 0;
1174
1175   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1176   if (vresp->noResponse()) { delete vresp; return 0; }
1177
1178   int toReturn = (int)vresp->extractULONG();
1179   delete vresp;
1180
1181   return toReturn;
1182 }
1183
1184 char* VDR::configLoad(const char* section, const char* key)
1185 {
1186   VDR_RequestPacket vrp;
1187   if (!vrp.init(VDR_CONFIGLOAD, false, 0)) return NULL;
1188   if (!vrp.addString(section)) return NULL;
1189   if (!vrp.addString(key)) return NULL;
1190
1191   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1192   if (vresp->noResponse()) { delete vresp; return NULL; }
1193
1194   char* toReturn = vresp->extractString();
1195   delete vresp;
1196
1197   return toReturn;
1198 }
1199
1200 RecTimerList* VDR::getRecTimersList()
1201 {
1202   VDR_RequestPacket vrp;
1203   if (!vrp.init(VDR_GETTIMERS, true, 0)) return NULL;
1204
1205   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1206   if (vresp->noResponse()) { delete vresp; return NULL; }
1207
1208   RecTimerList* recTimerList = new RecTimerList();
1209
1210   ULONG numTimers = vresp->extractULONG();
1211   if (numTimers > 0)
1212   {
1213     RecTimer* newRecTimer;
1214     char* tempString;
1215
1216     while (!vresp->end())
1217     {
1218       newRecTimer = new RecTimer();
1219       newRecTimer->active = vresp->extractULONG();
1220       newRecTimer->recording = vresp->extractULONG();
1221       newRecTimer->pending = vresp->extractULONG();
1222       newRecTimer->priority = vresp->extractULONG();
1223       newRecTimer->lifeTime = vresp->extractULONG();
1224       newRecTimer->channelNumber = vresp->extractULONG();
1225       newRecTimer->startTime = vresp->extractULONG();
1226       newRecTimer->stopTime = vresp->extractULONG();
1227       newRecTimer->day = vresp->extractULONG();
1228       newRecTimer->weekDays = vresp->extractULONG();
1229
1230       tempString = vresp->extractString();
1231       newRecTimer->setFile(tempString);
1232       delete[] tempString;
1233
1234       recTimerList->push_back(newRecTimer);
1235       logger->log("VDR", Log::DEBUG, "TL: %lu %lu %lu %lu %lu %lu %lu %lu %s",
1236         newRecTimer->active, newRecTimer->recording, newRecTimer->pending, newRecTimer->priority, newRecTimer->lifeTime,
1237         newRecTimer->channelNumber, newRecTimer->startTime, newRecTimer->stopTime, newRecTimer->getFile());
1238     }
1239   }
1240
1241   delete vresp;
1242
1243   sort(recTimerList->begin(), recTimerList->end(), RecTimerSorter());
1244
1245   return recTimerList;
1246 }
1247
1248 ULONG VDR::setEventTimer(char* timerString)
1249 {
1250   VDR_RequestPacket vrp;
1251   if (!vrp.init(VDR_SETTIMER, true, strlen(timerString) + 1)) return 0;
1252   if (!vrp.addString(timerString)) return 0;
1253
1254   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1255   if (vresp->noResponse()) { delete vresp; return 0; }
1256
1257   ULONG toReturn = vresp->extractULONG();
1258   delete vresp;
1259
1260   return toReturn;
1261 }
1262
1263 RecInfo* VDR::getRecInfo(char* fileName)
1264 {
1265   VDR_RequestPacket vrp;
1266   if (!vrp.init(VDR_GETRECINFO2, true, strlen(fileName) + 1)) return NULL;
1267   if (!vrp.addString(fileName)) return NULL;
1268   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1269
1270   if (vresp->noResponse()) { delete vresp; return NULL; }
1271
1272   if (vresp->serverError())
1273   {
1274     logger->log("VDR", Log::DEBUG, "Could not get rec info");
1275     delete vresp;
1276     return NULL;
1277   }
1278
1279   RecInfo* recInfo = new RecInfo();
1280
1281   recInfo->timerStart = vresp->extractULONG();
1282   recInfo->timerEnd = vresp->extractULONG();
1283   recInfo->resumePoint = vresp->extractULONG();
1284   recInfo->summary = vresp->extractString();
1285
1286   ULONG numComponents = vresp->extractULONG();
1287   if (numComponents)
1288   {
1289     recInfo->setNumComponents(numComponents);
1290     for (ULONG i = 0; i < numComponents; i++)
1291     {
1292       recInfo->streams[i] = vresp->extractUCHAR();
1293       recInfo->types[i] = vresp->extractUCHAR();
1294       recInfo->languages[i] = vresp->extractString();
1295       recInfo->descriptions[i] = vresp->extractString();
1296     }
1297   }
1298   recInfo->fps=vresp->extractdouble();
1299   recInfo->title=vresp->extractString();
1300
1301   // New stuff
1302   recInfo->channelName = vresp->extractString();
1303   recInfo->duration = vresp->extractULONG();
1304   recInfo->fileSize = vresp->extractULONG();
1305   recInfo->priority = vresp->extractULONG();
1306   recInfo->lifetime = vresp->extractULONG();
1307
1308   recInfo->print();
1309
1310   delete vresp;
1311   return recInfo;
1312 }
1313
1314 // FIXME obselete
1315 ULLONG VDR::rescanRecording(ULONG* totalFrames)
1316 {
1317   VDR_RequestPacket vrp;
1318   if (!vrp.init(VDR_RESCANRECORDING, true, 0)) return 0;
1319
1320   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1321   if (vresp->noResponse()) { delete vresp; return 0; }
1322
1323   ULLONG lengthBytes = vresp->extractULLONG();
1324   ULONG lengthFrames = vresp->extractULONG();
1325   delete vresp;
1326
1327   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
1328
1329   *totalFrames = lengthFrames;
1330   return lengthBytes;
1331 }
1332
1333 MarkList* VDR::getMarks(char* fileName)
1334 {
1335   VDR_RequestPacket vrp;
1336   if (!vrp.init(VDR_GETMARKS, true, strlen(fileName) + 1)) return NULL;
1337   if (!vrp.addString(fileName)) return NULL;
1338
1339   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1340   if (vresp->noResponse()) { delete vresp; return NULL; }
1341
1342   if (vresp->serverError())
1343   {
1344     delete vresp;
1345     return NULL;
1346   }
1347
1348   MarkList* markList = new MarkList();
1349
1350   while (!vresp->end())
1351   {
1352     Mark* mark = new Mark();
1353     mark->pos = vresp->extractULONG();
1354
1355     markList->push_back(mark);
1356     logger->log("VDR", Log::DEBUG, "Have added a mark to list. %lu", mark->pos);
1357   }
1358
1359   delete vresp;
1360
1361   return markList;
1362 }
1363
1364 void VDR::getChannelPids(Channel* channel)
1365 {
1366   VDR_RequestPacket vrp;
1367   if (!vrp.init(VDR_GETCHANNELPIDS, true, sizeof(ULONG))) return ;
1368   if (!vrp.addULONG(channel->number)) return ;
1369
1370   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1371   if (vresp->noResponse()) { delete vresp; return ; }
1372
1373   // Format of response
1374   // vpid
1375   // number of apids
1376   // {
1377   //    apid
1378   //    lang string
1379   // }
1380
1381   channel->vpid = vresp->extractULONG();
1382   channel->vstreamtype = vresp->extractULONG();
1383   channel->numAPids = vresp->extractULONG();
1384
1385   for (ULONG i = 0; i < channel->numAPids; i++)
1386   {
1387     apid newapid;
1388     newapid.pid = vresp->extractULONG();
1389     char * name=vresp->extractString();
1390     strncpy(newapid.desc,name,9);
1391     delete [] name;
1392     channel->apids.push_back(newapid);
1393   }
1394
1395   channel->numDPids = vresp->extractULONG();
1396
1397   for (ULONG i = 0; i < channel->numDPids; i++)
1398   {
1399     apid newdpid;
1400     newdpid.pid = vresp->extractULONG();
1401     char * name=vresp->extractString();
1402     strncpy(newdpid.desc,name,9);
1403     delete [] name;
1404     channel->dpids.push_back(newdpid);
1405   }
1406
1407   channel->numSPids = vresp->extractULONG();
1408
1409   for (ULONG i = 0; i < channel->numSPids; i++)
1410   {
1411     apid newspid;
1412     newspid.pid = vresp->extractULONG();
1413     char * name=vresp->extractString();
1414     strncpy(newspid.desc,name,9);
1415     delete [] name;
1416     channel->spids.push_back(newspid);
1417   }
1418   channel->tpid = vresp->extractULONG();
1419   // extension
1420   for (ULONG i = 0; i < channel->numAPids; i++)
1421   {
1422           channel->apids[i].type = vresp->extractULONG();
1423   }
1424   for (ULONG i = 0; i < channel->numDPids; i++)
1425   {
1426           channel->dpids[i].type = vresp->extractULONG();
1427   }
1428   for (ULONG i = 0; i < channel->numSPids; i++)
1429   {
1430           channel->spids[i].type = vresp->extractULONG();
1431           channel->spids[i].data1 = vresp->extractULONG();
1432           channel->spids[i].data2 = vresp->extractULONG();
1433   }
1434
1435   delete vresp;
1436
1437   return ;
1438 }
1439
1440 #ifdef VOMP_MEDIAPLAYER
1441 MediaList * VDR::getRootList() {
1442   return getMediaList(NULL);
1443 }
1444 /**
1445   * media List Request:
1446   * mediaURI
1447   * Media List response:
1448   * mediaList
1449 */
1450 MediaList* VDR::getMediaList(const MediaURI * root)
1451 {
1452   logger->log("VDR", Log::DEBUG, "getMediaList %s,d=%s, prov=%d", (root?root->getName():"NULL"),
1453       ((root && root->hasDisplayName())?root->getDisplayName():"NULL"),
1454       (root?root->getProvider():providerId));
1455   MediaURI remoteURI(root);
1456   VDR_GetMediaListRequest request(&remoteURI);
1457   SerializeBuffer *vrp=prepareRequest(&request);
1458   if (!vrp) {
1459     logger->log("VDR", Log::ERR, "getMediaList unable to create command");
1460     return NULL;
1461   }
1462
1463   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1464   if (!vresp) {
1465     Command::getInstance()->connectionLost();
1466     return NULL;
1467   }
1468
1469   MediaList *rt=new MediaList(NULL);
1470   ULONG rtflags=0;
1471   VDR_GetMediaListResponse resp(&rtflags,rt);
1472   if (decodeResponse(vresp,&resp) != 0) {
1473     return NULL;
1474   }
1475   return rt;
1476 }
1477
1478 /**
1479   * get image Request:
1480   * uri,x,y, channel
1481   * get media response:
1482   * 4 flags
1483   * 8 len of image
1484 */
1485 int VDR::openMedium(ULONG channel,const MediaURI *uri,  ULLONG * size, ULONG x, ULONG y)
1486 {
1487   MediaURI remoteURI(uri);
1488   VDR_OpenMediumRequest request(&channel,&remoteURI,&x,&y);
1489   *size=0;
1490   SerializeBuffer *vrp=prepareRequest(&request);
1491   if (!vrp) {
1492     logger->log("VDR", Log::ERR, "openMedium unable to create command");
1493     return -1;
1494   }
1495   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1496   if (!vresp) {
1497     Command::getInstance()->connectionLost();
1498     return -1;
1499   }
1500   ULONG flags=0;
1501   VDR_OpenMediumResponse response(&flags,size);
1502   if (decodeResponse(vresp,&response) != 0) {
1503     return -1;
1504   }
1505   logger->log("VDR", Log::DEBUG, "openMedia len=%llu", *size);
1506   return 0;
1507 }
1508
1509 /**
1510   * getMediaBlock - no separate response class - simple data block
1511   * resp
1512   * packet
1513   */
1514 int VDR::getMediaBlock(ULONG channel, ULLONG position, ULONG maxAmount, ULONG* amountReceived, unsigned char **buffer)
1515 {
1516   *amountReceived=0;
1517   VDR_GetMediaBlockRequest request(&channel,&position,&maxAmount);
1518   SerializeBuffer *vrp=prepareRequest(&request);
1519   if (!vrp) {
1520     logger->log("VDR", Log::ERR, "getMediaBlock unable to create command");
1521     return -1;
1522   }
1523   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1524   if (!vresp) {
1525     Command::getInstance()->connectionLost();
1526     return -1;
1527   }
1528
1529   // Special handling for getblock
1530   *amountReceived = (ULONG)(vresp->getEnd()-vresp->getStart());
1531   *buffer = vresp->steelBuffer();
1532   delete vresp;
1533   return 0;
1534 }
1535
1536 /**
1537   * VDR_GETMEDIAINFO
1538   * channel
1539   * rt
1540   * flags
1541   * info
1542   */
1543
1544 int VDR::getMediaInfo(ULONG channel, MediaInfo * result) {
1545   if (! result) return -1;
1546   VDR_GetMediaInfoRequest request(&channel);
1547   SerializeBuffer *vrp=prepareRequest(&request);
1548   if (!vrp) {
1549     logger->log("VDR", Log::ERR, "getMediaInfo unable to create command");
1550     return -1;
1551   }
1552   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1553   if (!vresp) {
1554     Command::getInstance()->connectionLost();
1555     return -1;
1556   }
1557
1558   ULONG flags=0;
1559   VDR_GetMediaInfoResponse response(&flags,result);
1560   if (decodeResponse(vresp,&response) != 0) {
1561     return -1;
1562   }
1563   return 0;
1564 }
1565
1566 /**
1567   * VDR_CLOSECHANNEL
1568   * channel
1569   * rt
1570   * flags
1571   */
1572
1573 int VDR::closeMediaChannel(ULONG channel) {
1574   VDR_CloseMediaChannelRequest request(&channel);
1575   SerializeBuffer *vrp=prepareRequest(&request);
1576   if (!vrp) {
1577     logger->log("VDR", Log::ERR, "closeMediaChannel unable to create command");
1578     return -1;
1579   }
1580   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1581   if (!vresp) {
1582     Command::getInstance()->connectionLost();
1583     return -1;
1584   }
1585   ULONG flags;
1586   VDR_CloseMediaChannelResponse response(&flags);
1587   if (decodeResponse(vresp,&response) != 0) return -1;
1588   return (flags != 0)?-1:0;
1589 }
1590
1591 #endif
1592
1593
1594 int VDR::deleteTimer(RecTimer* delTimer)
1595 {
1596   logger->log("VDR", Log::DEBUG, "Delete timer called");
1597
1598   VDR_RequestPacket vrp;
1599   if (!vrp.init(VDR_DELETETIMER, false, 0)) return 0;
1600   if (!vrp.addULONG(delTimer->channelNumber)) return 0;
1601   if (!vrp.addULONG(delTimer->weekDays)) return 0;
1602   if (!vrp.addULONG(delTimer->day)) return 0;
1603   if (!vrp.addULONG(delTimer->startTime)) return 0;
1604   if (!vrp.addULONG(delTimer->stopTime)) return 0;
1605
1606   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1607   if (vresp->noResponse()) { delete vresp; return 0; }
1608
1609   int toReturn = (int)vresp->extractULONG();
1610   delete vresp;
1611
1612   return toReturn;
1613 }
1614
1615 I18n::lang_code_list VDR::getLanguageList()
1616 {
1617   I18n::lang_code_list CodeList;
1618   CodeList["en"] = "English"; // Default entry
1619   VDR_RequestPacket vrp;
1620   if (!vrp.init(VDR_GETLANGUAGELIST, false, 0)) return CodeList;
1621   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1622   if (vresp->noResponse() || vresp->end())
1623   {
1624     delete vresp;
1625     return CodeList;
1626   }
1627   CodeList.clear();
1628   while (!vresp->end())
1629   {
1630     char* c_code = vresp->extractString();
1631     char* c_name = vresp->extractString();
1632     std::string code = c_code;
1633     std::string name = c_name;
1634     CodeList[code] = name;
1635     delete[] c_code;
1636     delete[] c_name;
1637   }
1638   delete vresp;
1639   return CodeList;
1640 }
1641
1642 int VDR::getLanguageContent(const std::string code, I18n::trans_table& texts)
1643 {
1644   VDR_RequestPacket vrp;
1645   if (!vrp.init(VDR_GETLANGUAGECONTENT, false, 0)) return 0;
1646   if (!vrp.addString(code.c_str())) return 0;
1647   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1648   if (vresp->noResponse()) { delete vresp; return 0; }
1649   texts.clear();
1650   while (!vresp->end())
1651   {
1652     char* c_key = vresp->extractString();
1653     char* c_text = vresp->extractString();
1654     std::string key = c_key;
1655     std::string text = c_text;
1656     texts[key] = text;
1657     delete[] c_key;
1658     delete[] c_text;
1659   }
1660   delete vresp;
1661   return 1;
1662 }
1663
1664 void VDR::shutdownVDR()
1665 {
1666   if(doVDRShutdown)
1667     logger->log("VDR", Log::DEBUG, "Shutting down vdr");
1668   else
1669     logger->log("VDR", Log::DEBUG, "Shutting down vomp only");
1670
1671   if(!doVDRShutdown || !connected)
1672     return;
1673
1674   VDR_RequestPacket vrp;
1675   logger->log("VDR", Log::DEBUG, "Sending shutdown");
1676   if (!vrp.init(VDR_SHUTDOWN, false, 0)) return;
1677   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1678   delete vresp;
1679
1680   logger->log("VDR", Log::DEBUG, "VDR shutdown");
1681 }
1682
1683 void VDR::getScraperEventType(char * fileName, int & movieID,
1684                 int & seriesID, int & episodeID)
1685 {
1686         movieID = 0;
1687         seriesID = 0;
1688         episodeID = 0;
1689         VDR_RequestPacket vrp;
1690         if (!vrp.init(VDR_GETRECSCRAPEREVENTTYPE, true, strlen(fileName) + 1)) return;
1691         if (!vrp.addString(fileName)) return ;
1692         Log::getInstance()->log("Recording", Log::DEBUG, "Before Response ");
1693         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1694         Log::getInstance()->log("Recording", Log::DEBUG, "After Response ");
1695         if (vresp->noResponse()) { delete vresp; return ; }
1696         int type = vresp->extractUCHAR();
1697         if (type == 0) //serie
1698         {
1699                 seriesID = vresp->extractLONG();
1700                 episodeID = vresp->extractLONG();
1701         } else if (type == 1) //movie
1702         {
1703                 movieID = vresp->extractLONG();
1704         }
1705         delete vresp;
1706
1707 }
1708
1709 void VDR::getScraperEventType(UINT channelid, UINT eventid, int & movieID,
1710                 int & seriesID, int & episodeID, int & epgImage )
1711 {
1712         movieID = 0;
1713         seriesID = 0;
1714         episodeID = 0;
1715         epgImage = 0;
1716         VDR_RequestPacket vrp;
1717         if (!vrp.init(VDR_GETEVENTSCRAPEREVENTTYPE, false, 0)) return;
1718         if (!vrp.addULONG(channelid)) return ;
1719         if (!vrp.addULONG(eventid)) return ;
1720         Log::getInstance()->log("Recording", Log::DEBUG, "Before Response ");
1721         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1722         Log::getInstance()->log("Recording", Log::DEBUG, "After Response ");
1723         if (vresp->noResponse()) { delete vresp; return ; }
1724         int type = vresp->extractUCHAR();
1725         if (type == 0) //serie
1726         {
1727                 seriesID = vresp->extractLONG();
1728                 episodeID = vresp->extractLONG();
1729         } else if (type == 1) //movie
1730         {
1731                 movieID = vresp->extractLONG();
1732         }
1733         epgImage = vresp->extractLONG();
1734         delete vresp;
1735
1736 }
1737
1738 MovieInfo *VDR::getScraperMovieInfo(int movieID)
1739 {
1740         VDR_RequestPacket vrp;
1741         if (!vrp.init(VDR_GETSCRAPERMOVIEINFO, false, 0)) return NULL;
1742         if (!vrp.addULONG(movieID)) return NULL;
1743         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1744         if (vresp->noResponse()) { delete vresp; return NULL; }
1745         MovieInfo * movieinf= new MovieInfo();
1746
1747         movieinf->id=movieID;
1748         movieinf->title = vresp->extractStdString();
1749         movieinf->originalTitle = vresp->extractStdString();
1750         movieinf->tagline = vresp->extractStdString();
1751         movieinf->overview = vresp->extractStdString();
1752         movieinf->adult = vresp->extractUCHAR();
1753         movieinf->collectionName = vresp->extractStdString();
1754
1755         movieinf->budget = vresp->extractLONG();
1756         movieinf->revenue = vresp->extractLONG();
1757         movieinf->genres = vresp->extractStdString();
1758         movieinf->homepage = vresp->extractStdString();
1759         movieinf->releaseDate = vresp->extractStdString();
1760         movieinf->runtime = vresp->extractLONG();
1761         movieinf->popularity = vresp->extractdouble();
1762         movieinf->voteAverage = vresp->extractdouble();
1763         movieinf->poster.width = vresp->extractULONG();
1764         movieinf->poster.height = vresp->extractULONG();
1765         movieinf->poster.info.setMovieInfo(movieinf);
1766         movieinf->poster.info.setElement(0,0);
1767         movieinf->fanart.width = vresp->extractULONG();
1768         movieinf->fanart.height = vresp->extractULONG();
1769         movieinf->fanart.info.setMovieInfo(movieinf);
1770         movieinf->fanart.info.setElement(1,0);
1771         movieinf->collectionPoster.width = vresp->extractULONG();
1772         movieinf->collectionPoster.height = vresp->extractULONG();
1773         movieinf->collectionPoster.info.setMovieInfo(movieinf);
1774         movieinf->collectionPoster.info.setElement(2,0);
1775         movieinf->collectionFanart.width = vresp->extractULONG();
1776         movieinf->collectionFanart.height = vresp->extractULONG();
1777         movieinf->collectionFanart.info.setMovieInfo(movieinf);
1778         movieinf->collectionFanart.info.setElement(3,0);
1779         ULONG num_actors =  vresp->extractULONG();
1780         movieinf->actors.clear();
1781         movieinf->actors.reserve(num_actors);
1782         for (ULONG acty=0; acty < num_actors; acty++) {
1783                 Actor new_act;
1784                 new_act.name =  vresp->extractStdString();
1785                 new_act.role =  vresp->extractStdString();
1786                 new_act.thumb.width = vresp->extractULONG();
1787                 new_act.thumb.height = vresp->extractULONG();
1788                 new_act.thumb.info.setMovieInfo(movieinf);
1789                 new_act.thumb.info.setElement(4,acty);
1790                 movieinf->actors.push_back(new_act);
1791         }
1792
1793
1794         delete vresp;
1795         return movieinf;
1796
1797 }
1798
1799 SeriesInfo *VDR::getScraperSeriesInfo(int seriesID, int episodeID)
1800 {
1801         VDR_RequestPacket vrp;
1802         if (!vrp.init(VDR_GETSCRAPERSERIESINFO, false, 0)) return NULL;
1803         if (!vrp.addULONG(seriesID)) return NULL;
1804         if (!vrp.addULONG(episodeID)) return NULL;
1805
1806         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1807         if (vresp->noResponse()) { delete vresp; return 0; }
1808         SeriesInfo * seriesinf= new SeriesInfo();
1809
1810         seriesinf->id=seriesID;
1811
1812
1813         seriesinf->name = vresp->extractStdString();
1814         seriesinf->overview = vresp->extractStdString();
1815         seriesinf->firstAired = vresp->extractStdString();
1816         seriesinf->network = vresp->extractStdString();
1817         seriesinf->genre = vresp->extractStdString();
1818         seriesinf->rating =  vresp->extractdouble();
1819         seriesinf->status = vresp->extractStdString();
1820
1821
1822         seriesinf->episode.episodeid=episodeID;
1823         seriesinf->episode.number = vresp->extractLONG();
1824         seriesinf->episode.season = vresp->extractLONG();
1825         seriesinf->episode.name =  vresp->extractStdString();
1826         seriesinf->episode.firstAired =  vresp->extractStdString();
1827         seriesinf->episode.guestStars =  vresp->extractStdString();
1828         seriesinf->episode.overview =  vresp->extractStdString();
1829         seriesinf->episode.rating = vresp->extractdouble();
1830         seriesinf->episode.image.width =  vresp->extractULONG();
1831         seriesinf->episode.image.height =  vresp->extractULONG();
1832         seriesinf->episode.image.info.setSeriesInfo(seriesinf);
1833         seriesinf->episode.image.info.setElement(0,0);
1834
1835
1836         ULONG num_actors =  vresp->extractULONG();
1837         seriesinf->actors.clear();
1838         seriesinf->actors.reserve(num_actors);
1839         for (ULONG acty=0; acty < num_actors; acty++) {
1840                 Actor new_act;
1841                 new_act.name =  vresp->extractStdString();
1842                 new_act.role =  vresp->extractStdString();
1843                 new_act.thumb.width = vresp->extractULONG();
1844                 new_act.thumb.height = vresp->extractULONG();
1845                 new_act.thumb.info.setSeriesInfo(seriesinf);
1846                 new_act.thumb.info.setElement(1,acty);
1847                 seriesinf->actors.push_back(new_act);
1848         }
1849         ULONG num_posters =  vresp->extractULONG();
1850         for (ULONG medias = 0; medias < num_posters; medias++ ) {
1851                 TVMedia media;
1852                 media.info.setSeriesInfo(seriesinf);
1853                 media.info.setElement(2,medias);
1854                 media.width =  vresp->extractULONG();
1855                 media.height = vresp->extractULONG();
1856                 seriesinf->posters.push_back(media);
1857         }
1858
1859         ULONG num_banners =  vresp->extractULONG();
1860         for (ULONG medias = 0; medias < num_banners; medias++ ) {
1861                 TVMedia media;
1862                 media.info.setSeriesInfo(seriesinf);
1863                 media.info.setElement(3,medias);
1864                 media.width =  vresp->extractULONG();
1865                 media.height = vresp->extractULONG();
1866                 seriesinf->banners.push_back(media);
1867         }
1868         ULONG num_fanarts =  vresp->extractULONG();
1869         for (ULONG medias = 0; medias < num_fanarts; medias++ ) {
1870                 TVMedia media;
1871                 media.info.setSeriesInfo(seriesinf);
1872                 media.info.setElement(4,medias);
1873                 media.width =  vresp->extractULONG();
1874                 media.height = vresp->extractULONG();
1875                 seriesinf->fanart.push_back(media);
1876         }
1877         seriesinf->seasonposter.width = vresp->extractULONG();
1878         seriesinf->seasonposter.height = vresp->extractULONG();
1879         seriesinf->seasonposter.info.setSeriesInfo(seriesinf);
1880         seriesinf->seasonposter.info.setElement(5,0);
1881
1882         delete vresp;
1883         return seriesinf;
1884
1885 }
1886
1887 ULONG VDR::loadTVMedia(TVMediaInfo& tvmedia)
1888 {
1889         VDR_RequestPacket vrp;
1890
1891         if (!vrp.init(VDR_LOADTVMEDIA, false, 0)) return ULONG_MAX;
1892         if (!vrp.addULONG(tvmedia.type)) return ULONG_MAX;
1893         if (!vrp.addULONG(tvmedia.primary_id)) return ULONG_MAX;
1894         if (!vrp.addULONG(tvmedia.secondary_id)) return ULONG_MAX;
1895         if (!vrp.addULONG(tvmedia.type_pict)) return ULONG_MAX;
1896         if (!vrp.addULONG(tvmedia.container)) return ULONG_MAX;
1897         if (!vrp.addULONG(tvmedia.container_member)) return ULONG_MAX;
1898 /*      Log::getInstance()->log("VDR", Log::DEBUG, "TVMedia with ID %d %d; %d %d %d %d;%d",
1899                         tvmedia.primary_id,tvmedia.secondary_id,tvmedia.type,tvmedia.type_pict,
1900                         tvmedia.container,tvmedia.container_member,vrp.getSerial());*/
1901
1902
1903         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1904         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1905         vdrpr->streamID = vrp.getSerial();
1906         vdrpr->streamReceiver = NULL;
1907         edRegister(vdrpr);
1908
1909
1910         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1911         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1912         delete vresp;
1913
1914         return vrp.getSerial();
1915 }
1916
1917 ULONG VDR::loadTVMediaRecThumb(TVMediaInfo & media)
1918 {
1919
1920         VDR_RequestPacket vrp;
1921
1922         if (!vrp.init(VDR_LOADTVMEDIARECTHUMB, false, 0)) return ULONG_MAX;
1923         if (!vrp.addString(media.primary_name.c_str())) return ULONG_MAX;
1924
1925         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1926         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1927         vdrpr->streamID = vrp.getSerial();
1928         vdrpr->streamReceiver = NULL;
1929         edRegister(vdrpr);
1930
1931
1932         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1933         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1934         delete vresp;
1935
1936         return vrp.getSerial();
1937 }
1938
1939 ULONG VDR::loadTVMediaEventThumb(TVMediaInfo & media)
1940 {
1941
1942         VDR_RequestPacket vrp;
1943
1944         if (!vrp.init(VDR_LOADTVMEDIAEVENTTHUMB, false, 0)) return ULONG_MAX;
1945         if (!vrp.addULONG(media.primary_id)) return ULONG_MAX;
1946         if (!vrp.addULONG(media.secondary_id)) return ULONG_MAX;
1947
1948         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1949         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1950         vdrpr->streamID = vrp.getSerial();
1951         vdrpr->streamReceiver = NULL;
1952         edRegister(vdrpr);
1953
1954
1955         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1956         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1957         delete vresp;
1958
1959         return vrp.getSerial();
1960 }
1961
1962 ULONG VDR::loadChannelLogo(TVMediaInfo & media)
1963 {
1964
1965         VDR_RequestPacket vrp;
1966
1967         if (!vrp.init(VDR_LOADCHANNELLOGO, false, 0)) return ULONG_MAX;
1968         if (!vrp.addULONG(media.primary_id)) return ULONG_MAX;
1969
1970         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1971         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1972         vdrpr->streamID = vrp.getSerial();
1973         vdrpr->streamReceiver = NULL;
1974         edRegister(vdrpr);
1975
1976
1977         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1978         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1979         delete vresp;
1980
1981 //      Log::getInstance()->log("VDR", Log::DEBUG, "TVMedia Channel Logo %d %x",
1982 //                              media.primary_id,vrp.getSerial());
1983
1984         return vrp.getSerial();
1985 }