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