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