]> git.vomp.tv Git - vompclient-marten.git/blob - media.cc
Windows updates
[vompclient-marten.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, "%0G/%0m/%0d %0H:%0M ", btime);
243 #endif
244   }
245   else {
246     SNPRINTF(buffer,TIMEBUFLEN,"00/00/00 00:00 ");
247     }
248   return buffer;
249 }
250
251 const MediaURI * Media::getURI() const {
252   return uri;
253 }
254
255 void Media::setURI(const MediaURI *u) {
256   if (uri) delete uri;
257   uri=new MediaURI(u);
258 }
259
260 int Media::getSerializedLenImpl() {
261   int rt=4+4+1; //type,time,hasURI
262   rt+=getSerializedStringLen(fileName);
263   rt+=getSerializedStringLen(displayName);
264   if (uri) rt+=uri->getSerializedLen();
265   return rt;
266 }
267 /**
268   * 4 type
269   * 4 time
270   * 4 namelen (incl. 0)
271   * name+0
272   * 4 displaylen (incl. 0)
273   * display+0
274   * 1 hasURI
275   * URI
276   */
277 int Media::serializeImpl(SerializeBuffer *b) {
278   if (b->encodeLong(mediaType) != 0) return -1; 
279   if (b->encodeLong(mtime) != 0) return -1; 
280   if (b->encodeString(fileName) != 0) return -1; 
281   if (b->encodeString(displayName) != 0) return -1; 
282
283   if (b->encodeByte(uri?1:0) != 0) return -1; 
284   if (uri) {
285     if (uri->serialize(b) != 0) return -1;
286   }
287   return 0;
288 }
289
290 int Media::deserializeImpl(SerializeBuffer *b) {
291   if (fileName) delete fileName;
292   fileName=NULL;
293   if (displayName) delete displayName;
294   displayName=NULL;
295   if (uri) delete uri;
296   uri=NULL;
297   if (b->decodeLong(mediaType) != 0) return -1;
298   if (b->decodeLong(mtime) != 0) return -1;
299   ULONG nlen=0;
300   if (b->decodeString(nlen,fileName) != 0) return -1;
301   if (b->decodeString(nlen,displayName) != 0) return -1;
302   UCHAR hasURI=0;
303   if (b->decodeByte(hasURI) != 0) return -1;
304   if (hasURI!=0) {
305     uri=new MediaURI();
306     if (uri->deserialize(b) != 0) return -1;
307   }
308   return 0;
309 }
310
311
312
313 MediaURI * MediaList::getURI(Media * m) {
314   if (! m) return NULL;
315   const MediaURI *rtc=m->getURI();
316   if (rtc) return new MediaURI(rtc);
317   if (!_root) return NULL;
318   if (! m->getFileName()) return NULL;
319   int len=strlen(m->getFileName());
320   if (_root->getName()) len+=strlen(_root->getName())+1;
321   MediaURI *rt=new MediaURI();
322   rt->_name=new char[len+1];
323   const char *fn=m->getFileName();
324   if (_root->getName()) {
325     while (*fn=='/') fn++;
326     sprintf(rt->_name,"%s/%s",_root->getName(),fn);
327   }
328   else {
329     sprintf(rt->_name,"%s",fn);
330   }
331   if (m->hasDisplayName() || _root->hasDisplayName()) {
332     len=strlen(m->getDisplayName())+1;
333     if (_root->hasDisplayName()) {
334       len+=strlen(_root->getDisplayName())+2;
335     }
336     rt->_display=new char[len];
337     if (_root->hasDisplayName()) {
338       const char *sp=m->getDisplayName();
339       if (*sp=='/')sp++;
340       sprintf(rt->_display,"%s/%s",_root->getDisplayName(),sp);
341     }
342     else {
343       sprintf(rt->_display,"%s",m->getDisplayName());
344     }
345   }
346   rt->_providerId=_root->_providerId;
347   rt->_allowedTypes=_root->_allowedTypes;
348   return rt;
349 }
350
351 MediaURI * MediaList::getParent(MediaURI *c) {
352   MediaURI * rt=new MediaURI();
353   rt->_providerId=c->_providerId;
354   rt->_allowedTypes=c->_allowedTypes;
355   ULONG nlen=0;
356   if (c->_name) {
357     char * ls=strrchr(c->_name,'/');
358     if (ls) {
359       nlen=ls-c->_name;
360       rt->_name=new char[nlen+1];
361       strncpy(rt->_name,c->_name,nlen);
362       rt->_name[nlen]=0;
363     }
364   }
365   if (c->_display) {
366     char * ls=strrchr(c->_display,'/');
367     if (ls) {
368       nlen=ls-c->_display;
369       rt->_display=new char[nlen+1];
370       strncpy(rt->_display,c->_display,nlen);
371       rt->_display[nlen]=0;
372     }
373   }
374   return rt;
375 }
376
377
378 MediaList::MediaList(const MediaURI *root) {
379   _root=new MediaURI(root);
380   _owning=true;
381 }
382
383
384 MediaList::~MediaList() {
385   emptyList();
386 }
387 void MediaList::emptyList(){
388   if (_owning) {
389     for (UINT i = 0; i < size(); i++)
390       {
391         delete (*this)[i];
392       }
393   }
394   clear();
395   if (_root) delete _root;
396   _root=NULL;
397   _owning=true;
398 }
399
400
401 MediaURI * MediaList::getRootURI() {
402   if ( ! _root) return NULL;
403   return new MediaURI(_root);
404 }
405
406 ULONG MediaList::getProvider() {
407   if (! _root) return 0;
408   return _root->getProvider();
409 }
410
411 void MediaList::setOwning(bool owning) {
412   _owning=owning;
413 }
414
415
416   
417 int MediaList::getSerializedLenImpl() {
418   int rt=4+1; //numelem+hasRoot
419   if (_root) rt+=_root->getSerializedLen();
420   for (MediaList::iterator it=begin();it<end();it++) {
421     rt+=(*it)->getSerializedLen();
422   }
423   return rt;
424 }
425
426 /**
427   * 4 numelem
428   * 1 hasRoot
429   * URI root
430   * nx Media elements
431   * 
432   */
433 int MediaList::serializeImpl(SerializeBuffer *b) {
434   if (b->encodeLong(size()) != 0) return -1; 
435   if (b->encodeByte(_root?1:0) != 0) return -1; 
436   if (_root) {
437     if (_root->serialize(b) != 0) return -1;
438   }
439   for (MediaList::iterator it=begin();it<end();it++) {
440     if ((*it)->serialize(b) !=0) return -1;
441   }
442   return 0;
443 }
444
445 int MediaList::deserializeImpl(SerializeBuffer *b) {
446   emptyList();
447   ULONG numelem;
448   if (b->decodeLong(numelem) != 0) return -1;
449   UCHAR hasRoot=0;
450   if (b->decodeByte(hasRoot) != 0) return -1;
451   if (hasRoot!=0) {
452     _root=new MediaURI();
453     if (_root->deserialize(b) != 0) return -1;
454   }
455   for (ULONG i=0;i<numelem;i++) {
456     Media *m=new Media();
457     if (m->deserialize(b) != 0) {
458       delete m;
459       return -1;
460     }
461     push_back(m);
462   }
463   return 0;
464 }
465
466
467