Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MP7Time.cpp

 /***********************************************************************
 *                                                                      *
 * MuViNo - ViTooKi Video Annotation Tool                               *
 *                                                                      *
 * title: MP7Time.cpp                                                   *
 *                                                                      *
 * $Id: MP7Time.cpp,v 1.5 2005/08/04 13:04:42 klschoef Exp $
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

#include <stdlib.h>
#include <string.h>
#ifndef WINCE
#include <errno.h>
#endif

#include <debug.hpp>
#include "MP7Time.hpp"

#ifdef WINCE
int errno = 0;
#endif

#define SECS_PER_DAY               (24 * 3600)
#define MP7TIME_TPOINT_BUFSIZE     (MP7TIME_DATE_LEN + MP7TIME_TZ_LEN + 30)
#define MP7TIME_DURATION_BUFSIZE   (MP7TIME_TZ_LEN + 50)

MP7Time::MP7Time()
{
  reset();
}

void MP7Time::resetTimePoint()
{
  tpoint.date[0] = '\0';
  tpoint.hasTime = false;
  tpoint.sec = 0;
  tpoint.num = 0;
  tpoint.denom = 1;
  tpoint.tz[0] = '\0';
}

void MP7Time::resetDuration()
{
  duration.sign = 1;
  duration.days = 0;
  duration.sec = 0;
  duration.num = 0;
  duration.denom = 1;
  duration.tz[0] = '\0';
  duration.units = 0;
}

void MP7Time::reset()
{
  resetTimePoint();
  resetDuration();
}

bool MP7Time::setTimePoint(uint value, uint ticksPerSecond)
{
  resetTimePoint();
  if (ticksPerSecond == 0) {
    dprintf_err("MP7Time::setTimePoint(value = %u, ticksPerSecond = %u) invalid ticksPerSecond value!\n",
                value, ticksPerSecond);
    return false;
  }
  tpoint.sec = value / ticksPerSecond;
  tpoint.num = value % ticksPerSecond;
  tpoint.denom = ticksPerSecond;
  tpoint.hasTime = true;
  return true;
}

bool MP7Time::setTimePoint(const char *mp7Value)
{
  resetTimePoint();
  uint val;
  char *pos = strchr(mp7Value, 'T');
  /* date part */
  if (!pos)
    pos = strchr(mp7Value, '\0');
  if (pos > mp7Value) {
    int len = pos - mp7Value;
    if (len > MP7TIME_DATE_LEN)
      return false;
    memcpy(tpoint.date, mp7Value, len);
    tpoint.date[len] = '\0';
  }
  if (*pos == '\0')
    return true;
  pos++;                        // advance to character after 'T'
  /* time zone */
  char *postz = strchr(pos, '+');
  if (!postz)
    postz = strchr(pos, '-');
  if (postz) {
    if (strlen(postz) > MP7TIME_TZ_LEN) {
      resetTimePoint();
      return false;
    }
    strcpy(tpoint.tz, postz);
  } else
    postz = strchr(pos, '\0');
  if (pos == postz)
    return true;
  /* parse time part */
  int unit = 3600;              // time unit (in seconds) of next field
  char *num = pos;
  for (; pos <= postz; pos++) {
    if (*pos == ':' || *pos == 'F' || *pos == '+'
        || *pos == '-' || *pos == '\0') {
      char *tail;
      errno = 0;
      val = (uint) strtoul(num, &tail, 10);
      if (errno || tail != pos) {
        dprintf_err("MP7Time::setTimePoint(mp7value = %s) integer conversion FAILED!\n",
                    mp7Value);
        resetTimePoint();
        return false;
      }
      num = pos + 1;
      switch (*pos) {
      case ':':                 // fall through
      case '+':                 // fall through
      case '-':                 // fall through
      case '\0':
        if (unit) {
          tpoint.sec += val * unit;
          unit /= 60;
        } else {
          if (!val) {
            dprintf_err("MP7Time::setTimePoint(mp7value = %s) 0 denominator!\n",
                        mp7Value);
            resetTimePoint();
            return false;
          }
          tpoint.denom = val;
        }
        break;
      case 'F':
        tpoint.num = val;
        unit = 0;
        break;
      } // switch
    } // if
  }
  tpoint.hasTime = true;
  return true;
}

bool MP7Time::setTimePoint(const MP7Time &otherTime)
{
  tpoint = otherTime.tpoint;
  return true;
}

bool MP7Time::moveTimePoint(int value, uint ticksPerSecond)
{
  bool rval = true;
  uint denom = commonMultiple(tpoint.denom, ticksPerSecond);
  tpoint.num *= denom / tpoint.denom;
  value *= (int) (denom / ticksPerSecond);
  tpoint.denom = denom;
  if (value < 0) {
    int sec = (int) tpoint.sec;
    value = -value;
    tpoint.num += denom;
    tpoint.num -= value % denom;
    if (tpoint.num >= denom)
      tpoint.num -= denom;
    else
      sec--;
    sec -= value / denom;
    if (sec < 0) {
      rval = false;
      resetTimePoint();
    } else
      tpoint.sec = (uint) sec;
  } else {
    tpoint.num += value % denom;
    if (tpoint.num >= denom) {
      tpoint.sec++;
      tpoint.num -= denom;
    }
    tpoint.sec += value / denom;
  }
  tpoint.hasTime = true;
  return rval;
}

bool MP7Time::setDuration(uint value, uint ticks)
{
  resetDuration();
  if (ticks == 0) {
    dprintf_err("MP7Time::setDuration(value = %u, ticks = %u) invalid ticks value!\n",
                value, ticks);
    return false;
  }
  duration.sec = value / ticks;
  duration.num = value % ticks;
  duration.denom = ticks;
  return true;
}

bool MP7Time::setDuration(const char *mp7Value)
{
  resetDuration();
  const char *pos = mp7Value;
  /* duration sign */
  if (*pos == '-') {
    duration.sign = -1;
    pos++;
  }
  if (*pos != 'P') {
    dprintf_err("MP7Time::setDuration(mp7Value = %s) invalid MPEG-7 duration!\n",
                mp7Value);
    resetDuration();
    return false;
  }
  pos++;
  /* parse duration and time zone */
  const char *start = pos;
  uint val;
  for (; *pos; pos++) {
    /* duration */
    if (*pos == 'T') {
      start = pos + 1;
    } else if (*pos == 'D' || *pos == 'H' || *pos == 'M' || *pos == 'S'
        || *pos == 'N' || *pos == 'F') {
      char *tail;
      errno = 0;
      val = (uint) strtoul(start, &tail, 10);
      if (errno || tail != pos) {
        dprintf_err("MP7Time::setDuration(mp7Value = %s) integer conversion FAILED!\n",
                    mp7Value);
        resetDuration();
        return false;
      }
      start = pos + 1;
      switch (*pos) {
      case 'D':
        duration.days = val;
        break;
      case 'H':
        duration.sec += val * 3600;
        break;
      case 'M':
        duration.sec += val * 60;
        break;
      case 'S':
        duration.sec += val;
        break;
      case 'N':
        duration.num = val;
        break;
      case 'F':
        if (val > 0)
          duration.denom = val;
        else {
          dprintf_err("MP7Time::setDuration(mp7Value = %s) invalid fraction!\n",
                      mp7Value);
          resetDuration();
          return false;
        }
      } //switch
    } else if (*pos == 'Z') {   // time zone difference
      int len = pos - start;    // don't copy the 'Z' character
      if (len > MP7TIME_TZ_LEN) {
        dprintf_err("MP7Time::setDuration(mp7Value = %s) time zone string too long!\n",
                    mp7Value);
        resetDuration();
        return false;
      }
      memcpy(duration.tz, start, len);
      duration.tz[len] = '\0';
    }
  } // for
  return true;
}

bool MP7Time::setDuration(const MP7Time &duration)
{
  this->duration = duration.duration;
  return true;
}

bool MP7Time::setDurationFromEnd(const MP7Time &end)
{
  if (!tpoint.hasTime || !end.tpoint.hasTime)
    return false;
  resetDuration();
  uint denom = commonMultiple(tpoint.denom, end.tpoint.denom);
  duration.denom = denom;
  if (compareTimePoint(end) <= 0) {
    duration.sign = 1;
    duration.num = end.tpoint.num * (denom / end.tpoint.denom);
    duration.sec = end.tpoint.sec;
    uint thisnum = tpoint.num * (denom / tpoint.denom);
    if (thisnum > duration.num) {
      duration.num += denom;
      duration.sec--;
    }
    duration.num -= thisnum;
    duration.sec -= tpoint.sec;
  } else {
    MP7Time end2(end);
    if (!end2.setDurationFromEnd(*this))
      return false;
    duration = end2.duration;
    duration.sign = -1;
  }
  if (duration.sec >= SECS_PER_DAY) {
    duration.days = duration.sec / SECS_PER_DAY;
    duration.sec %= SECS_PER_DAY;
  }
  return true;
}

bool MP7Time::addDuration(const MP7Time &otherTime)
{
  if (duration.sign < 0 || otherTime.duration.sign < 0)
    return false;
  if (otherTime.duration.num > 0) {
    uint newDenom = commonMultiple(duration.denom, otherTime.duration.denom);
    duration.num *= newDenom / duration.denom;
    duration.denom = newDenom;
    duration.num += otherTime.duration.num * newDenom / otherTime.duration.denom;
    if (duration.num >= duration.denom) {
      duration.sec++;
      duration.num -= duration.denom;
    }
  }
  duration.sec += otherTime.duration.sec;
  if (duration.sec >= SECS_PER_DAY) {
    duration.days++;
    duration.sec -= SECS_PER_DAY;
  }
  duration.days += otherTime.duration.days;
  return true;
}

const char *MP7Time::timePointPretty(bool forceSubSec) const
{
  static char buf[MP7TIME_TPOINT_BUFSIZE];
  int len = strlen(tpoint.date);
  char *pos = buf;
  if (len > 0) {
    memcpy(pos, tpoint.date, len);
    pos += len;
    if (tpoint.hasTime && *(pos-1) != '-')
      *pos++ = ' ';
  }
  /* avoid returning a null string for "empty" time point */
  if (tpoint.hasTime || !len) {
    pos += sprintf(pos, "%02u:%02u:%02u", tpoint.sec / 3600, (tpoint.sec % 3600) / 60,
                  tpoint.sec % 60);
    if (tpoint.num || forceSubSec) {
      *pos++ = '.';
      pos += sprintf(pos, "%02u", tpoint.num * 100 / tpoint.denom);
    }
  }
  len = strlen(tpoint.tz);
  if (len > 0) {
    memcpy(pos, tpoint.tz, len);
    pos += len;
  }
  *pos = '\0';
  return buf;
}

const char *MP7Time::durationPretty() const
{
  static char buf[MP7TIME_DURATION_BUFSIZE];
  char *pos = buf;
  int size = MP7TIME_DURATION_BUFSIZE;
  int n;
  bool hasTime = (duration.sec != 0 || duration.num != 0);
  if (duration.units) {
    n = snprintf(pos, size, "%d * [", duration.units);
    if (n+1 >= size) {          // count also '-' added below
      dprintf_err("MP7Time::durationPretty() static buffer too small, buf = %s\n",
                  buf);
      return buf;
    }
    pos += n;
    size -= n;
  }
  if (duration.sign < 0) {
    *pos++ = '-';
    size--;
  }
  if (duration.days) {
    n = snprintf(pos, size, "%u days", duration.days);
    if (n+1 >= size) {
      dprintf_err("MP7Time::durationPretty() static buffer too small, buf = %s\n",
                  buf);
      return buf;
    }
    pos += n;
    size -= n;
    if (hasTime || *duration.tz) {
      *pos++ = ' ';
      *pos = '\0';
      size--;
    }
  }
  if (hasTime) {
    n = snprintf(pos, size, "%02u:%02u:%02u", duration.sec / 3600,
                 (duration.sec % 3600) / 60, duration.sec % 60);
    if (n+3 >= size) {
      dprintf_err("MP7Time::durationPretty() static buffer too small, buf = %s\n",
                  buf);
      return buf;
    }
    pos += n;
    size -= n;
    if (duration.num) {
      n = snprintf(pos, size, ".%02u", duration.num * 100 / duration.denom);
      pos += n;
      size -= n;
    }
  }
  if (*duration.tz) {
    int len = strlen(duration.tz);
    if (len >= size) {
      dprintf_err("MP7Time::durationPretty() static buffer too small, buf = %s\n",
                  buf);
      return buf;
    }
    strcpy(pos, duration.tz);
    pos += len;
    size -= len;
  }
  if (duration.units) {
    if (size < 2) {
      dprintf_err("MP7Time::durationPretty() static buffer too small, buf = %s\n",
                  buf);
      return buf;
    }
    *pos++ = ']';
  }
  *pos = '\0';
  return buf;
}

MP7Time MP7Time::endTimePoint() const
{
  MP7Time end;
  end.tpoint.hasTime = tpoint.hasTime;
  end.tpoint.sec = tpoint.sec;
  end.tpoint.num = tpoint.num;
  end.tpoint.denom = tpoint.denom;
  if (duration.num > 0) {
    end.tpoint.denom = commonMultiple(tpoint.denom, duration.denom);
    if (end.tpoint.denom != tpoint.denom)
      end.tpoint.num *= end.tpoint.denom / tpoint.denom;
  }
  int i = 1;
  int sign = duration.sign;
  if (duration.units > 0) {
    i = duration.units;
  } else if (duration.units < 0) {
    i = -duration.units;
    sign = -sign;
  }
  if (sign > 0) {
    if (duration.days)
      end.tpoint.sec += duration.days * SECS_PER_DAY;
    end.tpoint.sec += duration.sec;
    if (duration.num > 0) {
      end.tpoint.num += duration.num * end.tpoint.denom / duration.denom;
      end.tpoint.sec += end.tpoint.num / end.tpoint.denom;
      end.tpoint.num %= end.tpoint.denom;
    }
  } else {
    if (duration.days)
      end.tpoint.sec -= duration.days * SECS_PER_DAY;
    end.tpoint.sec -= duration.sec;
    if (duration.num > 0) {
      uint diff = duration.num * end.tpoint.denom / duration.denom;
      end.tpoint.sec -= diff / end.tpoint.denom;
      diff %= end.tpoint.denom;
      if (diff > end.tpoint.num) {
        end.tpoint.sec--;
        diff -= end.tpoint.denom;
      }
      end.tpoint.num -= diff;
    }
  }
  return end;
}

const char *MP7Time::endTimePointPretty(bool forceSubSec) const
{
  return endTimePoint().timePointPretty(forceSubSec);
}

const char *MP7Time::toString() const
{
  static char buf[MP7TIME_TPOINT_BUFSIZE + MP7TIME_DURATION_BUFSIZE + 3];
  const char *tp = timePointPretty();
  const char *dur = durationPretty();
  int len1 = strlen(tp);
  int len2 = strlen(dur);
  char *pos = buf;
  if (len1 > 0) {
    memcpy(pos, tp, len1);
    pos += len1;
    if (len2 > 0) {
      *pos++ = ' ';
      *pos++ = '[';
    }
  }
  if (len2 > 0) {
    memcpy(pos, dur, len2);
    pos += len2;
    if (len1 > 0)
      *pos++ = ']';
  }
  *pos = '\0';
  return buf;
}

const char *MP7Time::timePointMP7() const
{
  static char buf[MP7TIME_TPOINT_BUFSIZE];
  char *pos = buf;
  int size = MP7TIME_TPOINT_BUFSIZE;
  int len = strlen(tpoint.date);
  int n;
  if (len > 0) {
    strcpy(pos, tpoint.date);
    pos += len;
    size -= len;
  }
  if (tpoint.hasTime) {
    *pos++ = 'T';
    size--;
    n = snprintf(pos, size, "%02u:%02u:%02u", tpoint.sec / 3600,
                 (tpoint.sec % 3600) / 60, tpoint.sec % 60);
    if (n >= size) {
      dprintf_err("MP7Time::timePointMP7() static buffer too small, buf = %s\n",
                  buf);
      return buf;
    }
    pos += n;
    size -= n;
    if (tpoint.num) {
      n = snprintf(pos, size, ":%uF%u", tpoint.num, tpoint.denom);
      if (n >= size) {
        dprintf_err("MP7Time::timePointMP7() static buffer too small, buf = %s\n",
                    buf);
        return buf;
      }
      pos += n;
      size -= n;
    }
  }
  len = strlen(tpoint.tz);
  if (len > 0) {
    if (len >= size) {
      dprintf_err("MP7Time::timePointMP7() static buffer too small, buf = %s\n",
                  buf);
      return buf;
    }
    strcpy(pos, tpoint.tz);
  }
  return buf;
}

const char *MP7Time::durationMP7() const
{
  static char buf[MP7TIME_DURATION_BUFSIZE];
  char *pos = buf;
  int size = MP7TIME_DURATION_BUFSIZE;
  int len = strlen(duration.tz);
  int n;
  const char *err_format = "MP7Time::durationMP7() static buffer too small, buf = %s\n";
  bool hasTime = (duration.sec != 0 || duration.num != 0);
  if (duration.sign < 0) {
    *pos++ = '-';
    size--;
  }
  *pos++ = 'P';
  size--;
  if (duration.days) {
    n = snprintf(pos, size, "%uD", duration.days);
    if (n >= size) {
      dprintf_err(err_format, buf);
      return buf;
    }
    pos += n;
    size -= n;
  }
  if (hasTime) {
    if (size >= 2) {
      *pos++ = 'T';
      *pos = '\0';
      size--;
    }
    uint val = duration.sec / 3600;
    if (val) {
      n = snprintf(pos, size, "%uH", val);
      if (n >= size) {
        dprintf_err(err_format, buf);
        return buf;
      }
      pos += n;
      size -= n;
    }
    val = (duration.sec % 3600) / 60;
    if (val) {
      n = snprintf(pos, size, "%uM", val);
      if (n >= size) {
        dprintf_err(err_format, buf);
        return buf;
      }
      pos += n;
      size -= n;
    }
    val = duration.sec % 60;
    if (val) {
      n = snprintf(pos, size, "%uS", val);
      if (n >= size) {
        dprintf_err(err_format, buf);
        return buf;
      }
      pos += n;
      size -= n;
    }
    if (duration.num) {
      n = snprintf(pos, size, "%uN%uF", duration.num, duration.denom);
      if (n >= size) {
        dprintf_err(err_format, buf);
        return buf;
      }
      pos += n;
      size -= n;
    }
  }
  if (len > 0) {
    if (len+1 >= size) {
      dprintf_err(err_format, buf);
      return buf;
    }
    memcpy(pos, duration.tz, len);
    pos += len;
    *pos++ = 'Z';
  }
  *pos = '\0';
  return buf;
}

double MP7Time::timeToSec() const
{
  if (!tpoint.hasTime)
    return 0.0;
  double sec = (double) tpoint.sec;
  if (tpoint.num)
    sec += (double) tpoint.num / (double) tpoint.denom;
  return sec;
}

int MP7Time::timeToMSec() const
{
  if (!tpoint.hasTime)
    return 0;
  int msec = (int) tpoint.sec * 1000;
  if (tpoint.num)
    msec += (int) (tpoint.num * 1000 / tpoint.denom);
  return msec;
}

int MP7Time::durationToMSec() const
{
  int msec = (int) duration.sec * 1000;
  if (duration.days)
    msec += (int) duration.days * SECS_PER_DAY;
  if (duration.num)
    msec += (int) (duration.num * 1000 / duration.denom);
  if (duration.units)
    msec *= duration.units;
  return msec;
}

double MP7Time::durationToSec() const
{
  double sec = (double) duration.sec;
  if (duration.days)
    sec += (double) (duration.days * SECS_PER_DAY);
  if (duration.num)
    sec += (double) duration.num / (double) duration.denom;
  if (duration.units)
    sec *= (double) duration.units;
  return sec;
}

bool MP7Time::timePointIsValid() const
{
  return *tpoint.date || tpoint.hasTime;
}

bool MP7Time::durationIsNull() const
{
  return !duration.days && !duration.sec && !duration.num;
}

int MP7Time::compareTimePoint(const MP7Time &other) const
{
  if (!tpoint.hasTime && !other.tpoint.hasTime)
    return 0;
  if (!tpoint.hasTime)
    return -1;
  if (!other.tpoint.hasTime)
    return 1;
  if (tpoint.sec < other.tpoint.sec)
    return -1;
  if (tpoint.sec > other.tpoint.sec)
    return 1;
  uint denom = commonMultiple(tpoint.denom, other.tpoint.denom);
  uint thisnum = tpoint.num * (denom / tpoint.denom);
  uint othernum = other.tpoint.num * (denom / other.tpoint.denom);
  if (thisnum < othernum)
    return -1;
  if (thisnum > othernum)
    return 1;
  return 0;
}

bool MP7Time::contains(const MP7Time &time) const
{
  int cmpStart = compareTimePoint(time);
  int cmpEnd = endTimePoint().compareTimePoint(time);
  if (duration.sign < 0) {
    return cmpStart >= 0 && cmpEnd <= 0;
  }
  return cmpStart <= 0 && cmpEnd >= 0;
}

uint MP7Time::commonMultiple(uint op1, uint op2)
{
    if (op1 % op2 == 0)
      return op1;
    if (op2 % op1 == 0)
      return op2;
    return op1 * op2;
}

© ViTooKi 2003 :: [Lite version] Created with Doxygen