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   time_t tTime = (time_t)getTime();
 234   struct tm btime;
 235   LOCALTIME_R(&tTime, &btime);
 236
 237   if (tTime != 0) {
 238 #ifndef _MSC_VER
 239   strftime(buffer,TIMEBUFLEN, "%0g/%0m/%0d %0H:%0M ", &btime);
 240 #else
 241   strftime(buffer,TIMEBUFLEN, "%Y/%m/%d %H:%M ", &btime);
 242
 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
 468