]> git.vomp.tv Git - vompserver.git/blob - media.c
Update Makefile as suggested in VDR 2.1.3 changes
[vompserver.git] / media.c
1 /*
2     Copyright 2004-2005 Chris Tallon, Andreas Vogel
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 */
20
21 #include "media.h"
22 #include <time.h>
23 #include <arpa/inet.h>
24 #ifndef SNPRINTF
25 #define SNPRINTF snprintf
26 #endif
27
28
29 MediaURI::MediaURI(const MediaURI *cp) {
30   if ( ! cp) {
31     _providerId=0;
32     _name=NULL;
33     _display=NULL;
34     _allowedTypes=MEDIA_TYPE_ALL;
35   }
36   else {
37     _providerId=cp->_providerId;
38     _allowedTypes=cp->_allowedTypes;
39     _name=NULL;
40     if (cp->_name) {
41       _name=new char[strlen(cp->_name)+1];
42       strcpy(_name,cp->_name);
43     }
44     _display=NULL;
45     if (cp->_display) {
46       _display=new char[strlen(cp->_display)+1];
47       strcpy(_display,cp->_display);
48     }
49   }
50
51 MediaURI::MediaURI(ULONG p, const char * n, const char * dp) {
52   _allowedTypes=MEDIA_TYPE_ALL;
53   _providerId=p;
54   if (n) {
55     _name=new char[strlen(n)+1];
56     strcpy(_name,n);
57   } else {
58     _name=NULL;
59   }
60   _display=NULL;
61   if (dp) {
62     _display=new char[strlen(dp)+1];
63     strcpy(_display,dp);
64   }
65 }
66
67
68 int MediaURI::getSerializedLenImpl() {
69   int rt=4+4; //provider+allowedType
70   rt+=getSerializedStringLen(_name);
71   rt+=getSerializedStringLen(_display);
72   return rt;
73 }
74 /**
75   * 4 provider
76   * 4 allowedType
77   * 4 namelen (incl. 0)
78   * name+0
79   * 4 displaylen (incl. 0)
80   * display+0
81   */
82 int MediaURI::serializeImpl(SerializeBuffer *b) {
83   version=1;
84   if (b->encodeLong(_providerId) != 0) return -1; 
85   if (b->encodeLong(_allowedTypes) != 0) return -1; 
86   if (b->encodeString(_name) != 0) return -1; 
87   if (b->encodeString(_display) != 0) return -1; 
88   return 0;
89 }
90
91 int MediaURI::deserializeImpl(SerializeBuffer *b) {
92   if (_name) delete _name;
93   _name=NULL;
94   if (_display) delete _display;
95   _display=NULL;
96   if (b->decodeLong(_providerId) != 0) return -1;
97   if (b->decodeLong(_allowedTypes) != 0) return -1;
98   ULONG nlen=0;
99   if (b->decodeString(nlen,_name) != 0) return -1;
100   if (b->decodeString(nlen,_display) != 0) return -1;
101   //if (version > 1) ...
102   return 0;
103 }
104
105
106
107
108 int MediaInfo::getSerializedLenImpl() {
109   int rt=8+1+4+4; //8len+1canPos+4type+4subtype
110   return rt;
111 }
112
113
114 /**
115   * serialize to buffer
116   * 8 len
117   * 1 canPos
118   * 4 type
119   * 4 subtype
120   */
121 int MediaInfo::serializeImpl(SerializeBuffer *b) {
122   if (b->encodeLongLong(size) != 0) return -1;
123   if (b->encodeByte(canPosition?1:0) != 0) return -1;
124   if (b->encodeLong(type) != 0) return -1; 
125   if (b->encodeLong(subtype) != 0) return -1;
126   return 0;
127 }
128 /**
129   * deserialize
130   * should be compatible to older serialize functions
131   */
132 int MediaInfo::deserializeImpl(SerializeBuffer *b) {
133   if (b->decodeLongLong(size) != 0) return -1;
134   UCHAR cp=0;
135   if (b->decodeByte(cp) != 0) return -1;
136   canPosition=cp!=0;
137   if (b->decodeLong(type) != 0) return -1;
138   if (b->decodeLong(subtype) != 0) return -1;
139   return 0;
140 }
141
142
143
144 Media::Media()
145 {
146   mtime = 0;
147   displayName = NULL;
148   fileName = NULL;
149   mediaType=MEDIA_TYPE_UNKNOWN;
150   uri=NULL;
151   index=0;
152 }
153
154 Media::Media(const Media *m) {
155   Media();
156   if (! m) return;
157   mtime=m->mtime;
158   mediaType=m->mediaType;
159   uri=NULL;
160   fileName=NULL;
161   displayName=NULL;
162   if (m->uri) uri=new MediaURI(m->uri);
163   setFileName(m->fileName);
164   setDisplayName(m->displayName);
165   index=m->index;
166 }
167
168 Media::~Media()
169 {
170   if (displayName) { delete[] displayName; displayName = NULL; }
171   if (fileName) { delete[] fileName; fileName = NULL; }
172   if (uri) delete uri;
173   index = -1; // just in case
174 }
175
176 ULONG Media::getTime() const
177 {
178   return mtime;
179 }
180
181 const char* Media::getDisplayName() const
182 {
183   if (displayName) return displayName;
184   return fileName;
185 }
186
187 const char* Media::getFileName() const
188 {
189   return fileName;
190 }
191
192 void Media::setTime(ULONG tstartTime)
193 {
194   mtime = tstartTime;
195 }
196
197 void Media::setMediaType(ULONG mtype)
198 {
199   mediaType=mtype;
200 }
201
202 ULONG Media::getMediaType() const
203 {
204   return mediaType;
205 }
206
207 void Media::setDisplayName(const char* tDisplayName)
208 {
209   if (displayName) delete[] displayName;
210   displayName=NULL;
211   if (! tDisplayName) return;
212   displayName = new char[strlen(tDisplayName) + 1];
213   if (displayName) strcpy(displayName, tDisplayName);
214 }
215
216 void Media::setFileName(const char* tFileName)
217 {
218   if (fileName) delete[] fileName;
219   fileName=NULL;
220   if (! tFileName) return;
221   fileName = new char[strlen(tFileName) + 1];
222   if (fileName) strcpy(fileName, tFileName);
223 }
224
225 bool Media::hasDisplayName() const {
226   return (displayName != NULL);
227 }
228
229 char * Media::getTimeString(char * buffer) const {
230   if (! buffer) buffer=new char[TIMEBUFLEN];
231   struct tm ltime;
232   time_t tTime = (time_t)getTime();
233   struct tm *btime = localtime(&tTime);
234   memcpy(&ltime,btime, sizeof(struct tm));
235   btime=&ltime;
236   if (btime && tTime != 0) {
237 #ifndef _MSC_VER
238   strftime(buffer,TIMEBUFLEN, "%0g/%0m/%0d %0H:%0M ", btime);
239 #else
240   strftime(buffer, TIMEBUFLEN, "%g/%m/%d %H:%M ", btime);
241 #endif
242   }
243   else {
244     SNPRINTF(buffer,TIMEBUFLEN,"00/00/00 00:00 ");
245     }
246   return buffer;
247 }
248
249 const MediaURI * Media::getURI() const {
250   return uri;
251 }
252
253 void Media::setURI(const MediaURI *u) {
254   if (uri) delete uri;
255   uri=new MediaURI(u);
256 }
257
258 int Media::getSerializedLenImpl() {
259   int rt=4+4+1; //type,time,hasURI
260   rt+=getSerializedStringLen(fileName);
261   rt+=getSerializedStringLen(displayName);
262   if (uri) rt+=uri->getSerializedLen();
263   return rt;
264 }
265 /**
266   * 4 type
267   * 4 time
268   * 4 namelen (incl. 0)
269   * name+0
270   * 4 displaylen (incl. 0)
271   * display+0
272   * 1 hasURI
273   * URI
274   */
275 int Media::serializeImpl(SerializeBuffer *b) {
276   if (b->encodeLong(mediaType) != 0) return -1; 
277   if (b->encodeLong(mtime) != 0) return -1; 
278   if (b->encodeString(fileName) != 0) return -1; 
279   if (b->encodeString(displayName) != 0) return -1; 
280
281   if (b->encodeByte(uri?1:0) != 0) return -1; 
282   if (uri) {
283     if (uri->serialize(b) != 0) return -1;
284   }
285   return 0;
286 }
287
288 int Media::deserializeImpl(SerializeBuffer *b) {
289   if (fileName) delete fileName;
290   fileName=NULL;
291   if (displayName) delete displayName;
292   displayName=NULL;
293   if (uri) delete uri;
294   uri=NULL;
295   if (b->decodeLong(mediaType) != 0) return -1;
296   if (b->decodeLong(mtime) != 0) return -1;
297   ULONG nlen=0;
298   if (b->decodeString(nlen,fileName) != 0) return -1;
299   if (b->decodeString(nlen,displayName) != 0) return -1;
300   UCHAR hasURI=0;
301   if (b->decodeByte(hasURI) != 0) return -1;
302   if (hasURI!=0) {
303     uri=new MediaURI();
304     if (uri->deserialize(b) != 0) return -1;
305   }
306   return 0;
307 }
308
309
310
311 MediaURI * MediaList::getURI(Media * m) {
312   if (! m) return NULL;
313   const MediaURI *rtc=m->getURI();
314   if (rtc) return new MediaURI(rtc);
315   if (!_root) return NULL;
316   if (! m->getFileName()) return NULL;
317   int len=strlen(m->getFileName());
318   if (_root->getName()) len+=strlen(_root->getName())+1;
319   MediaURI *rt=new MediaURI();
320   rt->_name=new char[len+1];
321   const char *fn=m->getFileName();
322   if (_root->getName()) {
323     while (*fn=='/') fn++;
324     sprintf(rt->_name,"%s/%s",_root->getName(),fn);
325   }
326   else {
327     sprintf(rt->_name,"%s",fn);
328   }
329   if (m->hasDisplayName() || _root->hasDisplayName()) {
330     len=strlen(m->getDisplayName())+1;
331     if (_root->hasDisplayName()) {
332       len+=strlen(_root->getDisplayName())+2;
333     }
334     rt->_display=new char[len];
335     if (_root->hasDisplayName()) {
336       const char *sp=m->getDisplayName();
337       if (*sp=='/')sp++;
338       sprintf(rt->_display,"%s/%s",_root->getDisplayName(),sp);
339     }
340     else {
341       sprintf(rt->_display,"%s",m->getDisplayName());
342     }
343   }
344   rt->_providerId=_root->_providerId;
345   rt->_allowedTypes=_root->_allowedTypes;
346   return rt;
347 }
348
349 MediaURI * MediaList::getParent(MediaURI *c) {
350   MediaURI * rt=new MediaURI();
351   rt->_providerId=c->_providerId;
352   rt->_allowedTypes=c->_allowedTypes;
353   ULONG nlen=0;
354   if (c->_name) {
355     char * ls=strrchr(c->_name,'/');
356     if (ls) {
357       nlen=ls-c->_name;
358       rt->_name=new char[nlen+1];
359       strncpy(rt->_name,c->_name,nlen);
360       rt->_name[nlen]=0;
361     }
362   }
363   if (c->_display) {
364     char * ls=strrchr(c->_display,'/');
365     if (ls) {
366       nlen=ls-c->_display;
367       rt->_display=new char[nlen+1];
368       strncpy(rt->_display,c->_display,nlen);
369       rt->_display[nlen]=0;
370     }
371   }
372   return rt;
373 }
374
375
376 MediaList::MediaList(const MediaURI *root) {
377   _root=new MediaURI(root);
378   _owning=true;
379 }
380
381
382 MediaList::~MediaList() {
383   emptyList();
384 }
385 void MediaList::emptyList(){
386   if (_owning) {
387     for (UINT i = 0; i < size(); i++)
388       {
389         delete (*this)[i];
390       }
391   }
392   clear();
393   if (_root) delete _root;
394   _root=NULL;
395   _owning=true;
396 }
397
398
399 MediaURI * MediaList::getRootURI() {
400   if ( ! _root) return NULL;
401   return new MediaURI(_root);
402 }
403
404 ULONG MediaList::getProvider() {
405   if (! _root) return 0;
406   return _root->getProvider();
407 }
408
409 void MediaList::setOwning(bool owning) {
410   _owning=owning;
411 }
412
413
414   
415 int MediaList::getSerializedLenImpl() {
416   int rt=4+1; //numelem+hasRoot
417   if (_root) rt+=_root->getSerializedLen();
418   for (MediaList::iterator it=begin();it<end();it++) {
419     rt+=(*it)->getSerializedLen();
420   }
421   return rt;
422 }
423
424 /**
425   * 4 numelem
426   * 1 hasRoot
427   * URI root
428   * nx Media elements
429   * 
430   */
431 int MediaList::serializeImpl(SerializeBuffer *b) {
432   if (b->encodeLong(size()) != 0) return -1; 
433   if (b->encodeByte(_root?1:0) != 0) return -1; 
434   if (_root) {
435     if (_root->serialize(b) != 0) return -1;
436   }
437   for (MediaList::iterator it=begin();it<end();it++) {
438     if ((*it)->serialize(b) !=0) return -1;
439   }
440   return 0;
441 }
442
443 int MediaList::deserializeImpl(SerializeBuffer *b) {
444   emptyList();
445   ULONG numelem;
446   if (b->decodeLong(numelem) != 0) return -1;
447   UCHAR hasRoot=0;
448   if (b->decodeByte(hasRoot) != 0) return -1;
449   if (hasRoot!=0) {
450     _root=new MediaURI();
451     if (_root->deserialize(b) != 0) return -1;
452   }
453   for (ULONG i=0;i<numelem;i++) {
454     Media *m=new Media();
455     if (m->deserialize(b) != 0) {
456       delete m;
457       return -1;
458     }
459     push_back(m);
460   }
461   return 0;
462 }
463
464
465