]> git.vomp.tv Git - vompserver.git/blob - vompclientrrproc.c
Support for epgimages added
[vompserver.git] / vompclientrrproc.c
1 /*
2     Copyright 2008 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, write to the Free Software
18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20
21 #include <stdlib.h>
22
23 #ifndef VOMPSTANDALONE
24 #include <vdr/recording.h>
25 #include <vdr/channels.h>
26 #include <vdr/videodir.h>
27 #include <vdr/plugin.h>
28 #include <vdr/timers.h>
29 #include <vdr/menu.h>
30 #include <vdr/remote.h>
31 #include "recplayer.h"
32 #include "mvpreceiver.h"
33 #include "services/scraper2vdr.h"
34 #endif
35
36 #include "vompclientrrproc.h"
37 #include "vompclient.h"
38 #include "log.h"
39 #include "media.h"
40 #include "mediaplayer.h"
41 #include "servermediafile.h"
42 #include "i18n.h"
43 #include "vdrcommand.h"
44 #include "picturereader.h"
45
46 bool ResumeIDLock;
47
48 ULONG VompClientRRProc::VOMP_PROTOCOL_VERSION_MIN = 0x00000301;
49 ULONG VompClientRRProc::VOMP_PROTOCOL_VERSION_MAX = 0x00000302;
50 // format is aabbccdd
51 // cc is release protocol version, increase with every release, that changes protocol
52 // dd is development protocol version, set to zero at every release, 
53 // increase for every protocol change in git
54 // bb not equal zero should indicate a non loggytronic protocol
55 // aa is reserved for future use
56 // VOMP_PROTOCOL_VERSION_MIN is the protocol version minimal supported by the server
57 // VOMP_PROTOCOL_VERSION_MAX is the protocol version maximal supported by the server
58 // This allows to run older clients from a new server
59 // Increase the minimal protocol version everytime you break compatibility for a certain 
60 // command. 
61
62 ULONG VompClientRRProc::getProtocolVersionMin()
63 {
64   return VOMP_PROTOCOL_VERSION_MIN;
65 }
66
67 ULONG VompClientRRProc::getProtocolVersionMax()
68 {
69   return VOMP_PROTOCOL_VERSION_MAX;
70 }
71
72 VompClientRRProc::VompClientRRProc(VompClient& x)
73  : x(x)
74 {
75   log = Log::getInstance();
76   req = NULL;
77   resp = NULL;
78 }
79
80 VompClientRRProc::~VompClientRRProc()
81 {
82   threadStop();
83 }
84
85 bool VompClientRRProc::init()
86 {
87   int a = threadStart();
88   sleep(1);
89   return a;
90 }
91
92 bool VompClientRRProc::recvRequest(RequestPacket* newRequest)
93 {
94   /*
95      Accept a new request
96      Now we have a queue system is used,
97      since on rare occasion the client fire two request at once
98      e.g. heavily channel switching 
99      then processing only a single request would cause a deadlock in the client
100      Marten
101   */
102
103   log->log("RRProc", Log::DEBUG, "recvReq");
104   threadLock();
105   req_queue.push(newRequest);
106   threadSignalNoLock();
107   log->log("RRProc", Log::DEBUG, "recvReq set req and signalled");     
108   threadUnlock();
109
110   return true;
111 }
112
113 void VompClientRRProc::threadMethod()
114 {
115   threadLock();
116   log->log("RRProc", Log::DEBUG, "threadMethod startup");     
117
118   if (req_queue.size() != 0)
119   {
120 /*
121 -    log->log("RRProc", Log::ERR, "threadMethod err 1");     
122 -    threadUnlock();
123 -    return;
124
125 That was how the code used to be.
126
127 TODO: Work out why this happens.
128 */  
129   
130     log->log("RRProc", Log::ERR, "threadMethod startup with already queued packets");     
131     while (req_queue.size()) 
132     {
133       //log->log("RRProc", Log::DEBUG, "thread while");
134       req = req_queue.front();
135       req_queue.pop();
136       
137       threadUnlock(); // allow recvRequest to be queuing packets while we are working on this one
138       
139       if (!processPacket())
140       {
141         log->log("RRProc", Log::ERR, "processPacket exited with fail");     
142         return;
143       }
144       
145       threadLock();
146     } 
147     log->log("RRProc", Log::ERR, "threadMethod startup with already queued packets done.");     
148
149   }
150     
151   while(1)  
152   {
153     log->log("RRProc", Log::DEBUG, "threadMethod waiting");     
154     threadWaitForSignal();  // unlocks, waits, relocks
155     if (req_queue.size() == 0)
156     {
157       log->log("RRProc", Log::INFO, "threadMethod err 2 or quit");     
158       threadUnlock();
159       return;
160     }
161     
162     // signalled with something in queue
163     
164     log->log("RRProc", Log::DEBUG, "thread woken with req, queue size: %i", req_queue.size());
165
166     while (req_queue.size()) 
167     {
168       //log->log("RRProc", Log::DEBUG, "thread while");
169       req = req_queue.front();
170       req_queue.pop();
171       
172       threadUnlock(); // allow recvRequest to be queuing packets while we are working on this one
173       
174       if (!processPacket())
175       {
176         log->log("RRProc", Log::ERR, "processPacket exited with fail");     
177         return;
178       }
179       
180       threadLock();
181     } 
182     
183     // locked and run out of packets to process
184   }  
185 }
186
187 bool VompClientRRProc::processPacket()
188 {
189   resp = new ResponsePacket();
190   if (!resp->init(req->requestID))
191   {
192     log->log("RRProc", Log::ERR, "response packet init fail");     
193     delete resp; 
194     
195     if (req->data) free(req->data);
196     delete req;
197     req = NULL;
198
199     return false;
200   }
201     
202   int result = 0;
203
204   switch(req->opcode)
205   {
206     case 1:
207       result = processLogin();
208       break;
209 #ifndef VOMPSTANDALONE        
210     case 2:
211       result = processGetRecordingsList();
212       break;
213     case 3:
214       result = processDeleteRecording();
215       break;
216     case 5:
217       result = processGetChannelsList();
218       break;
219     case 6:
220       result = processStartStreamingChannel();
221       break;
222     case 7:
223       result = processGetBlock();
224       break;
225     case 8:
226       result = processStopStreaming();
227       break;
228     case 9:
229       result = processStartStreamingRecording();
230       break;
231     case 10:
232       result = processGetChannelSchedule();
233       break;
234 #endif     
235     case 11:
236       result = processConfigSave();
237       break;
238     case 12:
239       result = processConfigLoad();
240       break;
241 #ifndef VOMPSTANDALONE        
242     case 13:
243       result = processReScanRecording();         // FIXME obselete
244       break;
245     case 14:
246       result = processGetTimers();
247       break;
248     case 15:
249       result = processSetTimer();
250       break;
251     case 16:
252       result = processPositionFromFrameNumber();
253       break;
254     case 17:
255       result = processFrameNumberFromPosition();
256       break;
257     case 18:
258       result = processMoveRecording();
259       break;
260     case 19:
261       result = processGetIFrame();
262       break;
263     case 20:
264       result = processGetRecInfo();
265       break;
266     case 21:
267       result = processGetMarks();
268       break;
269     case 22:
270       result = processGetChannelPids();
271       break;
272     case 23:
273       result = processDeleteTimer();
274       break;
275     case 666:
276       result = processVDRShutdown();
277       break;
278     case VDR_GETRECSCRAPEREVENTTYPE:
279       result = processGetRecScraperEventType();
280     break;
281     case VDR_GETSCRAPERMOVIEINFO:
282       result = processGetScraperMovieInfo();
283     break;
284     case VDR_GETSCRAPERSERIESINFO:
285       result = processGetScraperSeriesInfo();
286     break;
287     case VDR_LOADTVMEDIA:
288       result = processLoadTvMedia();
289     break;
290     case VDR_LOADTVMEDIARECTHUMB:
291       result = processLoadTvMediaRecThumb();
292     break;
293     case VDR_GETEVENTSCRAPEREVENTTYPE:
294       result = processGetEventScraperEventType();
295     break;
296     case VDR_LOADTVMEDIAEVENTTHUMB:
297       result = processLoadTvMediaEventThumb();
298     break;
299     case VDR_LOADCHANNELLOGO:
300       result = processLoadChannelLogo();
301     break;
302 #endif
303     case VDR_GETMEDIALIST:
304       result = processGetMediaList();
305       break;
306     case VDR_OPENMEDIA:
307       result = processOpenMedia();
308       break;
309     case VDR_GETMEDIABLOCK:
310       result = processGetMediaBlock();
311       break;
312     case 33:
313       result = processGetLanguageList();
314       break;
315     case 34:
316       result = processGetLanguageContent();
317       break;
318     case VDR_GETMEDIAINFO:
319             result = processGetMediaInfo();
320             break;
321     case VDR_CLOSECHANNEL:
322             result = processCloseMediaChannel();
323             break;
324     case 37:
325       result = processSetCharset();
326       break;
327   }
328
329   delete resp;
330   resp = NULL;
331   
332   if (req->data) free(req->data);
333   delete req;
334   req = NULL;
335   
336   if (result) return true;
337   return false;
338 }
339
340 int VompClientRRProc::processLogin()
341 {
342   if (req->dataLength != 6) return 0;
343
344   // Open the config
345
346   char configFileName[PATH_MAX];
347   snprintf(configFileName, PATH_MAX, "%s/vomp-%02X-%02X-%02X-%02X-%02X-%02X.conf", x.configDir, req->data[0], req->data[1], req->data[2], req->data[3], req->data[4], req->data[5]);
348   x.config.init(configFileName);
349
350   // Send the login reply
351
352   time_t timeNow = time(NULL);
353   struct tm* timeStruct = localtime(&timeNow);
354   int timeOffset = timeStruct->tm_gmtoff;
355
356   resp->addULONG(timeNow);
357   resp->addLONG(timeOffset);
358   resp->addULONG(VOMP_PROTOCOL_VERSION_MIN);
359   resp->addULONG(VOMP_PROTOCOL_VERSION_MAX);
360   resp->finalise();
361   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
362   log->log("RRProc", Log::DEBUG, "written login reply len %lu", resp->getLen());
363     
364   x.loggedIn = true;
365   x.netLog(); // safe to run here since the client won't start net logging for a while yet
366   
367   return 1;
368 }
369
370 int VompClientRRProc::processSetCharset()
371 {
372   int charset = ntohl(*(ULONG*)req->data);
373   if (charset>0 && charset<3)
374   {
375     log->log("RRProc", Log::DEBUG, "Set charset to %d", charset);
376     x.setCharset(charset);
377     resp->addULONG(1);
378   }
379   else
380   {
381     log->log("RRProc", Log::DEBUG, "Invalid charset %d", charset);
382     resp->addULONG(0);
383   }
384   resp->finalise();
385   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
386   return 1;
387 }
388
389 int VompClientRRProc::processConfigSave()
390 {
391   char* section = (char*)req->data;
392   char* key = NULL;
393   char* value = NULL;
394
395   for (UINT k = 0; k < req->dataLength; k++)
396   {
397     if (req->data[k] == '\0')
398     {
399       if (!key)
400       {
401         key = (char*)&req->data[k+1];
402       }
403       else
404       {
405         value = (char*)&req->data[k+1];
406         break;
407       }
408     }
409   }
410
411   // if the last string (value) doesnt have null terminator, give up
412   if (req->data[req->dataLength - 1] != '\0') return 0;
413
414   log->log("RRProc", Log::DEBUG, "Config save: %s %s %s", section, key, value);
415   if (x.config.setValueString(section, key, value))
416   {
417     resp->addULONG(1);
418   }
419   else
420   {
421     resp->addULONG(0);
422   }
423
424   resp->finalise();
425   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
426   
427   return 1;
428 }
429
430 int VompClientRRProc::processConfigLoad()
431 {
432   char* section = (char*)req->data;
433   char* key = NULL;
434
435   for (UINT k = 0; k < req->dataLength; k++)
436   {
437     if (req->data[k] == '\0')
438     {
439       key = (char*)&req->data[k+1];
440       break;
441     }
442   }
443
444   char* value = x.config.getValueString(section, key);
445
446   if (value)
447   {
448     resp->addString(value);//client coding, do not touch
449     log->log("RRProc", Log::DEBUG, "Written config load packet");
450     delete[] value;
451   }
452   else
453   {
454     resp->addULONG(0);
455     log->log("RRProc", Log::DEBUG, "Written config load failed packet");
456   }
457
458   resp->finalise();
459   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
460   
461   return 1;
462 }
463
464
465 //helper for sending from a serialize buffer
466 //insert the used len into the first 4 Bytes of the buffer
467 void VompClientRRProc::sendPacket(SerializeBuffer *b) {
468   resp->copyin(b->getStart(),b->getCurrent()-b->getStart());
469   resp->finalise();
470   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
471 }
472
473 /**
474   * media List Request:
475   * Media List response:
476   * flags, mediaList
477 */
478 #define MLISTBUF 500000
479 int VompClientRRProc::processGetMediaList()
480 {
481   SerializeBuffer buffer(req->data,req->dataLength);
482   MediaURI uri(0,NULL,NULL);
483   VDR_GetMediaListRequest request(&uri);
484   if (request.deserialize(&buffer) != 0) {
485     log->log("Client", Log::ERR, "getMediaList unable to deserialize");
486     return 0;
487   }
488   const char *dirname=uri.getName();
489   log->log("Client", Log::DEBUG, "getMediaList for %s", dirname);
490
491   MediaList * ml=NULL;
492   if (dirname == NULL) {
493     ml=x.media->getRootList();
494   } else {
495     ml=x.media->getMediaList(&uri);
496   }
497   if (ml == NULL) {
498      log->log("Client", Log::ERR, "getMediaList returned NULL");
499      return 0;
500   }
501   SerializeBuffer rbuf(MLISTBUF,false,true);
502   ULONG flags=0; //TODO: real error handling by setting flags
503   VDR_GetMediaListResponse response(&flags,ml);
504   if (response.serialize(&rbuf) != 0) {
505      log->log("Client", Log::ERR, "getMediaList returned NULL");
506      delete ml;
507      return 0;
508   }
509   log->log("Client", Log::DEBUG, "getMediaList size  %u", ml->size());
510   delete ml;
511   
512
513   sendPacket(&rbuf);
514   log->log("Client", Log::DEBUG, "Written Media list");
515   return 1;
516 }
517 /**
518   * openMedia Request:
519   * openMedia response:
520 */
521 int VompClientRRProc::processOpenMedia()
522 {
523   SerializeBuffer buffer(req->data,req->dataLength);
524   MediaURI uri(0,NULL,NULL);
525   ULONG channel=0;
526   ULONG xs=0;
527   ULONG ys=0;
528   VDR_OpenMediumRequest request(&channel,&uri,&xs,&ys);
529   if (request.deserialize(&buffer) != 0) {
530     log->log("Client", Log::ERR, "openMediaRequest unable to deserialize");
531     return 0;
532   }
533   const char *name=uri.getName();
534   log->log("Client", Log::DEBUG, "openMediaRequest for %s", name);
535   ULLONG size=0;
536   int rt=x.media->openMedium(channel,&uri,&size,xs,ys);
537   ULONG flags=0;
538   if (rt != 0) {
539     size=0;
540     flags=1;
541     log->log("Client", Log::ERR, "openMediaRequest unable to open");
542   }
543   VDR_OpenMediumResponse response(&flags,&size);
544   SerializeBuffer rbuf(response.getSerializedLen()+4,false,true);
545   if (response.serialize(&rbuf) != 0) {
546      log->log("Client", Log::ERR, "openMediaRequest cannot serialize");
547      return 0;
548   }
549   log->log("Client", Log::DEBUG, "openMediaRequest size  %llu", size);
550   sendPacket(&rbuf);
551   return 1;
552 }
553 /**
554   * VDR_GETMEDIABLOCK
555   * resp
556   * packet - no serialized response!
557   */
558 int VompClientRRProc::processGetMediaBlock()
559 {
560   SerializeBuffer buffer(req->data,req->dataLength);
561   ULLONG position = 0;
562   ULONG amount = 0;
563   ULONG channel = 0;
564   VDR_GetMediaBlockRequest request(&channel,&position,&amount);
565   if (request.deserialize(&buffer) != 0) {
566     log->log("Client", Log::ERR, "getMediaBlock unable to deserialize");
567     return 0;
568   }
569   log->log("Client", Log::DEBUG, "getMediaBlock pos = %llu length = %lu,chan=%lu", position, amount,channel);
570
571   UCHAR sendBuffer[amount ];
572   ULONG amountReceived = 0; 
573   UCHAR *rbuf=sendBuffer;
574   int rt=x.media->getMediaBlock(channel,position,amount,&amountReceived,&rbuf);
575   if (!amountReceived || rt != 0)
576   {
577     log->log("Client", Log::DEBUG, "written 4(0) as getblock got 0");
578   }
579   else
580   {
581     if (rbuf != sendBuffer) {
582       //the provider did not use the optimized handling with using my buffer
583       resp->copyin(rbuf,amountReceived);
584       free(rbuf);
585     } else {
586       // the provider did not allocate a new buffer
587       resp->copyin(sendBuffer,amountReceived);
588     }
589   }
590   resp->finalise();
591   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
592   log->log("Client", Log::DEBUG, "written ok %lu", amountReceived);
593   return 1;
594 }
595 /**
596   * VDR_GETMEDIAINFO
597   */
598
599 int VompClientRRProc::processGetMediaInfo()
600 {
601   SerializeBuffer buffer(req->data,req->dataLength);
602   ULONG channel=0;
603   VDR_GetMediaInfoRequest request(&channel);
604   if (request.deserialize(&buffer) != 0) {
605     log->log("Client", Log::ERR, "getMediaInfo unable to deserialize");
606     return 0;
607   }
608   log->log("Client", Log::DEBUG, "getMediaInfo chan=%lu", channel);
609   ULONG flags=0;
610   MediaInfo mi;
611   int rt=x.media->getMediaInfo(channel,&mi);
612   if (rt != 0) {
613     flags=1;
614     log->log("Client", Log::ERR, "getMediaInfo unable to get");
615   }
616   VDR_GetMediaInfoResponse response(&flags,&mi);
617   SerializeBuffer rbuf(response.getSerializedLen()+4,false,true);
618   if (response.serialize(&rbuf) != 0) {
619      log->log("Client", Log::ERR, "getMediaInfo cannot serialize");
620      return 0;
621   }
622   sendPacket(&rbuf);
623   return 1;
624 }
625
626 /**
627   * VDR_CLOSECHANNEL
628   */
629
630
631 int VompClientRRProc::processCloseMediaChannel()
632 {
633   SerializeBuffer buffer(req->data,req->dataLength);
634   ULONG channel=0;
635   VDR_CloseMediaChannelRequest request(&channel);
636   if (request.deserialize(&buffer) != 0) {
637     log->log("Client", Log::ERR, "closeMediaChannel unable to deserialize");
638     return 0;
639   }
640   ULONG flags=0;
641   log->log("Client", Log::DEBUG, "closeMediaChannel chan=%lu", channel);
642   int rt=x.media->closeMediaChannel(channel);
643   if (rt != 0) {
644     flags=1;
645     log->log("Client", Log::ERR, "closeMediaChannel unable to get");
646   }
647   VDR_CloseMediaChannelResponse response(&flags);
648   SerializeBuffer rbuf(response.getSerializedLen()+4,false,true);
649   if (response.serialize(&rbuf) != 0) {
650      log->log("Client", Log::ERR, "closeMediaChannel cannot serialize");
651      return 0;
652   }
653   sendPacket(&rbuf);
654   return 1;
655 }
656
657
658
659 int VompClientRRProc::processGetLanguageList()
660 {
661   x.i18n.findLanguages();
662   const I18n::lang_code_list& languages = x.i18n.getLanguageList();
663   std::string result;
664   I18n::lang_code_list::const_iterator iter;
665   for (iter = languages.begin(); iter != languages.end(); ++iter)
666   {
667     resp->addString(iter->first.c_str()); // Source code is acsii
668     resp->addString(x.charconvutf8->Convert(iter->second.c_str())); //translate string can be any utf-8 character
669   }
670   resp->finalise();
671   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
672   return 1;
673 }
674
675 int VompClientRRProc::processGetLanguageContent()
676 {
677   if (req->dataLength <= 0) return 0;
678   std::string code, result;
679   code.assign((char*)req->data, req->dataLength - 1);
680   x.i18n.findLanguages();
681   I18n::trans_table texts = x.i18n.getLanguageContent(code);
682   I18n::trans_table::const_iterator iter;
683   for (iter = texts.begin(); iter != texts.end(); ++iter)
684   {
685     resp->addString(iter->first.c_str());// source code is acsii since it is english
686     resp->addString(x.charconvutf8->Convert(iter->second.c_str())); // translate text can be any unicode string, it is stored as UTF-8
687   }
688   resp->finalise();
689   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
690   return 1;
691 }
692
693 #ifndef VOMPSTANDALONE
694
695 int VompClientRRProc::processGetRecordingsList()
696 {
697   int FreeMB;
698 #if APIVERSNUM > 20101
699   int Percent = cVideoDirectory::VideoDiskSpace(&FreeMB);
700 #else
701   int Percent = VideoDiskSpace(&FreeMB);
702 #endif
703   int Total = (FreeMB / (100 - Percent)) * 100;
704   
705   resp->addULONG(Total);
706   resp->addULONG(FreeMB);
707   resp->addULONG(Percent);
708   
709   cRecordings Recordings;
710   Recordings.Load();
711
712   for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording))
713   {
714 #if VDRVERSNUM < 10721
715     resp->addULONG(recording->start);
716 #else
717     resp->addULONG(recording->Start());
718 #endif
719     resp->addUCHAR(recording->IsNew() ? 1 : 0);
720     resp->addString(x.charconvsys->Convert(recording->Name())); //coding of recording name is system dependent
721     resp->addString(recording->FileName());//file name are not  visible by user do not touch
722   }
723
724   resp->finalise();
725   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
726   
727   log->log("RRProc", Log::DEBUG, "Written recordings list");
728
729   return 1;
730 }
731
732 int VompClientRRProc::processDeleteRecording()
733 {
734   // data is a pointer to the fileName string
735
736   cRecordings Recordings;
737   Recordings.Load(); // probably have to do this
738
739   cRecording* recording = Recordings.GetByName((char*)req->data);
740
741   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
742
743   if (recording)
744   {
745     log->log("RRProc", Log::DEBUG, "deleting recording: %s", recording->Name());
746
747     cRecordControl *rc = cRecordControls::GetRecordControl(recording->FileName());
748     if (!rc)
749     {
750       if (recording->Delete())
751       {
752         // Copy svdrp's way of doing this, see if it works
753 #if VDRVERSNUM > 10300
754         ::Recordings.DelByName(recording->FileName());
755 #endif
756         resp->addULONG(1);
757       }
758       else
759       {
760         resp->addULONG(2);
761       }
762     }
763     else
764     {
765       resp->addULONG(3);
766     }
767   }
768   else
769   {
770     resp->addULONG(4);
771   }
772
773   resp->finalise();
774   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
775   
776   return 1;
777 }
778
779 int VompClientRRProc::processMoveRecording()
780 {
781   log->log("RRProc", Log::DEBUG, "Process move recording");
782   char* fileName = (char*)req->data;
783   char* newPath = NULL;
784
785   for (UINT k = 0; k < req->dataLength; k++)
786   {
787     if (req->data[k] == '\0')
788     {
789       newPath = (char*)&req->data[k+1];
790       break;
791     }
792   }
793   if (!newPath) return 0;
794
795   cRecordings Recordings;
796   Recordings.Load(); // probably have to do this
797
798   cRecording* recording = Recordings.GetByName((char*)fileName);
799
800   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
801
802   if (recording)
803   {
804     cRecordControl *rc = cRecordControls::GetRecordControl(recording->FileName());
805     if (!rc)
806     {
807       log->log("RRProc", Log::DEBUG, "moving recording: %s", recording->Name());
808       log->log("RRProc", Log::DEBUG, "moving recording: %s", recording->FileName());
809       log->log("RRProc", Log::DEBUG, "to: %s", newPath);
810
811       const char* t = recording->FileName();
812
813       char* dateDirName = NULL;   int k;
814       char* titleDirName = NULL;  int j;
815
816       // Find the datedirname
817       for(k = strlen(t) - 1; k >= 0; k--)
818       {
819         if (t[k] == '/')
820         {
821           log->log("RRProc", Log::DEBUG, "l1: %i", strlen(&t[k+1]) + 1);
822           dateDirName = new char[strlen(&t[k+1]) + 1];
823           strcpy(dateDirName, &t[k+1]);
824           break;
825         }
826       }
827
828       // Find the titledirname
829
830       for(j = k-1; j >= 0; j--)
831       {
832         if (t[j] == '/')
833         {
834           log->log("RRProc", Log::DEBUG, "l2: %i", (k - j - 1) + 1);
835           titleDirName = new char[(k - j - 1) + 1];
836           memcpy(titleDirName, &t[j+1], k - j - 1);
837           titleDirName[k - j - 1] = '\0';
838           break;
839         }
840       }
841
842       log->log("RRProc", Log::DEBUG, "datedirname: %s", dateDirName);
843       log->log("RRProc", Log::DEBUG, "titledirname: %s", titleDirName);
844 #if APIVERSNUM > 20101
845       log->log("RRProc", Log::DEBUG, "viddir: %s", cVideoDirectory::Name());
846 #else
847       log->log("RRProc", Log::DEBUG, "viddir: %s", VideoDirectory);
848 #endif
849
850       char* newPathConv = new char[strlen(newPath)+1];
851       strcpy(newPathConv, newPath);
852       ExchangeChars(newPathConv, true);
853       log->log("RRProc", Log::DEBUG, "EC: %s", newPathConv);
854
855 #if APIVERSNUM > 20101
856       char* newContainer = new char[strlen(cVideoDirectory::Name()) + strlen(newPathConv) + strlen(titleDirName) + 1];
857       log->log("RRProc", Log::DEBUG, "l10: %i", strlen(cVideoDirectory::Name()) + strlen(newPathConv) + strlen(titleDirName) + 1);
858       sprintf(newContainer, "%s%s%s", cVideoDirectory::Name(), newPathConv, titleDirName);
859 #else
860       char* newContainer = new char[strlen(VideoDirectory) + strlen(newPathConv) + strlen(titleDirName) + 1];
861       log->log("RRProc", Log::DEBUG, "l10: %i", strlen(VideoDirectory) + strlen(newPathConv) + strlen(titleDirName) + 1);
862       sprintf(newContainer, "%s%s%s", VideoDirectory, newPathConv, titleDirName);
863 #endif
864       delete[] newPathConv;
865
866       log->log("RRProc", Log::DEBUG, "%s", newContainer);
867
868       struct stat dstat;
869       int statret = stat(newContainer, &dstat);
870       if ((statret == -1) && (errno == ENOENT)) // Dir does not exist
871       {
872         log->log("RRProc", Log::DEBUG, "new dir does not exist");
873         int mkdirret = mkdir(newContainer, 0755);
874         if (mkdirret != 0)
875         {
876           delete[] dateDirName;
877           delete[] titleDirName;
878           delete[] newContainer;
879
880           resp->addULONG(5);          
881           resp->finalise();
882           x.tcp.sendPacket(resp->getPtr(), resp->getLen());
883           return 1;
884         }
885       }
886       else if ((statret == 0) && (! (dstat.st_mode && S_IFDIR))) // Something exists but it's not a dir
887       {
888         delete[] dateDirName;
889         delete[] titleDirName;
890         delete[] newContainer;
891
892         resp->addULONG(5);          
893         resp->finalise();
894         x.tcp.sendPacket(resp->getPtr(), resp->getLen());
895         return 1;
896       }
897
898       // Ok, the directory container has been made, or it pre-existed.
899
900       char* newDir = new char[strlen(newContainer) + 1 + strlen(dateDirName) + 1];
901       sprintf(newDir, "%s/%s", newContainer, dateDirName);
902
903       log->log("RRProc", Log::DEBUG, "doing rename '%s' '%s'", t, newDir);
904       int renameret = rename(t, newDir);
905       if (renameret == 0)
906       {
907         // Success. Test for remove old dir containter
908         char* oldTitleDir = new char[k+1];
909         memcpy(oldTitleDir, t, k);
910         oldTitleDir[k] = '\0';
911         log->log("RRProc", Log::DEBUG, "len: %i, cp: %i, strlen: %i, oldtitledir: %s", k+1, k, strlen(oldTitleDir), oldTitleDir);
912         rmdir(oldTitleDir); // can't do anything about a fail result at this point.
913         delete[] oldTitleDir;
914       }
915
916       if (renameret == 0)
917       {
918 #if VDRVERSNUM > 10311
919         // Tell VDR
920         ::Recordings.Update();
921 #endif
922         // Success. Send a different packet from just a ulong
923         resp->addULONG(1); // success
924         resp->addString(newDir); //system depent do not convert
925       }
926       else
927       {
928         resp->addULONG(5);          
929       }
930
931       resp->finalise();
932       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
933
934       delete[] dateDirName;
935       delete[] titleDirName;
936       delete[] newContainer;
937       delete[] newDir;
938     }
939     else
940     {
941       resp->addULONG(3);          
942       resp->finalise();
943       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
944     }
945   }
946   else
947   {
948     resp->addULONG(4);          
949     resp->finalise();
950     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
951   }
952
953   return 1;
954 }
955
956 int VompClientRRProc::processGetChannelsList()
957 {
958   ULONG type;
959
960   char* chanConfig = x.config.getValueString("General", "Channels");
961   int allChans = 1;
962   if (chanConfig) allChans = strcasecmp(chanConfig, "FTA only");
963
964   for (cChannel *channel = Channels.First(); channel; channel = Channels.Next(channel))
965   {
966 #if VDRVERSNUM < 10300
967     if (!channel->GroupSep() && (!channel->Ca() || allChans))
968 #else
969     if (!channel->GroupSep() && (!channel->Ca(0) || allChans))
970 #endif
971     {
972       log->log("RRProc", Log::DEBUG, "name: '%s'", channel->Name());
973
974       if (channel->Vpid()) type = 1;
975 #if VDRVERSNUM < 10300
976       else type = 2;
977 #else
978       else if (channel->Apid(0)) type = 2;
979       else continue;
980 #endif
981
982       resp->addULONG(channel->Number());
983       resp->addULONG(type);      
984       resp->addString(x.charconvsys->Convert(channel->Name()));
985 #if VDRVERSNUM < 10703
986       resp->addULONG(2);
987 #else
988       resp->addULONG(channel->Vtype());
989 #endif      
990     }
991   }
992
993   resp->finalise();
994   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
995
996   log->log("RRProc", Log::DEBUG, "Written channels list");
997
998   return 1;
999 }
1000
1001 int VompClientRRProc::processGetChannelPids()
1002 {
1003   ULONG channelNumber = ntohl(*(ULONG*)req->data);
1004
1005   cChannel* channel = x.channelFromNumber(channelNumber);
1006   if (!channel)
1007   {
1008     resp->addULONG(0);
1009     resp->finalise();
1010     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1011     return 1;
1012   }
1013
1014   ULONG numApids = 0;
1015   ULONG numDpids = 0;
1016   ULONG numSpids = 0;
1017
1018
1019 #if VDRVERSNUM < 10300
1020
1021   log->log("RRProc", Log::DEBUG, "Apid1: %i", channel->Apid1());
1022   log->log("RRProc", Log::DEBUG, "Apid2: %i", channel->Apid2());
1023
1024   if (channel->Apid2())
1025     numApids = 2;
1026   else if (channel->Apid1())
1027     numApids = 1;
1028   else
1029     numApids = 0;
1030
1031 #else
1032
1033   for (const int *Apid = channel->Apids(); *Apid; Apid++)
1034   {
1035     numApids++;
1036   }
1037   for (const int *Dpid = channel->Dpids(); *Dpid; Dpid++)
1038   {
1039     numDpids++;
1040   }
1041   for (const int *Spid = channel->Spids(); *Spid; Spid++)
1042   {
1043     numSpids++;
1044   }
1045 #endif
1046
1047
1048   // Format of response
1049   // vpid
1050   // number of apids
1051   // {
1052   //    apid
1053   //    lang string
1054   // }
1055   // number of dpids
1056   // {
1057   //    dpid
1058   //    lang string
1059   // }
1060   // number of spids
1061   // {
1062   //    spid
1063   //    lang string
1064   // }
1065   // tpid
1066
1067   resp->addULONG(channel->Vpid());
1068 #if VDRVERSNUM < 10703
1069   resp->addULONG(2);
1070 #else
1071   resp->addULONG(channel->Vtype());
1072 #endif
1073   resp->addULONG(numApids);
1074
1075 #if VDRVERSNUM < 10300
1076   if (numApids >= 1)
1077   {
1078     resp->addULONG(channel->Apid1());
1079     resp->addString("");
1080   }
1081   if (numApids == 2)
1082   {
1083     resp->addULONG(channel->Apid2());
1084     resp->addString("");
1085   }
1086   resp->addULONG(0);
1087   resp->addULONG(0); 
1088 #else
1089   for (ULONG i = 0; i < numApids; i++)
1090   {
1091     resp->addULONG(channel->Apid(i));
1092     resp->addString(x.charconvsys->Convert(channel->Alang(i)));
1093   }
1094   resp->addULONG(numDpids);
1095   for (ULONG i = 0; i < numDpids; i++)
1096   {
1097     resp->addULONG(channel->Dpid(i));
1098     resp->addString(x.charconvsys->Convert(channel->Dlang(i)));
1099   }
1100   resp->addULONG(numSpids);
1101   for (ULONG i = 0; i < numSpids; i++)
1102   {
1103     resp->addULONG(channel->Spid(i));
1104     resp->addString(x.charconvsys->Convert(channel->Slang(i)));
1105   }
1106 #endif
1107   resp->addULONG(channel->Tpid());
1108   // Format of extended response, for compatibility with older client at the end
1109   // {
1110   //    atypes
1111   // }
1112   // {
1113   //    dtypes
1114   // }
1115   // {
1116   //    stypes
1117   //    comppageid
1118   //    ancpageids
1119   // }
1120 #if VDRVERSNUM < 10300
1121   if (numApids >= 1)
1122   {
1123     resp->addULONG(4);
1124   }
1125   if (numApids == 2)
1126   {
1127     resp->addULONG(4);
1128   }
1129 #else
1130   for (ULONG i = 0; i < numApids; i++)
1131   {
1132 #if VDRVERSNUM < 10715
1133     resp->addULONG(4);
1134 #else
1135     resp->addULONG(channel->Atype(i));
1136 #endif
1137   }
1138   for (ULONG i = 0; i < numDpids; i++)
1139   {
1140 #if VDRVERSNUM < 10715
1141     resp->addULONG(0x6A /*AC3*/);
1142 #else
1143     resp->addULONG(channel->Dtype(i));
1144 #endif
1145   }
1146   for (ULONG i = 0; i < numSpids; i++)
1147   {
1148 #if VDRVERSNUM < 10715
1149     resp->addULONG(0);
1150     resp->addULONG(0);
1151     resp->addULONG(0);
1152 #else
1153     resp->addULONG(channel->SubtitlingType(i));
1154     resp->addULONG(channel->CompositionPageId(i));
1155     resp->addULONG(channel->AncillaryPageId(i));
1156 #endif
1157   }
1158 #endif
1159
1160
1161   resp->finalise();
1162   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1163   
1164   log->log("RRProc", Log::DEBUG, "Written channels pids");
1165
1166   return 1;
1167 }
1168
1169 int VompClientRRProc::processStartStreamingChannel()
1170 {
1171   if (x.lp)
1172   {
1173     log->log("RRProc", Log::ERR, "Client called start streaming twice");
1174     return 0;
1175   }
1176   
1177   log->log("RRProc", Log::DEBUG, "req->dataLength = %i", req->dataLength);
1178   ULONG channelNumber = ntohl(*(ULONG*)req->data);
1179
1180   cChannel* channel = x.channelFromNumber(channelNumber);
1181   if (!channel)
1182   {
1183     resp->addULONG(0);
1184     resp->finalise();
1185     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1186     return 1;
1187   }
1188
1189   // get the priority we should use
1190   int fail = 1;
1191   int priority = x.config.getValueLong("General", "Live priority", &fail);
1192   if (!fail)
1193   {
1194     log->log("RRProc", Log::DEBUG, "Config: Live TV priority: %i", priority);
1195   }
1196   else
1197   {
1198     log->log("RRProc", Log::DEBUG, "Config: Live TV priority config fail");
1199     priority = 0;
1200   }
1201
1202   // a bit of sanity..
1203 #if VDRVERSNUM < 10725
1204   if (priority < 0) priority = 0;
1205 #else 
1206   if (priority < -99) priority = -99;
1207 #endif
1208   if (priority > 99) priority = 99;
1209
1210   log->log("RRProc", Log::DEBUG, "Using live TV priority %i", priority);
1211   x.lp = MVPReceiver::create(channel, priority);
1212
1213   if (!x.lp)
1214   {
1215     resp->addULONG(0);
1216     resp->finalise();
1217     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1218     return 1;
1219   }
1220
1221   if (!x.lp->init(&x.tcp, req->requestID))
1222   {
1223     delete x.lp;
1224     x.lp = NULL;
1225     resp->addULONG(0);
1226     resp->finalise();
1227     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1228     return 1;
1229   }
1230
1231   resp->addULONG(1);
1232   resp->finalise();
1233   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1234   return 1;
1235 }
1236
1237 int VompClientRRProc::processStopStreaming()
1238 {
1239   log->log("RRProc", Log::DEBUG, "STOP STREAMING RECEIVED");
1240   if (x.lp)
1241   {
1242     x.lp->detachMVPReceiver();
1243     delete x.lp;
1244     x.lp = NULL;
1245   }
1246   else if (x.recplayer)
1247   {
1248     x.writeResumeData();
1249
1250     delete x.recplayer;
1251     delete x.recordingManager;
1252     x.recplayer = NULL;
1253     x.recordingManager = NULL;
1254   }
1255
1256   resp->addULONG(1);
1257   resp->finalise();
1258   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1259   return 1;
1260 }
1261
1262 int VompClientRRProc::processGetBlock()
1263 {
1264   if (x.lp)
1265   {
1266     log->log("RRProc", Log::ERR, "Get block called during live streaming");
1267     return 0;
1268   }
1269
1270   if (!x.recplayer)
1271   {
1272     log->log("RRProc", Log::ERR, "Get block called when no recording open");
1273     return 0;
1274   }
1275
1276   UCHAR* data = req->data;
1277
1278   ULLONG position = x.ntohll(*(ULLONG*)data);
1279   data += sizeof(ULLONG);
1280   ULONG amount = ntohl(*(ULONG*)data);
1281
1282   log->log("RRProc", Log::DEBUG, "getblock pos = %llu length = %lu", position, amount);
1283
1284   UCHAR sendBuffer[amount];
1285   ULONG amountReceived = x.recplayer->getBlock(&sendBuffer[0], position, amount);
1286
1287   if (!amountReceived)
1288   {
1289     resp->addULONG(0);
1290     log->log("RRProc", Log::DEBUG, "written 4(0) as getblock got 0");
1291   }
1292   else
1293   {
1294     resp->copyin(sendBuffer, amountReceived);
1295     log->log("RRProc", Log::DEBUG, "written %lu", amountReceived);
1296   }
1297
1298   resp->finalise();
1299   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1300   log->log("RRProc", Log::DEBUG, "Finished getblock, have sent %lu", resp->getLen());
1301   return 1;
1302 }
1303
1304 int VompClientRRProc::processStartStreamingRecording()
1305 {
1306   // data is a pointer to the fileName string
1307
1308   x.recordingManager = new cRecordings;
1309   x.recordingManager->Load();
1310
1311   cRecording* recording = x.recordingManager->GetByName((char*)req->data);
1312
1313   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
1314
1315   if (recording)
1316   {
1317     x.recplayer = new RecPlayer(recording);
1318
1319     resp->addULLONG(x.recplayer->getLengthBytes());
1320     resp->addULONG(x.recplayer->getLengthFrames());
1321     
1322 #if VDRVERSNUM < 10703
1323     resp->addUCHAR(true);//added for TS    
1324 #else
1325     resp->addUCHAR(recording->IsPesRecording());//added for TS
1326 #endif
1327
1328     resp->finalise();
1329     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1330     
1331     log->log("RRProc", Log::DEBUG, "written totalLength");
1332   }
1333   else
1334   {
1335     delete x.recordingManager;
1336     x.recordingManager = NULL;
1337   }
1338   return 1;
1339 }
1340
1341 int VompClientRRProc::processPositionFromFrameNumber()
1342 {
1343   ULLONG retval = 0;
1344
1345   ULONG frameNumber = ntohl(*(ULONG*)req->data);
1346
1347   if (!x.recplayer)
1348   {
1349     log->log("RRProc", Log::DEBUG, "Rescan recording called when no recording being played!");
1350   }
1351   else
1352   {
1353     retval = x.recplayer->positionFromFrameNumber(frameNumber);
1354   }
1355
1356   resp->addULLONG(retval);
1357   resp->finalise();
1358   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1359
1360   log->log("RRProc", Log::DEBUG, "Wrote posFromFrameNum reply to client");
1361   return 1;
1362 }
1363
1364 int VompClientRRProc::processFrameNumberFromPosition()
1365 {
1366   ULONG retval = 0;
1367
1368   ULLONG position = x.ntohll(*(ULLONG*)req->data);
1369
1370   if (!x.recplayer)
1371   {
1372     log->log("RRProc", Log::DEBUG, "Rescan recording called when no recording being played!");
1373   }
1374   else
1375   {
1376     retval = x.recplayer->frameNumberFromPosition(position);
1377   }
1378
1379   resp->addULONG(retval);
1380   resp->finalise();
1381   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1382
1383   log->log("RRProc", Log::DEBUG, "Wrote frameNumFromPos reply to client");
1384   return 1;
1385 }
1386
1387 int VompClientRRProc::processGetIFrame()
1388 {
1389   bool success = false;
1390
1391   ULONG* data = (ULONG*)req->data;
1392
1393   ULONG frameNumber = ntohl(*data);
1394   data++;
1395   ULONG direction = ntohl(*data);
1396
1397   ULLONG rfilePosition = 0;
1398   ULONG rframeNumber = 0;
1399   ULONG rframeLength = 0;
1400
1401   if (!x.recplayer)
1402   {
1403     log->log("RRProc", Log::DEBUG, "GetIFrame recording called when no recording being played!");
1404   }
1405   else
1406   {
1407     success = x.recplayer->getNextIFrame(frameNumber, direction, &rfilePosition, &rframeNumber, &rframeLength);
1408   }
1409
1410   // returns file position, frame number, length
1411
1412   if (success)
1413   {
1414     resp->addULLONG(rfilePosition);
1415     resp->addULONG(rframeNumber);
1416     resp->addULONG(rframeLength);
1417   }
1418   else
1419   {
1420     resp->addULONG(0);
1421   }
1422
1423   resp->finalise();
1424   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1425   
1426   log->log("RRProc", Log::DEBUG, "Wrote GNIF reply to client %llu %lu %lu", rfilePosition, rframeNumber, rframeLength);
1427   return 1;
1428 }
1429
1430 int VompClientRRProc::processGetChannelSchedule()
1431 {
1432   ULONG* data = (ULONG*)req->data;
1433
1434   ULONG channelNumber = ntohl(*data);
1435   data++;
1436   ULONG startTime = ntohl(*data);
1437   data++;
1438   ULONG duration = ntohl(*data);
1439
1440   log->log("RRProc", Log::DEBUG, "get schedule called for channel %lu", channelNumber);
1441
1442   cChannel* channel = x.channelFromNumber(channelNumber);
1443   if (!channel)
1444   {
1445     resp->addULONG(0);
1446     resp->finalise();
1447     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1448   
1449     log->log("RRProc", Log::DEBUG, "written 0 because channel = NULL");
1450     return 1;
1451   }
1452
1453   log->log("RRProc", Log::DEBUG, "Got channel");
1454
1455 #if VDRVERSNUM < 10300
1456   cMutexLock MutexLock;
1457   const cSchedules *Schedules = cSIProcessor::Schedules(MutexLock);
1458 #else
1459   cSchedulesLock MutexLock;
1460   const cSchedules *Schedules = cSchedules::Schedules(MutexLock);
1461 #endif
1462   if (!Schedules)
1463   {
1464     resp->addULONG(0);
1465     resp->finalise();
1466     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1467     
1468     log->log("RRProc", Log::DEBUG, "written 0 because Schedule!s! = NULL");
1469     return 1;
1470   }
1471
1472   log->log("RRProc", Log::DEBUG, "Got schedule!s! object");
1473
1474   const cSchedule *Schedule = Schedules->GetSchedule(channel->GetChannelID());
1475   if (!Schedule)
1476   {
1477     resp->addULONG(0);
1478     resp->finalise();
1479     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1480     
1481     log->log("RRProc", Log::DEBUG, "written 0 because Schedule = NULL");
1482     return 1;
1483   }
1484
1485   log->log("RRProc", Log::DEBUG, "Got schedule object");
1486
1487   const char* empty = "";
1488   bool atLeastOneEvent = false;
1489
1490   ULONG thisEventID;
1491   ULONG thisEventTime;
1492   ULONG thisEventDuration;
1493   const char* thisEventTitle;
1494   const char* thisEventSubTitle;
1495   const char* thisEventDescription;
1496
1497 #if VDRVERSNUM < 10300
1498
1499   const cEventInfo *event;
1500   for (int eventNumber = 0; eventNumber < Schedule->NumEvents(); eventNumber++)
1501   {
1502     event = Schedule->GetEventNumber(eventNumber);
1503
1504     thisEventID = event->GetEventID();
1505     thisEventTime = event->GetTime();
1506     thisEventDuration = event->GetDuration();
1507     thisEventTitle = event->GetTitle();
1508     thisEventSubTitle = event->GetSubtitle();
1509     thisEventDescription = event->GetExtendedDescription();
1510
1511 #else
1512
1513   for (const cEvent* event = Schedule->Events()->First(); event; event = Schedule->Events()->Next(event))
1514   {
1515     thisEventID = event->EventID();
1516     thisEventTime = event->StartTime();
1517     thisEventDuration = event->Duration();
1518     thisEventTitle = event->Title();
1519     thisEventSubTitle = NULL;
1520     thisEventDescription = event->Description();
1521
1522 #endif
1523
1524     //in the past filter
1525     if ((thisEventTime + thisEventDuration) < (ULONG)time(NULL)) continue;
1526
1527     //start time filter
1528     if ((thisEventTime + thisEventDuration) <= startTime) continue;
1529
1530     //duration filter
1531     if (thisEventTime >= (startTime + duration)) continue;
1532
1533     if (!thisEventTitle) thisEventTitle = empty;
1534     if (!thisEventSubTitle) thisEventSubTitle = empty;
1535     if (!thisEventDescription) thisEventDescription = empty;
1536
1537     resp->addULONG(thisEventID);
1538     resp->addULONG(thisEventTime);
1539     resp->addULONG(thisEventDuration);
1540
1541     resp->addString(x.charconvsys->Convert(thisEventTitle));
1542     resp->addString(x.charconvsys->Convert(thisEventSubTitle));
1543     resp->addString(x.charconvsys->Convert(thisEventDescription));
1544
1545     atLeastOneEvent = true;
1546   }
1547
1548   log->log("RRProc", Log::DEBUG, "Got all event data");
1549
1550   if (!atLeastOneEvent)
1551   {
1552     resp->addULONG(0);
1553     log->log("RRProc", Log::DEBUG, "Written 0 because no data");
1554   }
1555   
1556   resp->finalise();
1557   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1558     
1559   log->log("RRProc", Log::DEBUG, "written schedules packet");
1560
1561   return 1;
1562 }
1563
1564 int VompClientRRProc::processGetTimers()
1565 {
1566   cTimer *timer;
1567   int numTimers = Timers.Count();
1568
1569   resp->addULONG(numTimers);
1570
1571   for (int i = 0; i < numTimers; i++)
1572   {
1573     timer = Timers.Get(i);
1574
1575 #if VDRVERSNUM < 10300
1576     resp->addULONG(timer->Active());
1577 #else
1578     resp->addULONG(timer->HasFlags(tfActive));
1579 #endif
1580     resp->addULONG(timer->Recording());
1581     resp->addULONG(timer->Pending());
1582     resp->addULONG(timer->Priority());
1583     resp->addULONG(timer->Lifetime());
1584     resp->addULONG(timer->Channel()->Number());
1585     resp->addULONG(timer->StartTime());
1586     resp->addULONG(timer->StopTime());
1587     resp->addULONG(timer->Day());
1588     resp->addULONG(timer->WeekDays());
1589     resp->addString(timer->File()); //Filename is system specific and not visible by user
1590   }
1591
1592   resp->finalise();
1593   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1594   
1595   log->log("RRProc", Log::DEBUG, "Written timers list");
1596
1597   return 1;
1598 }
1599
1600 int VompClientRRProc::processSetTimer()
1601 {
1602   char* timerString = new char[strlen((char*)req->data) + 1];
1603   strcpy(timerString, (char*)req->data);
1604
1605 #if VDRVERSNUM < 10300
1606
1607   // If this is VDR 1.2 the date part of the timer string must be reduced
1608   // to just DD rather than YYYY-MM-DD
1609
1610   int s = 0; // source
1611   int d = 0; // destination
1612   int c = 0; // count
1613   while(c != 2) // copy up to date section, including the second ':'
1614   {
1615     timerString[d] = req->data[s];
1616     if (req->data[s] == ':') c++;
1617     ++s;
1618     ++d;
1619   }
1620   // now it has copied up to the date section
1621   c = 0;
1622   while(c != 2) // waste YYYY-MM-
1623   {
1624     if (req->data[s] == '-') c++;
1625     ++s;
1626   }
1627   // now source is at the DD
1628   memcpy(&timerString[d], &req->data[s], req->dataLength - s);
1629   d += req->dataLength - s;
1630   timerString[d] = '\0';
1631
1632   log->log("RRProc", Log::DEBUG, "Timer string after 1.2 conversion:");
1633
1634 #endif
1635   log->log("RRProc", Log::DEBUG, "%s", timerString);
1636
1637   cTimer *timer = new cTimer;
1638   if (timer->Parse((char*)timerString))
1639   {
1640     cTimer *t = Timers.GetTimer(timer);
1641     if (!t)
1642     {
1643       Timers.Add(timer);
1644 #if VDRVERSNUM < 10300
1645       Timers.Save();
1646 #else
1647       Timers.SetModified();
1648 #endif
1649       resp->addULONG(0);
1650       resp->finalise();
1651       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1652       return 1; // FIXME - cTimer* timer is leaked here!
1653     }
1654     else
1655     {
1656       resp->addULONG(1);
1657       resp->finalise();
1658       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1659     }
1660   }
1661   else
1662   {
1663     resp->addULONG(2);
1664     resp->finalise();
1665     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1666   }
1667   delete timer;
1668   return 1;
1669 }
1670
1671 int VompClientRRProc::processDeleteTimer()
1672 {
1673   log->log("RRProc", Log::DEBUG, "Delete timer called");
1674   // get timer
1675   
1676   int position = 0;
1677   
1678   INT delChannel = ntohl(*(ULONG*)&req->data[position]); position += 4;
1679   INT delWeekdays = ntohl(*(ULONG*)&req->data[position]); position += 4;
1680   INT delDay = ntohl(*(ULONG*)&req->data[position]); position += 4;  
1681   INT delStart = ntohl(*(ULONG*)&req->data[position]); position += 4;  
1682   INT delStop = ntohl(*(ULONG*)&req->data[position]); position += 4;
1683     
1684   cTimer* ti = NULL;
1685   for (ti = Timers.First(); ti; ti = Timers.Next(ti))
1686   {
1687     if  ( (ti->Channel()->Number() == delChannel)
1688      &&   ((ti->WeekDays() && (ti->WeekDays() == delWeekdays)) || (!ti->WeekDays() && (ti->Day() == delDay)))
1689      &&   (ti->StartTime() == delStart)
1690      &&   (ti->StopTime() == delStop) )
1691        break;
1692   }
1693   
1694   if (!ti)
1695   {
1696     resp->addULONG(4);
1697     resp->finalise();
1698     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1699     return 1;
1700   }
1701           
1702   if (!Timers.BeingEdited())
1703   {
1704     if (!ti->Recording())
1705     {
1706       Timers.Del(ti);
1707       Timers.SetModified();
1708       resp->addULONG(10);
1709       resp->finalise();
1710       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1711       return 1;
1712     }
1713     else
1714     {
1715       log->log("RRProc", Log::ERR, "Unable to delete timer - timer is running");
1716       resp->addULONG(3);
1717       resp->finalise();
1718       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1719       return 1;
1720     }  
1721   }
1722   else
1723   {
1724     log->log("RRProc", Log::ERR, "Unable to delete timer - timers being edited at VDR");
1725     resp->addULONG(1);
1726     resp->finalise();
1727     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1728     return 1;
1729   }  
1730 }
1731
1732 int VompClientRRProc::processGetRecInfo()
1733 {
1734   // data is a pointer to the fileName string
1735   
1736   cRecordings Recordings;
1737   Recordings.Load(); // probably have to do this
1738
1739   cRecording *recording = Recordings.GetByName((char*)req->data);
1740
1741   time_t timerStart = 0;
1742   time_t timerStop = 0;
1743   char* summary = NULL;
1744   char* shorttext = NULL;
1745   char* description = NULL;
1746   char* title = NULL;
1747   bool newsummary=false;
1748   ULONG resumePoint = 0;
1749
1750   if (!recording)
1751   {
1752     log->log("RRProc", Log::ERR, "GetRecInfo found no recording");
1753     resp->addULONG(0);
1754     resp->finalise();
1755     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1756     return 1;
1757   }
1758
1759   /* Return packet:
1760   4 bytes: start time for timer
1761   4 bytes: end time for timer
1762   4 bytes: resume point
1763   string: summary
1764   4 bytes: num components
1765   {
1766     1 byte: stream
1767     1 byte: type
1768     string: language
1769     string: description
1770   }
1771   8 bytes: frames per second
1772   */
1773
1774   // Get current timer
1775
1776   cRecordControl *rc = cRecordControls::GetRecordControl(recording->FileName());
1777   if (rc)
1778   {
1779     timerStart = rc->Timer()->StartTime();
1780     timerStop = rc->Timer()->StopTime();
1781     log->log("RRProc", Log::DEBUG, "GRI: RC: %lu %lu", timerStart, timerStop);
1782   }
1783
1784   resp->addULONG(timerStart);
1785   resp->addULONG(timerStop);
1786
1787   // Get resume point
1788
1789 /*  char* value = x.config.getValueString("ResumeData", (char*)req->data);
1790   if (value)
1791   {
1792     resumePoint = strtoul(value, NULL, 10);
1793     delete[] value;
1794   }*/
1795
1796   char* ResumeIdC = x.config.getValueString("General", "ResumeId");
1797   int ResumeId;
1798   if (ResumeIdC) {
1799     ResumeId = atoi(ResumeIdC);
1800     delete[] ResumeIdC;
1801   }
1802   else
1803     ResumeId = 0;  //default if not defined in vomp-MAC.conf
1804
1805   while (ResumeIDLock)
1806     cCondWait::SleepMs(100);
1807   ResumeIDLock = true;
1808   int OldSetupResumeID = Setup.ResumeID;
1809   Setup.ResumeID = ResumeId;                            //UGLY: quickly change resumeid
1810 #if VDRVERSNUM < 10703
1811   cResumeFile ResumeFile(recording->FileName());        //get corresponding resume file
1812 #else
1813   cResumeFile ResumeFile(recording->FileName(), recording->IsPesRecording()); //get corresponding resume file
1814 #endif
1815   Setup.ResumeID = OldSetupResumeID;                    //and restore it back
1816   ResumeIDLock = false;
1817
1818   int resume = ResumeFile.Read();
1819   //isyslog("VOMPDEBUG: resumePoint = %i, resume = %i, ResumeId = %i",resumePoint, resume, ResumeId);
1820   if (resume >= 0) 
1821     resumePoint = ResumeFile.Read();
1822
1823   log->log("RRProc", Log::DEBUG, "GRI: RP: %lu", resumePoint);
1824
1825   resp->addULONG(resumePoint);
1826
1827   // Get summary
1828
1829 #if VDRVERSNUM < 10300
1830   summary = (char*)recording->Summary();
1831 #else
1832   const cRecordingInfo *Info = recording->Info();
1833   shorttext = (char*)Info->ShortText();
1834   description = (char*) (char*)Info->Description();
1835   if (isempty(shorttext)) summary=description;
1836   else if (isempty(description)) summary=shorttext;
1837   else {
1838      int length=strlen(description)+strlen(shorttext)+4;
1839      summary=new char[length];
1840      snprintf(summary,length,"%s\n\n%s",shorttext,description);
1841      newsummary=true;
1842   }
1843   
1844   if (isempty(summary)) summary = (char*)Info->Description();
1845 #endif
1846   log->log("RRProc", Log::DEBUG, "GRI: S: %s", summary);
1847   if (summary)
1848   {
1849     resp->addString(x.charconvsys->Convert(summary));
1850     if (newsummary) delete [] summary;
1851   }
1852   else
1853   {
1854     resp->addString("");
1855   }
1856
1857   // Get channels
1858
1859 #if VDRVERSNUM < 10300
1860
1861   // Send 0 for numchannels - this signals the client this info is not available
1862   resp->addULONG(0);
1863
1864 #else
1865   const cComponents* components = Info->Components();
1866
1867   log->log("RRProc", Log::DEBUG, "GRI: D1: %p", components);
1868
1869   if (!components)
1870   {
1871     resp->addULONG(0);
1872   }
1873   else
1874   {
1875     resp->addULONG(components->NumComponents());
1876   
1877     tComponent* component;
1878     for (int i = 0; i < components->NumComponents(); i++)
1879     {
1880       component = components->Component(i);
1881
1882       log->log("RRProc", Log::DEBUG, "GRI: C: %i %u %u %s %s", i, component->stream, component->type, component->language, component->description);
1883       
1884       resp->addUCHAR(component->stream);
1885       resp->addUCHAR(component->type);
1886
1887       if (component->language)
1888       {
1889         resp->addString(x.charconvsys->Convert(component->language));
1890       }
1891       else
1892       {
1893         resp->addString("");
1894       }
1895       if (component->description)
1896       {
1897         resp->addString(x.charconvsys->Convert(component->description));
1898       }
1899       else
1900       {
1901         resp->addString("");
1902       }
1903     }
1904   }
1905
1906 #endif
1907   double framespersec;
1908 #if VDRVERSNUM < 10703
1909   framespersec = FRAMESPERSEC;
1910 #else
1911   framespersec = Info->FramesPerSecond();
1912 #endif
1913   resp->adddouble(framespersec);
1914   title = (char*)Info->Title();
1915   if (title) 
1916   {
1917     resp->addString(x.charconvsys->Convert(title));
1918   }
1919   else
1920   {
1921       resp->addString(x.charconvsys->Convert(recording->Name()));
1922   }
1923   
1924   // Done. send it
1925
1926   resp->finalise();
1927   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1928
1929   log->log("RRProc", Log::DEBUG, "Written getrecinfo");
1930
1931   return 1;
1932 }
1933
1934
1935
1936
1937 // FIXME obselete
1938
1939 int VompClientRRProc::processReScanRecording()
1940 {
1941   if (!x.recplayer)
1942   {
1943     log->log("RRProc", Log::DEBUG, "Rescan recording called when no recording being played!");
1944     return 0;
1945   }
1946
1947   x.recplayer->scan();
1948
1949   resp->addULLONG(x.recplayer->getLengthBytes());
1950   resp->addULONG(x.recplayer->getLengthFrames());
1951   resp->finalise();
1952   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1953   log->log("RRProc", Log::DEBUG, "Rescan recording, wrote new length to client");
1954   return 1;
1955 }
1956
1957 // FIXME without client calling rescan, getblock wont work even tho more data is avail
1958
1959 int VompClientRRProc::processGetMarks()
1960 {
1961   // data is a pointer to the fileName string
1962
1963   cMarks Marks;
1964   cRecordings Recordings;
1965   Recordings.Load(); // probably have to do this
1966
1967   cRecording *recording = Recordings.GetByName((char*)req->data);
1968
1969   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
1970
1971   if (recording)
1972   {
1973 #if VDRVERSNUM < 10703
1974     Marks.Load(recording->FileName());
1975 #else
1976     Marks.Load(recording->FileName(), recording->FramesPerSecond(), recording->IsPesRecording());
1977 #endif
1978     if (Marks.Count())
1979     {
1980       for (const cMark *m = Marks.First(); m; m = Marks.Next(m))
1981       {
1982 #if VDRVERSNUM < 10721
1983         ULLONG mposition = m->position;
1984 #else
1985         ULLONG mposition = m->Position();
1986 #endif
1987         log->log("RRProc", Log::DEBUG, "found Mark %i", mposition);
1988
1989         resp->addULONG(mposition);
1990       }
1991     }
1992     else
1993     {
1994       log->log("RRProc", Log::DEBUG, "no marks found, sending 0-mark");
1995       resp->addULONG(0);
1996     }
1997   }
1998
1999   resp->finalise();
2000   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2001   
2002   log->log("RRProc", Log::DEBUG, "Written Marks list");
2003
2004   return 1;
2005 }
2006
2007 int VompClientRRProc::processVDRShutdown()
2008 {
2009   log->log("RRProc", Log::DEBUG, "Trying to shutdown VDR");
2010   VompClient::decClients(); // Temporarily make this client disappear
2011   cRemote::Put(kPower);
2012   VompClient::incClients();
2013   resp->finalise();
2014   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2015   return 1;
2016 }
2017
2018 int VompClientRRProc::processGetRecScraperEventType()
2019 {
2020   Recordings.Load(); // probably have to do this
2021
2022   cRecording *recording = Recordings.GetByName((char*)req->data);
2023   ScraperGetEventType call;
2024   call.type = tNone;
2025
2026   if (recording && x.scrapQuery()) 
2027   {
2028      call.recording = recording;
2029      x.scraper->Service("GetEventType",&call);
2030   }
2031   resp->addUCHAR(call.type);
2032   if (call.type == tMovie)
2033   {
2034      resp->addLONG(call.movieId);
2035   } else if (call.type == tSeries){
2036      resp->addLONG(call.seriesId);
2037      resp->addLONG(call.episodeId);
2038   }
2039   resp->finalise();
2040   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2041
2042   return 1;
2043 }
2044
2045 int VompClientRRProc::processGetEventScraperEventType()
2046 {
2047   ScraperGetEventType call;
2048   call.type = tNone;
2049   ULONG channelid = ntohl(*(ULONG*)req->data);
2050   ULONG eventid = ntohl(*(ULONG*)(req->data+4));
2051   const cEvent *event = NULL; 
2052   
2053   cChannel* channel = x.channelFromNumber(channelid);
2054
2055 #if VDRVERSNUM < 10300
2056   cMutexLock MutexLock;
2057   const cSchedules *Schedules = cSIProcessor::Schedules(MutexLock);
2058 #else
2059   cSchedulesLock MutexLock;
2060   const cSchedules *Schedules = cSchedules::Schedules(MutexLock);
2061 #endif
2062   const cSchedule * Schedule;
2063   if (Schedules && channel)
2064   {
2065      const cSchedule *Schedule = Schedules->GetSchedule(channel->GetChannelID());
2066      if (Schedule) {
2067         event = Schedule->GetEvent(eventid);
2068     }
2069   }
2070     
2071   if (event && x.scrapQuery()) 
2072   {
2073      call.event = event;
2074      x.scraper->Service("GetEventType",&call);
2075   }
2076   resp->addUCHAR(call.type);
2077   if (call.type == tMovie)
2078   {
2079      resp->addLONG(call.movieId);
2080   } else if (call.type == tSeries){
2081      resp->addLONG(call.seriesId);
2082      resp->addLONG(call.episodeId);
2083   }
2084   if (x.pict->epgImageExists(eventid)) {
2085      resp->addLONG(1);
2086   } else {
2087      resp->addLONG(0);
2088   }
2089     
2090   resp->finalise();
2091   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2092
2093   return 1;
2094 }
2095
2096 #define ADDSTRING_TO_PAKET(y) if ((y)!=0)  resp->addString(x.charconvutf8->Convert(y)); else resp->addString(""); 
2097
2098 int VompClientRRProc::processGetScraperMovieInfo()
2099 {
2100    
2101    cMovie movie;
2102    movie.movieId = ntohl(*(ULONG*)req->data);
2103    if (!x.scrapQuery()) {
2104       log->log("RRProc", Log::DEBUG, "No Scraper, get SeriesInfo");
2105       return 0; //stupid, I have no scraper why are you still asking
2106    }
2107    x.scraper->Service("GetMovie",&movie);
2108    
2109
2110    ADDSTRING_TO_PAKET(movie.title.c_str());
2111    ADDSTRING_TO_PAKET(movie.originalTitle.c_str());
2112    ADDSTRING_TO_PAKET(movie.tagline.c_str());
2113    ADDSTRING_TO_PAKET(movie.overview.c_str());
2114    resp->addUCHAR(movie.adult);
2115    ADDSTRING_TO_PAKET(movie.collectionName.c_str());
2116
2117    resp->addLONG(movie.budget);
2118    resp->addLONG(movie.revenue);
2119    ADDSTRING_TO_PAKET(movie.genres.c_str());
2120    ADDSTRING_TO_PAKET(movie.homepage.c_str());
2121    ADDSTRING_TO_PAKET(movie.releaseDate.c_str());
2122    resp->addLONG(movie.runtime);
2123    resp->adddouble(movie.popularity);
2124    resp->adddouble(movie.voteAverage);
2125    resp->addULONG(movie.poster.width);
2126    resp->addULONG(movie.poster.height);
2127    resp->addULONG(movie.fanart.width);
2128    resp->addULONG(movie.fanart.height);
2129    resp->addULONG(movie.collectionPoster.width);
2130    resp->addULONG(movie.collectionPoster.height);
2131    resp->addULONG(movie.collectionFanart.width);
2132    resp->addULONG(movie.collectionFanart.height);
2133    resp->addULONG(movie.actors.size());
2134    for (ULONG acty=0; acty < movie.actors.size(); acty++) {
2135        ADDSTRING_TO_PAKET(movie.actors[acty].name.c_str());
2136        ADDSTRING_TO_PAKET(movie.actors[acty].role.c_str());
2137        resp->addULONG(movie.actors[acty].actorThumb.width);
2138        resp->addULONG(movie.actors[acty].actorThumb.height);
2139    }
2140   resp->finalise();
2141   
2142   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2143
2144   
2145   return 1;
2146
2147 }
2148
2149 int VompClientRRProc::processGetScraperSeriesInfo()
2150 {
2151    cSeries series;
2152    series.seriesId = ntohl(*(ULONG*)req->data);
2153    series.episodeId = ntohl(*(ULONG*)(req->data+4));
2154    if (!x.scrapQuery()) {
2155       log->log("RRProc", Log::DEBUG, "No Scraper, get SeriesInfo");
2156       return 0; //stupid, I have no scraper why are you still asking
2157    }
2158    x.scraper->Service("GetSeries",&series);
2159    
2160    ADDSTRING_TO_PAKET(series.name.c_str());
2161    ADDSTRING_TO_PAKET(series.overview.c_str());
2162    ADDSTRING_TO_PAKET(series.firstAired.c_str());
2163    ADDSTRING_TO_PAKET(series.network.c_str());
2164    ADDSTRING_TO_PAKET(series.genre.c_str());
2165    resp->adddouble(series.rating);
2166    ADDSTRING_TO_PAKET(series.status.c_str());
2167    
2168    resp->addLONG(series.episode.number);
2169    resp->addLONG(series.episode.season);
2170    ADDSTRING_TO_PAKET(series.episode.name.c_str());
2171    ADDSTRING_TO_PAKET(series.episode.firstAired.c_str());
2172    ADDSTRING_TO_PAKET(series.episode.guestStars.c_str());
2173    ADDSTRING_TO_PAKET(series.episode.overview.c_str());
2174    resp->adddouble(series.episode.rating);
2175    resp->addULONG(series.episode.episodeImage.width);
2176    resp->addULONG(series.episode.episodeImage.height);
2177    
2178    ULONG num_actors = series.actors.size();
2179    resp->addULONG(num_actors);
2180    for (ULONG acty=0; acty < num_actors; acty++) {
2181        ADDSTRING_TO_PAKET(series.actors[acty].name.c_str());
2182        ADDSTRING_TO_PAKET(series.actors[acty].role.c_str());
2183        resp->addULONG(series.actors[acty].actorThumb.width);
2184        resp->addULONG(series.actors[acty].actorThumb.height);
2185    }
2186    ULONG num_posters = series.posters.size();
2187    resp->addULONG(num_posters);
2188    for (ULONG medias = 0; medias < num_posters; medias++ ) {
2189        cTvMedia media=series.posters[medias];
2190        resp->addULONG(media.width);
2191        resp->addULONG(media.height);
2192    }
2193
2194    ULONG num_banners = series.banners.size();
2195    resp->addULONG(num_banners);
2196    for (ULONG medias = 0; medias < num_banners; medias++ ) {
2197        cTvMedia media=series.banners[medias];
2198        resp->addULONG(media.width);
2199        resp->addULONG(media.height);
2200    }
2201    ULONG num_fanarts = series.fanarts.size();
2202    resp->addULONG(num_fanarts);
2203    for (ULONG medias = 0; medias < num_fanarts; medias++ ) {
2204        cTvMedia media=series.fanarts[medias];
2205        resp->addULONG(media.width);
2206        resp->addULONG(media.height);
2207    }
2208    resp->addULONG(series.seasonPoster.width);
2209    resp->addULONG(series.seasonPoster.height);
2210    
2211    resp->finalise();
2212
2213    x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2214    
2215    return 1;
2216 }
2217
2218 int VompClientRRProc::processLoadTvMedia()
2219 {
2220    TVMediaRequest tvreq;
2221    tvreq.streamID = req->requestID;
2222    tvreq.type = ntohl(*(ULONG*)req->data);
2223    tvreq.primary_id = ntohl(*(ULONG*)(req->data+4));
2224    tvreq.secondary_id = ntohl(*(ULONG*)(req->data+8));
2225    tvreq.type_pict = ntohl(*(ULONG*)(req->data+12));
2226    tvreq.container = ntohl(*(ULONG*)(req->data+16));
2227    tvreq.container_member = ntohl(*(ULONG*)(req->data+20));
2228    log->log("RRProc", Log::DEBUG, "TVMedia request %d",req->requestID);
2229    x.pict->addTVMediaRequest(tvreq);
2230
2231    
2232    resp->finalise();
2233
2234    x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2235    
2236    return 1;
2237 }
2238
2239 int VompClientRRProc::processLoadTvMediaRecThumb()
2240 {
2241    TVMediaRequest tvreq;
2242    tvreq.streamID = req->requestID;
2243    tvreq.type = 3; // unknown but primary_name is set
2244    tvreq.primary_id = 0;
2245    tvreq.primary_name = std::string((const char*) req->data);
2246    tvreq.secondary_id = 0;
2247    tvreq.type_pict = 1;
2248    tvreq.container = 0;
2249    tvreq.container_member = 0;
2250    log->log("RRProc", Log::DEBUG, "TVMedia request %d %s",req->requestID,req->data);
2251    x.pict->addTVMediaRequest(tvreq);
2252
2253    
2254    resp->finalise();
2255
2256    x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2257    
2258    return 1;
2259 }
2260
2261 int VompClientRRProc::processLoadTvMediaEventThumb()
2262 {
2263    TVMediaRequest tvreq;
2264    tvreq.streamID = req->requestID;
2265    tvreq.type = 4; // unknown but primary_id is set
2266    UINT channelid = ntohl(*(ULONG*)req->data);
2267    tvreq.primary_id = ntohl(*(ULONG*)(req->data+4));
2268    tvreq.secondary_id = 0;
2269    cChannel* channel = x.channelFromNumber(channelid);
2270
2271    if (channel) tvreq.primary_name = std::string((const char*)channel->GetChannelID().ToString());
2272    tvreq.type_pict = 1;
2273    tvreq.container = 0;
2274    tvreq.container_member = 0;
2275    log->log("RRProc", Log::DEBUG, "TVMedia request %d %s",req->requestID,req->data);
2276    x.pict->addTVMediaRequest(tvreq);
2277
2278    
2279    resp->finalise();
2280
2281    x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2282    
2283    return 1;
2284 }
2285
2286 int VompClientRRProc::processLoadChannelLogo()
2287 {
2288    TVMediaRequest tvreq;
2289    tvreq.streamID = req->requestID;
2290    tvreq.type = 5; // channel logo
2291    UINT channelid = ntohl(*(ULONG*)req->data);
2292    tvreq.primary_id = channelid;
2293    tvreq.secondary_id = 0;
2294    cChannel* channel = x.channelFromNumber(channelid);
2295
2296    if (channel) tvreq.primary_name = std::string((const char*)channel->Name());
2297    tvreq.type_pict = 1;
2298    tvreq.container = 0;
2299    tvreq.container_member = 0;
2300    log->log("RRProc", Log::DEBUG, "TVMedia request %d %d %s",req->requestID,channelid, channel->Name());
2301    x.pict->addTVMediaRequest(tvreq);
2302
2303    
2304    resp->finalise();
2305
2306    x.tcp.sendPacket(resp->getPtr(), resp->getLen());
2307    
2308    return 1;
2309 }
2310
2311  
2312
2313
2314   
2315 #endif // !VOMPSTANDALONE
2316