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