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; // FIXME what is this
 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   edMutex.lock();
 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       edMutex.unlock();
 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       edMutex.lock();
 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       edMutex.unlock();
 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       edMutex.lock();
 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   edMutex.unlock();
 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   edMutex.lock();
 591
 592
 593   if (static_cast<ULONG>(tcp->sendData(vrp->getPtr(), vrp->getLen())) != vrp->getLen())
 594   {
 595     edMutex.unlock();
 596     edUnregister(&vdrpr);
 597     VDR_ResponsePacket* vresp = new VDR_ResponsePacket();
 598     return vresp; // "no-response" return
 599   }
 600
 601   // Sleep and block this thread. The sleep unlocks the mutex
 602 //  logger->log("VDR", Log::DEBUG, "RR sleep - opcode %lu", vrp->getOpcode());
 603   edSleepThisReceiver(&vdrpr);
 604 //  logger->log("VDR", Log::DEBUG, "RR unsleep");
 605
 606   // Woken because a response packet has arrived, mutex will be locked
 607 //  logger->log("VDR", Log::DEBUG, "Packet delivered to me, requestID: %lu", vdrpr.save_vresp->getRequestID());
 608
 609   edMutex.unlock();
 610   return vdrpr.save_vresp;
 611 }
 612
 613 bool VDR::sendKA(ULONG timeStamp)
 614 {
 615   char buffer[8];
 616
 617   int pos=0;
 618   ULONG ul=CHANNEL_KEEPALIVE;
 619   buffer[pos++]=(ul>>24)&0xff;
 620   buffer[pos++]=(ul>>16)&0xff;
 621   buffer[pos++]=(ul>>8)&0xff;
 622   buffer[pos++]=ul &0xff;
 623   ul=timeStamp;
 624   buffer[pos++]=(ul>>24)&0xff;
 625   buffer[pos++]=(ul>>16)&0xff;
 626   buffer[pos++]=(ul>>8)&0xff;
 627   buffer[pos++]=ul &0xff;
 628   if (static_cast<ULONG>(tcp->sendData(buffer, 8)) != 8) return false;
 629   return true;
 630 }
 631
 632 /////////////////////////////////////////////////////////////////////////////
 633
 634 // Here VDR takes a break for the VDR_PacketReceiver helper class
 635
 636 void VDR_PacketReceiver::call(void* userTag, bool& r_deregisterEDR, bool& r_wakeThread, bool& r_deleteEDR)
 637 {
 638   if (receiverChannel == VDR::CHANNEL_REQUEST_RESPONSE)
 639   {
 640     // It's a RR. Save vresp and, signal the waiting thread and return.
 641     // VDR::RequestResponse will be blocking waiting for this to happen.
 642     // That function has a pointer to this object and can read save_vresp.
 643     save_vresp = reinterpret_cast<VDR_ResponsePacket*>(userTag);
 644
 645     r_deregisterEDR = true;
 646     r_wakeThread = true;
 647     r_deleteEDR = false;
 648   }
 649   else if (receiverChannel == VDR::CHANNEL_STREAM)
 650   {
 651     // It's a stream packet. Pass off the stream data to streamReceiver,
 652     // delete the vresp. Keep this PacketReceiver for the next stream packet.
 653     VDR_ResponsePacket* vresp = reinterpret_cast<VDR_ResponsePacket*>(userTag);
 654     streamReceiver->streamReceive(vresp->getFlag(), vresp->getUserData(), vresp->getUserDataLength());
 655     delete vresp;
 656
 657     r_deregisterEDR = false;
 658     r_wakeThread = false;
 659     r_deleteEDR = false;
 660   }
 661   else if (receiverChannel == VDR::CHANNEL_TVMEDIA)
 662   {
 663     // It's TVMedia
 664     // Pass off the vresp object to OSDVector
 665     // This used to return true which would signal the cond (wake the thread)
 666     // but am going to try setting this to false because I don't know that there is a thread to signal
 667     // delete the EDR. It's made once per media requested and wasn't owned/deleted by anything before
 668
 669     VDR_ResponsePacket* vresp = reinterpret_cast<VDR_ResponsePacket*>(userTag);
 670     Log::getInstance()->log("VDR", Log::DEBUG, "TVMedia Pictures arrived VDR %x", vresp->getStreamID());
 671     OsdVector *osd=dynamic_cast<OsdVector*>(Osd::getInstance());
 672     if (osd) osd->getPictReader()->receivePicture(vresp);
 673     // else delete vresp; //nonsense // only rpi does CHANNEL_TVMEDIA, rpi has osdvector. therefore, can't get here.
 674
 675     r_deregisterEDR = true;
 676     r_wakeThread = false;
 677     r_deleteEDR = true;
 678   }
 679   else abort(); // unknown receiverChannel, should not happen
 680 }
 681
 682 /////////////////////////////////////////////////////////////////////////////
 683
 684 int VDR::doLogin(unsigned int* v_server_min, unsigned int* v_server_max, unsigned int* v_client,
 685                 ASLPrefList& list, int &subtitles)
 686 {
 687   VDR_RequestPacket vrp;
 688   if (!vrp.init(VDR_LOGIN, true, 6)) return 0;
 689
 690   UCHAR mactemp[6];
 691   tcp->getMAC(mactemp);
 692   if (!vrp.copyin(mactemp, 6)) return 0;
 693
 694   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 695   if (vresp->noResponse()) { delete vresp; return 0; }
 696
 697   ULONG vdrTime = vresp->extractULONG();
 698   logger->log("VDR", Log::DEBUG, "vdrtime = %lu", vdrTime);
 699   long vdrTimeOffset = vresp->extractLONG();
 700   logger->log("VDR", Log::DEBUG, "offset = %i", vdrTimeOffset);
 701
 702   unsigned int version_min=vresp->extractULONG();
 703
 704   *v_server_min=version_min;
 705   unsigned int version_max=vresp->extractULONG();
 706   *v_server_max=version_max;
 707   *v_client=VOMP_PROTOCOL_VERSION;
 708
 709   if (0x00000302 <= version_max) {
 710           unsigned int numlangcodes = vresp->extractULONG();
 711           subtitles = vresp->extractULONG();
 712           list.clear();
 713           for (unsigned int i=0; i<numlangcodes; i++) {
 714                   ASLPref newpref;
 715                   newpref.audiopref = vresp->extractLONG();
 716                   newpref.subtitlepref = vresp->extractLONG();
 717                   newpref.langcode = vresp->extractStdString();
 718                   //logger->log("VDR", Log::DEBUG, "Langpref %s %d %d", newpref.langcode.c_str(),  newpref.audiopref,  newpref.subtitlepref);
 719                   list.push_back(newpref);
 720           }
 721   }
 722
 723
 724   delete vresp;
 725
 726   if ((version_min > VOMP_PROTOCOL_VERSION)
 727                   || (version_max < VOMP_PROTOCOL_VERSION) ) {
 728
 729           return 0;
 730
 731   }
 732
 733   // Set the time and zone on the MVP only
 734
 735 #if !defined(WIN32) && !defined(__ANDROID__)
 736   struct timespec currentTime;
 737   currentTime.tv_sec = vdrTime;
 738   currentTime.tv_nsec = 0;
 739
 740   int b = clock_settime(CLOCK_REALTIME, &currentTime);
 741
 742   logger->log("VDR", Log::DEBUG, "set clock = %u", b);
 743
 744   // now make a TZ variable and set it
 745   char sign;
 746   int hours;
 747   int minutes;
 748   if (vdrTimeOffset > 0) sign = '-';
 749   else sign = '+';
 750
 751   vdrTimeOffset = abs(vdrTimeOffset);
 752
 753   hours = (int)vdrTimeOffset / 3600;
 754   minutes = vdrTimeOffset % 3600;
 755
 756   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
 757
 758   minutes = (int)minutes / 60;
 759
 760   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
 761
 762   char newTZ[30];
 763   sprintf(newTZ, "MVP%c%i:%i", sign, hours, minutes);
 764   setenv("TZ", newTZ, 1);
 765
 766   logger->log("VDR", Log::DEBUG, "Timezone data: %s", newTZ);
 767 #endif
 768
 769   setCharset(Osd::getInstance()->charSet());
 770
 771   return 1;
 772 }
 773
 774 bool VDR::LogExtern(const char* logString)
 775 {
 776   if (!connected) return false;
 777   int stringLength = strlen(logString);
 778   int packetLength = stringLength + 8;
 779   char *buffer=new char[packetLength + 1];
 780   int pos=0;
 781   ULONG ul=CHANNEL_NETLOG;
 782   buffer[pos++]=(ul>>24)&0xff;
 783   buffer[pos++]=(ul>>16)&0xff;
 784   buffer[pos++]=(ul>>8)&0xff;
 785   buffer[pos++]=ul &0xff;
 786   ul=stringLength;
 787   buffer[pos++]=(ul>>24)&0xff;
 788   buffer[pos++]=(ul>>16)&0xff;
 789   buffer[pos++]=(ul>>8)&0xff;
 790   buffer[pos++]=ul &0xff;
 791
 792   strcpy(&buffer[8], logString);
 793
 794   if (tcp->sendData(buffer, packetLength) != packetLength)
 795   {
 796     connected = false; // stop the rest of the connection
 797     delete [] buffer;
 798     return false;
 799   }
 800   delete [] buffer;
 801   return true;
 802 }
 803
 804 bool VDR::setCharset(int charset)
 805 {
 806   VDR_RequestPacket vrp;
 807   if (!vrp.init(VDR_SETCHARSET, true, sizeof(ULONG))) return false;
 808   if (!vrp.addULONG(charset)) return false;
 809
 810   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 811   if (vresp->noResponse()) { delete vresp; return false; }
 812
 813   ULONG success = vresp->extractULONG();
 814   delete vresp;
 815
 816   if (!success) return false;
 817
 818   return true;
 819 }
 820
 821 bool VDR::getRecordingsList(RecMan* recman)
 822 {
 823   VDR_RequestPacket vrp;
 824   if (!vrp.init(VDR_GETRECORDINGLIST, true, 0)) return false;
 825
 826   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 827   if (vresp->noResponse()) { delete vresp; return false; }
 828
 829   ULONG totalSpace = vresp->extractULONG();
 830   ULONG freeSpace = vresp->extractULONG();
 831   ULONG percent = vresp->extractULONG();
 832
 833   recman->setStats(totalSpace, freeSpace, percent);
 834
 835   ULONG start;
 836   UCHAR isNew;
 837   char* name;
 838   char* fileName;
 839
 840   while (!vresp->end())
 841   {
 842     start = vresp->extractULONG();
 843     isNew = vresp->extractUCHAR();
 844     name = vresp->extractString();
 845     fileName = vresp->extractString();
 846     recman->addEntry(isNew, start, name, fileName);
 847     delete[] name;
 848     delete[] fileName;
 849   }
 850   delete vresp;
 851
 852   return true;
 853 }
 854
 855 int VDR::deleteRecording(char* fileName)
 856 {
 857   VDR_RequestPacket vrp;
 858   if (!vrp.init(VDR_DELETERECORDING, true, strlen(fileName) + 1)) return 0;
 859   if (!vrp.addString(fileName)) return 0;
 860
 861   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 862   if (vresp->noResponse()) { delete vresp; return 0; }
 863
 864   int toReturn = static_cast<int>(vresp->extractULONG());
 865   delete vresp;
 866
 867   return toReturn;
 868 }
 869
 870 int VDR::deleteRecResume(char* fileName)
 871 {
 872   VDR_RequestPacket vrp;
 873   if (!vrp.init(VDR_DELETERECRESUME, true, strlen(fileName) + 1)) return 0;
 874   if (!vrp.addString(fileName)) return 0;
 875
 876   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 877   if (vresp->noResponse()) { delete vresp; return 0; }
 878
 879   int toReturn = static_cast<int>(vresp->extractULONG());
 880   delete vresp;
 881
 882   return toReturn;
 883 }
 884
 885 char* VDR::moveRecording(char* fileName, char* newPath)
 886 {
 887   VDR_RequestPacket vrp;
 888   if (!vrp.init(VDR_MOVERECORDING, true, strlen(fileName) + 1 + strlen(newPath) + 1)) return NULL;
 889   if (!vrp.addString(fileName)) return NULL;
 890   if (!vrp.addString(newPath)) return NULL;
 891
 892   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 893   if (vresp->noResponse()) { delete vresp; return NULL; }
 894
 895   char* toReturn = NULL;
 896   int success = static_cast<int>(vresp->extractULONG());
 897   if (success == 1)
 898   {
 899     toReturn = vresp->extractString();
 900   }
 901
 902   delete vresp;
 903
 904   return toReturn;
 905 }
 906
 907 ChannelList* VDR::getChannelsList(ULONG type)
 908 {
 909   VDR_RequestPacket vrp;
 910   if (!vrp.init(VDR_GETCHANNELLIST, true, 0)) return NULL;
 911
 912   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 913   if (vresp->noResponse()) { delete vresp; return NULL; }
 914
 915   ChannelList* chanList = new ChannelList();
 916
 917   bool h264support=Video::getInstance()->supportsh264();
 918   bool mpeg2support=Video::getInstance()->supportsmpeg2();
 919
 920   while (!vresp->end())
 921   {
 922     Channel* chan = new Channel();
 923     chan->number = vresp->extractULONG();
 924     chan->type = vresp->extractULONG();
 925     chan->name = vresp->extractString();
 926     chan->vstreamtype = static_cast<UCHAR>(vresp->extractULONG());
 927
 928     if (chan->type == type && ((chan->vstreamtype==0x1b && h264support)|| (chan->vstreamtype!=0x1b &&mpeg2support)) )
 929     {
 930       chanList->push_back(chan);
 931       logger->log("VDR", Log::DEBUG, "Have added a channel to list. %lu %lu %s", chan->number, chan->type, chan->name);
 932       if (chan->number > maxChannelNumber) maxChannelNumber = chan->number;
 933     }
 934     else
 935     {
 936       delete chan;
 937     }
 938   }
 939
 940   delete vresp;
 941
 942   if (maxChannelNumber > 99999)
 943     channelNumberWidth = 6;
 944   else if (maxChannelNumber > 9999)
 945     channelNumberWidth = 5;
 946   else if (maxChannelNumber > 999)
 947     channelNumberWidth = 4;
 948   else if (maxChannelNumber > 99)
 949     channelNumberWidth = 3;
 950   else if (maxChannelNumber > 9)
 951     channelNumberWidth = 2;
 952   else
 953     channelNumberWidth = 1;
 954
 955   return chanList;
 956 }
 957
 958 int VDR::streamChannel(ULONG number, StreamReceiver* tstreamReceiver)
 959 {
 960   VDR_RequestPacket vrp;
 961   if (!vrp.init(VDR_STREAMCHANNEL, true, sizeof(ULONG))) return 0;
 962   if (!vrp.addULONG(number)) return 0;
 963
 964
 965   VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
 966   vdrpr->receiverChannel = VDR::CHANNEL_STREAM;
 967   vdrpr->streamID = vrp.getSerial();
 968   vdrpr->streamReceiver = tstreamReceiver;
 969   edRegister(vdrpr);
 970   TEMP_SINGLE_VDR_PR = vdrpr;
 971
 972   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 973   if (vresp->noResponse())
 974   {
 975     delete vresp;
 976     edUnregister(vdrpr);
 977     delete vdrpr;
 978     return 0;
 979   }
 980
 981   int toReturn = static_cast<int>(vresp->extractULONG());
 982   logger->log("VDR", Log::DEBUG, "VDR said %lu to start streaming request", toReturn);
 983   delete vresp;
 984
 985   return toReturn;
 986 }
 987
 988 int VDR::stopStreaming()
 989 {
 990   VDR_RequestPacket vrp;
 991   if (!vrp.init(VDR_STOPSTREAMING, true, 0)) return 0;
 992
 993   if (TEMP_SINGLE_VDR_PR) // this block only needs to be done if it was a live stream
 994                           // TEMP_SINGLE_VDR_PR will not be set unless we are streaming a channel
 995   {
 996     edUnregister(TEMP_SINGLE_VDR_PR);
 997     delete TEMP_SINGLE_VDR_PR;
 998     TEMP_SINGLE_VDR_PR = NULL;
 999   }
1000
1001   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1002   if (vresp->noResponse()) { delete vresp; return 0; }
1003
1004   int toReturn = static_cast<int>(vresp->extractULONG());
1005   delete vresp;
1006
1007   return toReturn;
1008 }
1009
1010 UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived)
1011 {
1012   VDR_RequestPacket vrp;
1013   if (!vrp.init(VDR_GETBLOCK, true, sizeof(ULLONG) + sizeof(ULONG))) return NULL;
1014   if (!vrp.addULLONG(position)) return NULL;
1015   if (!vrp.addULONG(maxAmount)) return NULL;
1016
1017   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1018   if (vresp->noResponse()) { delete vresp; return NULL; }
1019
1020   if (vresp->serverError())
1021   {
1022     logger->log("VDR", Log::DEBUG, "Detected getblock 0");
1023     *amountReceived = 0;
1024     delete vresp;
1025     return NULL;
1026   }
1027
1028   // Special handling for getblock
1029   UCHAR* toReturn = vresp->getUserData();
1030   *amountReceived = vresp->getUserDataLength();
1031
1032   delete vresp;
1033
1034   return toReturn;
1035 }
1036
1037 ULLONG VDR::streamRecording(char* fileName, ULONG* totalFrames, bool* IsPesRecording)
1038 {
1039   VDR_RequestPacket vrp;
1040   if (!vrp.init(VDR_STREAMRECORDING, true, strlen(fileName) + 1)) return 0;
1041   if (!vrp.addString(fileName)) return 0;
1042
1043   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1044   if (vresp->noResponse()) { delete vresp; return 0; }
1045
1046   ULLONG lengthBytes = vresp->extractULLONG();
1047   ULONG lengthFrames = vresp->extractULONG();
1048   UCHAR isPesRecording = vresp->extractUCHAR();
1049   delete vresp;
1050
1051   *totalFrames = lengthFrames;
1052   *IsPesRecording = (isPesRecording);//convert Uchar to bool
1053
1054   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu, IsPesRecording %x", lengthBytes, lengthFrames, *IsPesRecording);
1055
1056   return lengthBytes;
1057 }
1058
1059 ULLONG VDR::positionFromFrameNumber(ULONG frameNumber)
1060 {
1061   VDR_RequestPacket vrp;
1062   if (!vrp.init(VDR_POSFROMFRAME, true, sizeof(ULONG))) return 0;
1063   if (!vrp.addULONG(frameNumber)) return 0;
1064
1065   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1066   if (vresp->noResponse()) { delete vresp; return 0; }
1067
1068   ULLONG position = vresp->extractULLONG();
1069   delete vresp;
1070
1071   logger->log("VDR", Log::DEBUG, "VDR said new position is: %llu", position);
1072
1073   return position;
1074 }
1075
1076 ULONG VDR::frameNumberFromPosition(ULLONG position)
1077 {
1078   VDR_RequestPacket vrp;
1079   if (!vrp.init(VDR_FRAMEFROMPOS, true, sizeof(ULLONG))) return 0;
1080   if (!vrp.addULLONG(position)) return 0;
1081
1082   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1083   if (vresp->noResponse()) { delete vresp; return 0; }
1084
1085   ULONG framenumber = vresp->extractULONG();
1086   delete vresp;
1087
1088   logger->log("VDR", Log::DEBUG, "VDR said new framenumber is: %u", framenumber);
1089
1090   return framenumber;
1091 }
1092
1093 bool VDR::getNextIFrame(ULONG frameNumber, ULONG direction, ULLONG* rfilePosition, ULONG* rframeNumber, ULONG* rframeLength)
1094 {
1095   VDR_RequestPacket vrp;
1096   if (!vrp.init(VDR_GETNEXTIFRAME, true, sizeof(ULONG)*2)) return false;
1097   if (!vrp.addULONG(frameNumber)) return false;
1098   if (!vrp.addULONG(direction)) return false;
1099
1100   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1101   if (vresp->noResponse()) { delete vresp; return false; }
1102
1103   if (vresp->serverError())
1104   {
1105     logger->log("VDR", Log::DEBUG, "Detected getNextIFrame error");
1106     delete vresp;
1107     return false;
1108   }
1109
1110   *rfilePosition = vresp->extractULLONG();
1111   *rframeNumber = vresp->extractULONG();
1112   *rframeLength = vresp->extractULONG();
1113
1114   delete vresp;
1115
1116   logger->log("VDR", Log::DEBUG, "VDR GNIF said %llu %lu %lu", *rfilePosition, *rframeNumber, *rframeLength);
1117
1118   return true;
1119 }
1120
1121 EventList* VDR::getChannelSchedule(ULONG number)
1122 {
1123   time_t now;
1124   time(&now);
1125   return getChannelSchedule(number, now, 24 * 60 * 60);
1126 }
1127
1128 EventList* VDR::getChannelSchedule(ULONG number, time_t start, ULONG duration)
1129 {
1130 // retrieve event list (vector of events) from vdr within filter window. duration is in seconds
1131
1132   VDR_RequestPacket vrp;
1133   if (!vrp.init(VDR_GETCHANNELSCHEDULE, true, sizeof(ULONG)*3)) return NULL;
1134   if (!vrp.addULONG(number)) return NULL;
1135   if (!vrp.addULONG(start)) return NULL;
1136   if (!vrp.addULONG(duration)) return NULL;
1137
1138   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1139   if (vresp->noResponse()) { delete vresp; return NULL; }
1140
1141   // received a ulong(0) - schedules error in the plugin
1142   if (vresp->serverError())
1143   {
1144     delete vresp;
1145     return NULL;
1146   }
1147
1148   EventList* eventList = new EventList();
1149
1150   while (!vresp->end())
1151   {
1152     Event* event = new Event();
1153     event->id = vresp->extractULONG();
1154     event->time = vresp->extractULONG();
1155     event->duration = vresp->extractULONG();
1156     event->title = vresp->extractString();
1157     event->subtitle = vresp->extractString();
1158     event->description = vresp->extractString();
1159     eventList->push_back(event);
1160   }
1161
1162   delete vresp;
1163
1164   logger->log("VDR", Log::DEBUG, "Success got to end of getChannelSchedule");
1165   return eventList;
1166 }
1167
1168 int VDR::configSave(const char* section, const char* key, const char* value)
1169 {
1170   VDR_RequestPacket vrp;
1171   if (!vrp.init(VDR_CONFIGSAVE, false, 0)) return 0;
1172   if (!vrp.addString(section)) return 0;
1173   if (!vrp.addString(key)) return 0;
1174   if (!vrp.addString(value)) return 0;
1175
1176   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1177   if (vresp->noResponse()) { delete vresp; return 0; }
1178
1179   int toReturn = static_cast<int>(vresp->extractULONG());
1180   delete vresp;
1181
1182   return toReturn;
1183 }
1184
1185 char* VDR::configLoad(const char* section, const char* key)
1186 {
1187   VDR_RequestPacket vrp;
1188   if (!vrp.init(VDR_CONFIGLOAD, false, 0)) return NULL;
1189   if (!vrp.addString(section)) return NULL;
1190   if (!vrp.addString(key)) return NULL;
1191
1192   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1193   if (vresp->noResponse()) { delete vresp; return NULL; }
1194
1195   char* toReturn = vresp->extractString();
1196   delete vresp;
1197
1198   return toReturn;
1199 }
1200
1201 RecTimerList* VDR::getRecTimersList()
1202 {
1203   VDR_RequestPacket vrp;
1204   if (!vrp.init(VDR_GETTIMERS, true, 0)) return NULL;
1205
1206   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1207   if (vresp->noResponse()) { delete vresp; return NULL; }
1208
1209   RecTimerList* recTimerList = new RecTimerList();
1210
1211   ULONG numTimers = vresp->extractULONG();
1212   if (numTimers > 0)
1213   {
1214     RecTimer* newRecTimer;
1215     char* tempString;
1216
1217     while (!vresp->end())
1218     {
1219       newRecTimer = new RecTimer();
1220       newRecTimer->active = vresp->extractULONG();
1221       newRecTimer->recording = vresp->extractULONG();
1222       newRecTimer->pending = vresp->extractULONG();
1223       newRecTimer->priority = vresp->extractULONG();
1224       newRecTimer->lifeTime = vresp->extractULONG();
1225       newRecTimer->channelNumber = vresp->extractULONG();
1226       newRecTimer->startTime = vresp->extractULONG();
1227       newRecTimer->stopTime = vresp->extractULONG();
1228       newRecTimer->day = vresp->extractULONG();
1229       newRecTimer->weekDays = vresp->extractULONG();
1230
1231       tempString = vresp->extractString();
1232       newRecTimer->setFile(tempString);
1233       delete[] tempString;
1234
1235       recTimerList->push_back(newRecTimer);
1236       logger->log("VDR", Log::DEBUG, "TL: %lu %lu %lu %lu %lu %lu %lu %lu %s",
1237         newRecTimer->active, newRecTimer->recording, newRecTimer->pending, newRecTimer->priority, newRecTimer->lifeTime,
1238         newRecTimer->channelNumber, newRecTimer->startTime, newRecTimer->stopTime, newRecTimer->getFile());
1239     }
1240   }
1241
1242   delete vresp;
1243
1244   sort(recTimerList->begin(), recTimerList->end(), RecTimerSorter());
1245
1246   return recTimerList;
1247 }
1248
1249 ULONG VDR::setEventTimer(char* timerString)
1250 {
1251   VDR_RequestPacket vrp;
1252   if (!vrp.init(VDR_SETTIMER, true, strlen(timerString) + 1)) return 0;
1253   if (!vrp.addString(timerString)) return 0;
1254
1255   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1256   if (vresp->noResponse()) { delete vresp; return 0; }
1257
1258   ULONG toReturn = vresp->extractULONG();
1259   delete vresp;
1260
1261   return toReturn;
1262 }
1263
1264 RecInfo* VDR::getRecInfo(char* fileName)
1265 {
1266   VDR_RequestPacket vrp;
1267   if (!vrp.init(VDR_GETRECINFO2, true, strlen(fileName) + 1)) return NULL;
1268   if (!vrp.addString(fileName)) return NULL;
1269   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1270
1271   if (vresp->noResponse()) { delete vresp; return NULL; }
1272
1273   if (vresp->serverError())
1274   {
1275     logger->log("VDR", Log::DEBUG, "Could not get rec info");
1276     delete vresp;
1277     return NULL;
1278   }
1279
1280   RecInfo* recInfo = new RecInfo();
1281
1282   recInfo->timerStart = vresp->extractULONG();
1283   recInfo->timerEnd = vresp->extractULONG();
1284   recInfo->resumePoint = vresp->extractULONG();
1285   recInfo->summary = vresp->extractString();
1286
1287   ULONG numComponents = vresp->extractULONG();
1288   if (numComponents)
1289   {
1290     recInfo->setNumComponents(numComponents);
1291     for (ULONG i = 0; i < numComponents; i++)
1292     {
1293       recInfo->streams[i] = vresp->extractUCHAR();
1294       recInfo->types[i] = vresp->extractUCHAR();
1295       recInfo->languages[i] = vresp->extractString();
1296       recInfo->descriptions[i] = vresp->extractString();
1297     }
1298   }
1299   recInfo->fps=vresp->extractdouble();
1300   recInfo->title=vresp->extractString();
1301
1302   // New stuff
1303   recInfo->channelName = vresp->extractString();
1304   recInfo->duration = vresp->extractULONG();
1305   recInfo->fileSize = vresp->extractULONG();
1306   recInfo->priority = vresp->extractULONG();
1307   recInfo->lifetime = vresp->extractULONG();
1308
1309   recInfo->print();
1310
1311   delete vresp;
1312   return recInfo;
1313 }
1314
1315 // FIXME obselete
1316 ULLONG VDR::rescanRecording(ULONG* totalFrames)
1317 {
1318   VDR_RequestPacket vrp;
1319   if (!vrp.init(VDR_RESCANRECORDING, true, 0)) return 0;
1320
1321   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1322   if (vresp->noResponse()) { delete vresp; return 0; }
1323
1324   ULLONG lengthBytes = vresp->extractULLONG();
1325   ULONG lengthFrames = vresp->extractULONG();
1326   delete vresp;
1327
1328   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
1329
1330   *totalFrames = lengthFrames;
1331   return lengthBytes;
1332 }
1333
1334 MarkList* VDR::getMarks(char* fileName)
1335 {
1336   VDR_RequestPacket vrp;
1337   if (!vrp.init(VDR_GETMARKS, true, strlen(fileName) + 1)) return NULL;
1338   if (!vrp.addString(fileName)) return NULL;
1339
1340   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1341   if (vresp->noResponse()) { delete vresp; return NULL; }
1342
1343   if (vresp->serverError())
1344   {
1345     delete vresp;
1346     return NULL;
1347   }
1348
1349   MarkList* markList = new MarkList();
1350
1351   while (!vresp->end())
1352   {
1353     Mark* mark = new Mark();
1354     mark->pos = vresp->extractULONG();
1355
1356     markList->push_back(mark);
1357     logger->log("VDR", Log::DEBUG, "Have added a mark to list. %lu", mark->pos);
1358   }
1359
1360   delete vresp;
1361
1362   return markList;
1363 }
1364
1365 void VDR::getChannelPids(Channel* channel)
1366 {
1367   VDR_RequestPacket vrp;
1368   if (!vrp.init(VDR_GETCHANNELPIDS, true, sizeof(ULONG))) return ;
1369   if (!vrp.addULONG(channel->number)) return ;
1370
1371   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1372   if (vresp->noResponse()) { delete vresp; return ; }
1373
1374   // Format of response
1375   // vpid
1376   // number of apids
1377   // {
1378   //    apid
1379   //    lang string
1380   // }
1381
1382   channel->vpid = vresp->extractULONG();
1383   channel->vstreamtype = static_cast<UCHAR>(vresp->extractULONG());
1384   channel->numAPids = vresp->extractULONG();
1385
1386   for (ULONG i = 0; i < channel->numAPids; i++)
1387   {
1388     apid newapid;
1389     newapid.pid = vresp->extractULONG();
1390     char * name=vresp->extractString();
1391     strncpy(newapid.desc,name,9);
1392     delete [] name;
1393     channel->apids.push_back(newapid);
1394   }
1395
1396   channel->numDPids = vresp->extractULONG();
1397
1398   for (ULONG i = 0; i < channel->numDPids; i++)
1399   {
1400     apid newdpid;
1401     newdpid.pid = vresp->extractULONG();
1402     char * name=vresp->extractString();
1403     strncpy(newdpid.desc,name,9);
1404     delete [] name;
1405     channel->dpids.push_back(newdpid);
1406   }
1407
1408   channel->numSPids = vresp->extractULONG();
1409
1410   for (ULONG i = 0; i < channel->numSPids; i++)
1411   {
1412     apid newspid;
1413     newspid.pid = vresp->extractULONG();
1414     char * name=vresp->extractString();
1415     strncpy(newspid.desc,name,9);
1416     delete [] name;
1417     channel->spids.push_back(newspid);
1418   }
1419   channel->tpid = vresp->extractULONG();
1420   // extension
1421   for (ULONG i = 0; i < channel->numAPids; i++)
1422   {
1423           channel->apids[i].type = vresp->extractULONG();
1424   }
1425   for (ULONG i = 0; i < channel->numDPids; i++)
1426   {
1427           channel->dpids[i].type = vresp->extractULONG();
1428   }
1429   for (ULONG i = 0; i < channel->numSPids; i++)
1430   {
1431           channel->spids[i].type = vresp->extractULONG();
1432           channel->spids[i].data1 = vresp->extractULONG();
1433           channel->spids[i].data2 = vresp->extractULONG();
1434   }
1435
1436   delete vresp;
1437
1438   return ;
1439 }
1440
1441 #ifdef VOMP_MEDIAPLAYER
1442 MediaList * VDR::getRootList() {
1443   return getMediaList(NULL);
1444 }
1445 /**
1446   * media List Request:
1447   * mediaURI
1448   * Media List response:
1449   * mediaList
1450 */
1451 MediaList* VDR::getMediaList(const MediaURI * root)
1452 {
1453   logger->log("VDR", Log::DEBUG, "getMediaList %s,d=%s, prov=%d", (root?root->getName():"NULL"),
1454       ((root && root->hasDisplayName())?root->getDisplayName():"NULL"),
1455       (root?root->getProvider():providerId));
1456   MediaURI remoteURI(root);
1457   VDR_GetMediaListRequest request(&remoteURI);
1458   SerializeBuffer *vrp=prepareRequest(&request);
1459   if (!vrp) {
1460     logger->log("VDR", Log::ERR, "getMediaList unable to create command");
1461     return NULL;
1462   }
1463
1464   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1465   if (!vresp) {
1466     Command::getInstance()->connectionLost();
1467     return NULL;
1468   }
1469
1470   MediaList *rt=new MediaList(NULL);
1471   ULONG rtflags=0;
1472   VDR_GetMediaListResponse resp(&rtflags,rt);
1473   if (decodeResponse(vresp,&resp) != 0) {
1474     return NULL;
1475   }
1476   return rt;
1477 }
1478
1479 /**
1480   * get image Request:
1481   * uri,x,y, channel
1482   * get media response:
1483   * 4 flags
1484   * 8 len of image
1485 */
1486 int VDR::openMedium(ULONG channel,const MediaURI *uri,  ULLONG * size, ULONG x, ULONG y)
1487 {
1488   MediaURI remoteURI(uri);
1489   VDR_OpenMediumRequest request(&channel,&remoteURI,&x,&y);
1490   *size=0;
1491   SerializeBuffer *vrp=prepareRequest(&request);
1492   if (!vrp) {
1493     logger->log("VDR", Log::ERR, "openMedium unable to create command");
1494     return -1;
1495   }
1496   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1497   if (!vresp) {
1498     Command::getInstance()->connectionLost();
1499     return -1;
1500   }
1501   ULONG flags=0;
1502   VDR_OpenMediumResponse response(&flags,size);
1503   if (decodeResponse(vresp,&response) != 0) {
1504     return -1;
1505   }
1506   logger->log("VDR", Log::DEBUG, "openMedia len=%llu", *size);
1507   return 0;
1508 }
1509
1510 /**
1511   * getMediaBlock - no separate response class - simple data block
1512   * resp
1513   * packet
1514   */
1515 int VDR::getMediaBlock(ULONG channel, ULLONG position, ULONG maxAmount, ULONG* amountReceived, unsigned char **buffer)
1516 {
1517   *amountReceived=0;
1518   VDR_GetMediaBlockRequest request(&channel,&position,&maxAmount);
1519   SerializeBuffer *vrp=prepareRequest(&request);
1520   if (!vrp) {
1521     logger->log("VDR", Log::ERR, "getMediaBlock unable to create command");
1522     return -1;
1523   }
1524   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1525   if (!vresp) {
1526     Command::getInstance()->connectionLost();
1527     return -1;
1528   }
1529
1530   // Special handling for getblock
1531   *amountReceived = (ULONG)(vresp->getEnd()-vresp->getStart());
1532   *buffer = vresp->steelBuffer();
1533   delete vresp;
1534   return 0;
1535 }
1536
1537 /**
1538   * VDR_GETMEDIAINFO
1539   * channel
1540   * rt
1541   * flags
1542   * info
1543   */
1544
1545 int VDR::getMediaInfo(ULONG channel, MediaInfo * result) {
1546   if (! result) return -1;
1547   VDR_GetMediaInfoRequest request(&channel);
1548   SerializeBuffer *vrp=prepareRequest(&request);
1549   if (!vrp) {
1550     logger->log("VDR", Log::ERR, "getMediaInfo unable to create command");
1551     return -1;
1552   }
1553   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1554   if (!vresp) {
1555     Command::getInstance()->connectionLost();
1556     return -1;
1557   }
1558
1559   ULONG flags=0;
1560   VDR_GetMediaInfoResponse response(&flags,result);
1561   if (decodeResponse(vresp,&response) != 0) {
1562     return -1;
1563   }
1564   return 0;
1565 }
1566
1567 /**
1568   * VDR_CLOSECHANNEL
1569   * channel
1570   * rt
1571   * flags
1572   */
1573
1574 int VDR::closeMediaChannel(ULONG channel) {
1575   VDR_CloseMediaChannelRequest request(&channel);
1576   SerializeBuffer *vrp=prepareRequest(&request);
1577   if (!vrp) {
1578     logger->log("VDR", Log::ERR, "closeMediaChannel unable to create command");
1579     return -1;
1580   }
1581   SerializeBuffer* vresp = doRequestResponse(vrp,request.command);
1582   if (!vresp) {
1583     Command::getInstance()->connectionLost();
1584     return -1;
1585   }
1586   ULONG flags;
1587   VDR_CloseMediaChannelResponse response(&flags);
1588   if (decodeResponse(vresp,&response) != 0) return -1;
1589   return (flags != 0)?-1:0;
1590 }
1591
1592 #endif
1593
1594
1595 int VDR::deleteTimer(RecTimer* delTimer)
1596 {
1597   logger->log("VDR", Log::DEBUG, "Delete timer called");
1598
1599   VDR_RequestPacket vrp;
1600   if (!vrp.init(VDR_DELETETIMER, false, 0)) return 0;
1601   if (!vrp.addULONG(delTimer->channelNumber)) return 0;
1602   if (!vrp.addULONG(delTimer->weekDays)) return 0;
1603   if (!vrp.addULONG(delTimer->day)) return 0;
1604   if (!vrp.addULONG(delTimer->startTime)) return 0;
1605   if (!vrp.addULONG(delTimer->stopTime)) return 0;
1606
1607   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1608   if (vresp->noResponse()) { delete vresp; return 0; }
1609
1610   int toReturn = static_cast<int>(vresp->extractULONG());
1611   delete vresp;
1612
1613   return toReturn;
1614 }
1615
1616 I18n::lang_code_list VDR::getLanguageList()
1617 {
1618   I18n::lang_code_list CodeList;
1619   CodeList["en"] = "English"; // Default entry
1620   VDR_RequestPacket vrp;
1621   if (!vrp.init(VDR_GETLANGUAGELIST, false, 0)) return CodeList;
1622   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1623   if (vresp->noResponse() || vresp->end())
1624   {
1625     delete vresp;
1626     return CodeList;
1627   }
1628   CodeList.clear();
1629   while (!vresp->end())
1630   {
1631     char* c_code = vresp->extractString();
1632     char* c_name = vresp->extractString();
1633     std::string code = c_code;
1634     std::string name = c_name;
1635     CodeList[code] = name;
1636     delete[] c_code;
1637     delete[] c_name;
1638   }
1639   delete vresp;
1640   return CodeList;
1641 }
1642
1643 int VDR::getLanguageContent(const std::string code, I18n::trans_table& texts)
1644 {
1645   VDR_RequestPacket vrp;
1646   if (!vrp.init(VDR_GETLANGUAGECONTENT, false, 0)) return 0;
1647   if (!vrp.addString(code.c_str())) return 0;
1648   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1649   if (vresp->noResponse()) { delete vresp; return 0; }
1650   texts.clear();
1651   while (!vresp->end())
1652   {
1653     char* c_key = vresp->extractString();
1654     char* c_text = vresp->extractString();
1655     std::string key = c_key;
1656     std::string text = c_text;
1657     texts[key] = text;
1658     delete[] c_key;
1659     delete[] c_text;
1660   }
1661   delete vresp;
1662   return 1;
1663 }
1664
1665 void VDR::shutdownVDR()
1666 {
1667   if(doVDRShutdown)
1668     logger->log("VDR", Log::DEBUG, "Shutting down vdr");
1669   else
1670     logger->log("VDR", Log::DEBUG, "Shutting down vomp only");
1671
1672   if(!doVDRShutdown || !connected)
1673     return;
1674
1675   VDR_RequestPacket vrp;
1676   logger->log("VDR", Log::DEBUG, "Sending shutdown");
1677   if (!vrp.init(VDR_SHUTDOWN, false, 0)) return;
1678   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1679   delete vresp;
1680
1681   logger->log("VDR", Log::DEBUG, "VDR shutdown");
1682 }
1683
1684 void VDR::getScraperEventType(char * fileName, int & movieID,
1685                 int & seriesID, int & episodeID)
1686 {
1687         movieID = 0;
1688         seriesID = 0;
1689         episodeID = 0;
1690         VDR_RequestPacket vrp;
1691         if (!vrp.init(VDR_GETRECSCRAPEREVENTTYPE, true, strlen(fileName) + 1)) return;
1692         if (!vrp.addString(fileName)) return ;
1693         Log::getInstance()->log("Recording", Log::DEBUG, "Before Response ");
1694         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1695         Log::getInstance()->log("Recording", Log::DEBUG, "After Response ");
1696         if (vresp->noResponse()) { delete vresp; return ; }
1697         int type = vresp->extractUCHAR();
1698         if (type == 0) //serie
1699         {
1700                 seriesID = vresp->extractLONG();
1701                 episodeID = vresp->extractLONG();
1702         } else if (type == 1) //movie
1703         {
1704                 movieID = vresp->extractLONG();
1705         }
1706         delete vresp;
1707
1708 }
1709
1710 void VDR::getScraperEventType(UINT channelid, UINT eventid, int & movieID,
1711                 int & seriesID, int & episodeID, int & epgImage )
1712 {
1713         movieID = 0;
1714         seriesID = 0;
1715         episodeID = 0;
1716         epgImage = 0;
1717         VDR_RequestPacket vrp;
1718         if (!vrp.init(VDR_GETEVENTSCRAPEREVENTTYPE, false, 0)) return;
1719         if (!vrp.addULONG(channelid)) return ;
1720         if (!vrp.addULONG(eventid)) return ;
1721         Log::getInstance()->log("Recording", Log::DEBUG, "Before Response ");
1722         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1723         Log::getInstance()->log("Recording", Log::DEBUG, "After Response ");
1724         if (vresp->noResponse()) { delete vresp; return ; }
1725         int type = vresp->extractUCHAR();
1726         if (type == 0) //serie
1727         {
1728                 seriesID = vresp->extractLONG();
1729                 episodeID = vresp->extractLONG();
1730         } else if (type == 1) //movie
1731         {
1732                 movieID = vresp->extractLONG();
1733         }
1734         epgImage = vresp->extractLONG();
1735         delete vresp;
1736
1737 }
1738
1739 MovieInfo *VDR::getScraperMovieInfo(int movieID)
1740 {
1741         VDR_RequestPacket vrp;
1742         if (!vrp.init(VDR_GETSCRAPERMOVIEINFO, false, 0)) return NULL;
1743         if (!vrp.addULONG(movieID)) return NULL;
1744         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1745         if (vresp->noResponse()) { delete vresp; return NULL; }
1746         MovieInfo * movieinf= new MovieInfo();
1747
1748         movieinf->id=movieID;
1749         movieinf->title = vresp->extractStdString();
1750         movieinf->originalTitle = vresp->extractStdString();
1751         movieinf->tagline = vresp->extractStdString();
1752         movieinf->overview = vresp->extractStdString();
1753         movieinf->adult = vresp->extractUCHAR();
1754         movieinf->collectionName = vresp->extractStdString();
1755
1756         movieinf->budget = vresp->extractLONG();
1757         movieinf->revenue = vresp->extractLONG();
1758         movieinf->genres = vresp->extractStdString();
1759         movieinf->homepage = vresp->extractStdString();
1760         movieinf->releaseDate = vresp->extractStdString();
1761         movieinf->runtime = vresp->extractLONG();
1762         movieinf->popularity = vresp->extractdouble();
1763         movieinf->voteAverage = vresp->extractdouble();
1764         movieinf->poster.width = vresp->extractULONG();
1765         movieinf->poster.height = vresp->extractULONG();
1766         movieinf->poster.info.setMovieInfo(movieinf);
1767         movieinf->poster.info.setElement(0,0);
1768         movieinf->fanart.width = vresp->extractULONG();
1769         movieinf->fanart.height = vresp->extractULONG();
1770         movieinf->fanart.info.setMovieInfo(movieinf);
1771         movieinf->fanart.info.setElement(1,0);
1772         movieinf->collectionPoster.width = vresp->extractULONG();
1773         movieinf->collectionPoster.height = vresp->extractULONG();
1774         movieinf->collectionPoster.info.setMovieInfo(movieinf);
1775         movieinf->collectionPoster.info.setElement(2,0);
1776         movieinf->collectionFanart.width = vresp->extractULONG();
1777         movieinf->collectionFanart.height = vresp->extractULONG();
1778         movieinf->collectionFanart.info.setMovieInfo(movieinf);
1779         movieinf->collectionFanart.info.setElement(3,0);
1780         ULONG num_actors =  vresp->extractULONG();
1781         movieinf->actors.clear();
1782         movieinf->actors.reserve(num_actors);
1783         for (ULONG acty=0; acty < num_actors; acty++) {
1784                 Actor new_act;
1785                 new_act.name =  vresp->extractStdString();
1786                 new_act.role =  vresp->extractStdString();
1787                 new_act.thumb.width = vresp->extractULONG();
1788                 new_act.thumb.height = vresp->extractULONG();
1789                 new_act.thumb.info.setMovieInfo(movieinf);
1790                 new_act.thumb.info.setElement(4,acty);
1791                 movieinf->actors.push_back(new_act);
1792         }
1793
1794
1795         delete vresp;
1796         return movieinf;
1797
1798 }
1799
1800 SeriesInfo *VDR::getScraperSeriesInfo(int seriesID, int episodeID)
1801 {
1802         VDR_RequestPacket vrp;
1803         if (!vrp.init(VDR_GETSCRAPERSERIESINFO, false, 0)) return NULL;
1804         if (!vrp.addULONG(seriesID)) return NULL;
1805         if (!vrp.addULONG(episodeID)) return NULL;
1806
1807         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1808         if (vresp->noResponse()) { delete vresp; return 0; }
1809         SeriesInfo * seriesinf= new SeriesInfo();
1810
1811         seriesinf->id=seriesID;
1812
1813
1814         seriesinf->name = vresp->extractStdString();
1815         seriesinf->overview = vresp->extractStdString();
1816         seriesinf->firstAired = vresp->extractStdString();
1817         seriesinf->network = vresp->extractStdString();
1818         seriesinf->genre = vresp->extractStdString();
1819         seriesinf->rating =  vresp->extractdouble();
1820         seriesinf->status = vresp->extractStdString();
1821
1822
1823         seriesinf->episode.episodeid=episodeID;
1824         seriesinf->episode.number = vresp->extractLONG();
1825         seriesinf->episode.season = vresp->extractLONG();
1826         seriesinf->episode.name =  vresp->extractStdString();
1827         seriesinf->episode.firstAired =  vresp->extractStdString();
1828         seriesinf->episode.guestStars =  vresp->extractStdString();
1829         seriesinf->episode.overview =  vresp->extractStdString();
1830         seriesinf->episode.rating = vresp->extractdouble();
1831         seriesinf->episode.image.width =  vresp->extractULONG();
1832         seriesinf->episode.image.height =  vresp->extractULONG();
1833         seriesinf->episode.image.info.setSeriesInfo(seriesinf);
1834         seriesinf->episode.image.info.setElement(0,0);
1835
1836
1837         ULONG num_actors =  vresp->extractULONG();
1838         seriesinf->actors.clear();
1839         seriesinf->actors.reserve(num_actors);
1840         for (ULONG acty=0; acty < num_actors; acty++) {
1841                 Actor new_act;
1842                 new_act.name =  vresp->extractStdString();
1843                 new_act.role =  vresp->extractStdString();
1844                 new_act.thumb.width = vresp->extractULONG();
1845                 new_act.thumb.height = vresp->extractULONG();
1846                 new_act.thumb.info.setSeriesInfo(seriesinf);
1847                 new_act.thumb.info.setElement(1,acty);
1848                 seriesinf->actors.push_back(new_act);
1849         }
1850         ULONG num_posters =  vresp->extractULONG();
1851         for (ULONG medias = 0; medias < num_posters; medias++ ) {
1852                 TVMedia media;
1853                 media.info.setSeriesInfo(seriesinf);
1854                 media.info.setElement(2,medias);
1855                 media.width =  vresp->extractULONG();
1856                 media.height = vresp->extractULONG();
1857                 seriesinf->posters.push_back(media);
1858         }
1859
1860         ULONG num_banners =  vresp->extractULONG();
1861         for (ULONG medias = 0; medias < num_banners; medias++ ) {
1862                 TVMedia media;
1863                 media.info.setSeriesInfo(seriesinf);
1864                 media.info.setElement(3,medias);
1865                 media.width =  vresp->extractULONG();
1866                 media.height = vresp->extractULONG();
1867                 seriesinf->banners.push_back(media);
1868         }
1869         ULONG num_fanarts =  vresp->extractULONG();
1870         for (ULONG medias = 0; medias < num_fanarts; medias++ ) {
1871                 TVMedia media;
1872                 media.info.setSeriesInfo(seriesinf);
1873                 media.info.setElement(4,medias);
1874                 media.width =  vresp->extractULONG();
1875                 media.height = vresp->extractULONG();
1876                 seriesinf->fanart.push_back(media);
1877         }
1878         seriesinf->seasonposter.width = vresp->extractULONG();
1879         seriesinf->seasonposter.height = vresp->extractULONG();
1880         seriesinf->seasonposter.info.setSeriesInfo(seriesinf);
1881         seriesinf->seasonposter.info.setElement(5,0);
1882
1883         delete vresp;
1884         return seriesinf;
1885
1886 }
1887
1888 ULONG VDR::loadTVMedia(TVMediaInfo& tvmedia)
1889 {
1890         VDR_RequestPacket vrp;
1891
1892         if (!vrp.init(VDR_LOADTVMEDIA, false, 0)) return ULONG_MAX;
1893         if (!vrp.addULONG(tvmedia.type)) return ULONG_MAX;
1894         if (!vrp.addULONG(tvmedia.primary_id)) return ULONG_MAX;
1895         if (!vrp.addULONG(tvmedia.secondary_id)) return ULONG_MAX;
1896         if (!vrp.addULONG(tvmedia.type_pict)) return ULONG_MAX;
1897         if (!vrp.addULONG(tvmedia.container)) return ULONG_MAX;
1898         if (!vrp.addULONG(tvmedia.container_member)) return ULONG_MAX;
1899 /*      Log::getInstance()->log("VDR", Log::DEBUG, "TVMedia with ID %d %d; %d %d %d %d;%d",
1900                         tvmedia.primary_id,tvmedia.secondary_id,tvmedia.type,tvmedia.type_pict,
1901                         tvmedia.container,tvmedia.container_member,vrp.getSerial());*/
1902
1903
1904         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1905         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1906         vdrpr->streamID = vrp.getSerial();
1907         vdrpr->streamReceiver = NULL;
1908         edRegister(vdrpr);
1909
1910
1911         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1912         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1913         delete vresp;
1914
1915         return vrp.getSerial();
1916 }
1917
1918 ULONG VDR::loadTVMediaRecThumb(TVMediaInfo & media)
1919 {
1920
1921         VDR_RequestPacket vrp;
1922
1923         if (!vrp.init(VDR_LOADTVMEDIARECTHUMB, false, 0)) return ULONG_MAX;
1924         if (!vrp.addString(media.primary_name.c_str())) return ULONG_MAX;
1925
1926         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1927         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1928         vdrpr->streamID = vrp.getSerial();
1929         vdrpr->streamReceiver = NULL;
1930         edRegister(vdrpr);
1931
1932
1933         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1934         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1935         delete vresp;
1936
1937         return vrp.getSerial();
1938 }
1939
1940 ULONG VDR::loadTVMediaEventThumb(TVMediaInfo & media)
1941 {
1942
1943         VDR_RequestPacket vrp;
1944
1945         if (!vrp.init(VDR_LOADTVMEDIAEVENTTHUMB, false, 0)) return ULONG_MAX;
1946         if (!vrp.addULONG(media.primary_id)) return ULONG_MAX;
1947         if (!vrp.addULONG(media.secondary_id)) return ULONG_MAX;
1948
1949         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1950         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1951         vdrpr->streamID = vrp.getSerial();
1952         vdrpr->streamReceiver = NULL;
1953         edRegister(vdrpr);
1954
1955
1956         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1957         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1958         delete vresp;
1959
1960         return vrp.getSerial();
1961 }
1962
1963 ULONG VDR::loadChannelLogo(TVMediaInfo & media)
1964 {
1965
1966         VDR_RequestPacket vrp;
1967
1968         if (!vrp.init(VDR_LOADCHANNELLOGO, false, 0)) return ULONG_MAX;
1969         if (!vrp.addULONG(media.primary_id)) return ULONG_MAX;
1970
1971         VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
1972         vdrpr->receiverChannel = VDR::CHANNEL_TVMEDIA;
1973         vdrpr->streamID = vrp.getSerial();
1974         vdrpr->streamReceiver = NULL;
1975         edRegister(vdrpr);
1976
1977
1978         VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1979         //if (vresp->noResponse()) { delete vresp; return ULONG_MAX; }
1980         delete vresp;
1981
1982 //      Log::getInstance()->log("VDR", Log::DEBUG, "TVMedia Channel Logo %d %x",
1983 //                              media.primary_id,vrp.getSerial());
1984
1985         return vrp.getSerial();
1986 }