cannam@0: cannam@0: cannam@0: VampPluginSDK: RealTime.cpp Source File cannam@0: cannam@0: cannam@0: cannam@0: cannam@0: cannam@0: cannam@0:

RealTime.cpp

Go to the documentation of this file.
00001 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
cannam@0: 00002 
cannam@0: 00003 /*
cannam@0: 00004     Vamp
cannam@0: 00005 
cannam@0: 00006     An API for audio analysis and feature extraction plugins.
cannam@0: 00007 
cannam@0: 00008     Centre for Digital Music, Queen Mary, University of London.
cannam@0: 00009     Copyright 2006 Chris Cannam.
cannam@0: 00010   
cannam@0: 00011     Permission is hereby granted, free of charge, to any person
cannam@0: 00012     obtaining a copy of this software and associated documentation
cannam@0: 00013     files (the "Software"), to deal in the Software without
cannam@0: 00014     restriction, including without limitation the rights to use, copy,
cannam@0: 00015     modify, merge, publish, distribute, sublicense, and/or sell copies
cannam@0: 00016     of the Software, and to permit persons to whom the Software is
cannam@0: 00017     furnished to do so, subject to the following conditions:
cannam@0: 00018 
cannam@0: 00019     The above copyright notice and this permission notice shall be
cannam@0: 00020     included in all copies or substantial portions of the Software.
cannam@0: 00021 
cannam@0: 00022     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
cannam@0: 00023     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
cannam@0: 00024     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
cannam@0: 00025     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
cannam@0: 00026     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
cannam@0: 00027     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
cannam@0: 00028     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
cannam@0: 00029 
cannam@0: 00030     Except as contained in this notice, the names of the Centre for
cannam@0: 00031     Digital Music; Queen Mary, University of London; and Chris Cannam
cannam@0: 00032     shall not be used in advertising or otherwise to promote the sale,
cannam@0: 00033     use or other dealings in this Software without prior written
cannam@0: 00034     authorization.
cannam@0: 00035 */
cannam@0: 00036 
cannam@0: 00037 /*
cannam@0: 00038    This is a modified version of a source file from the 
cannam@0: 00039    Rosegarden MIDI and audio sequencer and notation editor.
cannam@0: 00040    This file copyright 2000-2006 Chris Cannam.
cannam@0: 00041    Relicensed by the author as detailed above.
cannam@0: 00042 */
cannam@0: 00043 
cannam@0: 00044 #include <iostream>
cannam@0: 00045 
cannam@0: 00046 #if (__GNUC__ < 3)
cannam@0: 00047 #include <strstream>
cannam@0: 00048 #define stringstream strstream
cannam@0: 00049 #else
cannam@0: 00050 #include <sstream>
cannam@0: 00051 #endif
cannam@0: 00052 
cannam@0: 00053 using std::cerr;
cannam@0: 00054 using std::endl;
cannam@0: 00055 
cannam@0: 00056 #include "RealTime.h"
cannam@0: 00057 
cannam@0: 00058 #ifndef _WIN32
cannam@0: 00059 #include <sys/time.h>
cannam@0: 00060 #endif
cannam@0: 00061 
cannam@0: 00062 namespace Vamp {
cannam@0: 00063 
cannam@0: 00064 // A RealTime consists of two ints that must be at least 32 bits each.
cannam@0: 00065 // A signed 32-bit int can store values exceeding +/- 2 billion.  This
cannam@0: 00066 // means we can safely use our lower int for nanoseconds, as there are
cannam@0: 00067 // 1 billion nanoseconds in a second and we need to handle double that
cannam@0: 00068 // because of the implementations of addition etc that we use.
cannam@0: 00069 //
cannam@0: 00070 // The maximum valid RealTime on a 32-bit system is somewhere around
cannam@0: 00071 // 68 years: 999999999 nanoseconds longer than the classic Unix epoch.
cannam@0: 00072 
cannam@0: 00073 #define ONE_BILLION 1000000000
cannam@0: 00074 
cannam@0: 00075 RealTime::RealTime(int s, int n) :
cannam@0: 00076     sec(s), nsec(n)
cannam@0: 00077 {
cannam@0: 00078     if (sec == 0) {
cannam@0: 00079         while (nsec <= -ONE_BILLION) { nsec += ONE_BILLION; --sec; }
cannam@0: 00080         while (nsec >=  ONE_BILLION) { nsec -= ONE_BILLION; ++sec; }
cannam@0: 00081     } else if (sec < 0) {
cannam@0: 00082         while (nsec <= -ONE_BILLION) { nsec += ONE_BILLION; --sec; }
cannam@0: 00083         while (nsec > 0)             { nsec -= ONE_BILLION; ++sec; }
cannam@0: 00084     } else { 
cannam@0: 00085         while (nsec >=  ONE_BILLION) { nsec -= ONE_BILLION; ++sec; }
cannam@0: 00086         while (nsec < 0)             { nsec += ONE_BILLION; --sec; }
cannam@0: 00087     }
cannam@0: 00088 }
cannam@0: 00089 
cannam@0: 00090 RealTime
cannam@0: 00091 RealTime::fromSeconds(double sec)
cannam@0: 00092 {
cannam@0: 00093     return RealTime(int(sec), int((sec - int(sec)) * ONE_BILLION + 0.5));
cannam@0: 00094 }
cannam@0: 00095 
cannam@0: 00096 RealTime
cannam@0: 00097 RealTime::fromMilliseconds(int msec)
cannam@0: 00098 {
cannam@0: 00099     return RealTime(msec / 1000, (msec % 1000) * 1000000);
cannam@0: 00100 }
cannam@0: 00101 
cannam@0: 00102 #ifndef _WIN32
cannam@0: 00103 RealTime
cannam@0: 00104 RealTime::fromTimeval(const struct timeval &tv)
cannam@0: 00105 {
cannam@0: 00106     return RealTime(tv.tv_sec, tv.tv_usec * 1000);
cannam@0: 00107 }
cannam@0: 00108 #endif
cannam@0: 00109 
cannam@0: 00110 std::ostream &operator<<(std::ostream &out, const RealTime &rt)
cannam@0: 00111 {
cannam@0: 00112     if (rt < RealTime::zeroTime) {
cannam@0: 00113         out << "-";
cannam@0: 00114     } else {
cannam@0: 00115         out << " ";
cannam@0: 00116     }
cannam@0: 00117 
cannam@0: 00118     int s = (rt.sec < 0 ? -rt.sec : rt.sec);
cannam@0: 00119     int n = (rt.nsec < 0 ? -rt.nsec : rt.nsec);
cannam@0: 00120 
cannam@0: 00121     out << s << ".";
cannam@0: 00122 
cannam@0: 00123     int nn(n);
cannam@0: 00124     if (nn == 0) out << "00000000";
cannam@0: 00125     else while (nn < (ONE_BILLION / 10)) {
cannam@0: 00126         out << "0";
cannam@0: 00127         nn *= 10;
cannam@0: 00128     }
cannam@0: 00129     
cannam@0: 00130     out << n << "R";
cannam@0: 00131     return out;
cannam@0: 00132 }
cannam@0: 00133 
cannam@0: 00134 std::string
cannam@0: 00135 RealTime::toString() const
cannam@0: 00136 {
cannam@0: 00137     std::stringstream out;
cannam@0: 00138     out << *this;
cannam@0: 00139     
cannam@0: 00140 #if (__GNUC__ < 3)
cannam@0: 00141     out << std::ends;
cannam@0: 00142 #endif
cannam@0: 00143 
cannam@0: 00144     std::string s = out.str();
cannam@0: 00145 
cannam@0: 00146     // remove trailing R
cannam@0: 00147     return s.substr(0, s.length() - 1);
cannam@0: 00148 }
cannam@0: 00149 
cannam@0: 00150 std::string
cannam@0: 00151 RealTime::toText(bool fixedDp) const
cannam@0: 00152 {
cannam@0: 00153     if (*this < RealTime::zeroTime) return "-" + (-*this).toText();
cannam@0: 00154 
cannam@0: 00155     std::stringstream out;
cannam@0: 00156 
cannam@0: 00157     if (sec >= 3600) {
cannam@0: 00158         out << (sec / 3600) << ":";
cannam@0: 00159     }
cannam@0: 00160 
cannam@0: 00161     if (sec >= 60) {
cannam@0: 00162         out << (sec % 3600) / 60 << ":";
cannam@0: 00163     }
cannam@0: 00164 
cannam@0: 00165     if (sec >= 10) {
cannam@0: 00166         out << ((sec % 60) / 10);
cannam@0: 00167     }
cannam@0: 00168 
cannam@0: 00169     out << (sec % 10);
cannam@0: 00170     
cannam@0: 00171     int ms = msec();
cannam@0: 00172 
cannam@0: 00173     if (ms != 0) {
cannam@0: 00174         out << ".";
cannam@0: 00175         out << (ms / 100);
cannam@0: 00176         ms = ms % 100;
cannam@0: 00177         if (ms != 0) {
cannam@0: 00178             out << (ms / 10);
cannam@0: 00179             ms = ms % 10;
cannam@0: 00180         } else if (fixedDp) {
cannam@0: 00181             out << "0";
cannam@0: 00182         }
cannam@0: 00183         if (ms != 0) {
cannam@0: 00184             out << ms;
cannam@0: 00185         } else if (fixedDp) {
cannam@0: 00186             out << "0";
cannam@0: 00187         }
cannam@0: 00188     } else if (fixedDp) {
cannam@0: 00189         out << ".000";
cannam@0: 00190     }
cannam@0: 00191         
cannam@0: 00192 #if (__GNUC__ < 3)
cannam@0: 00193     out << std::ends;
cannam@0: 00194 #endif
cannam@0: 00195 
cannam@0: 00196     std::string s = out.str();
cannam@0: 00197 
cannam@0: 00198     return s;
cannam@0: 00199 }
cannam@0: 00200 
cannam@0: 00201 
cannam@0: 00202 RealTime
cannam@0: 00203 RealTime::operator/(int d) const
cannam@0: 00204 {
cannam@0: 00205     int secdiv = sec / d;
cannam@0: 00206     int secrem = sec % d;
cannam@0: 00207 
cannam@0: 00208     double nsecdiv = (double(nsec) + ONE_BILLION * double(secrem)) / d;
cannam@0: 00209     
cannam@0: 00210     return RealTime(secdiv, int(nsecdiv + 0.5));
cannam@0: 00211 }
cannam@0: 00212 
cannam@0: 00213 double 
cannam@0: 00214 RealTime::operator/(const RealTime &r) const
cannam@0: 00215 {
cannam@0: 00216     double lTotal = double(sec) * ONE_BILLION + double(nsec);
cannam@0: 00217     double rTotal = double(r.sec) * ONE_BILLION + double(r.nsec);
cannam@0: 00218     
cannam@0: 00219     if (rTotal == 0) return 0.0;
cannam@0: 00220     else return lTotal/rTotal;
cannam@0: 00221 }
cannam@0: 00222 
cannam@0: 00223 long
cannam@0: 00224 RealTime::realTime2Frame(const RealTime &time, unsigned int sampleRate)
cannam@0: 00225 {
cannam@0: 00226     if (time < zeroTime) return -realTime2Frame(-time, sampleRate);
cannam@0: 00227     double s = time.sec + double(time.nsec + 1) / 1000000000.0;
cannam@0: 00228     return long(s * sampleRate);
cannam@0: 00229 }
cannam@0: 00230 
cannam@0: 00231 RealTime
cannam@0: 00232 RealTime::frame2RealTime(long frame, unsigned int sampleRate)
cannam@0: 00233 {
cannam@0: 00234     if (frame < 0) return -frame2RealTime(-frame, sampleRate);
cannam@0: 00235 
cannam@0: 00236     RealTime rt;
cannam@0: 00237     rt.sec = frame / long(sampleRate);
cannam@0: 00238     frame -= rt.sec * long(sampleRate);
cannam@0: 00239     rt.nsec = (int)(((double(frame) * 1000000.0) / sampleRate) * 1000.0);
cannam@0: 00240     return rt;
cannam@0: 00241 }
cannam@0: 00242 
cannam@0: 00243 const RealTime RealTime::zeroTime(0,0);
cannam@0: 00244 
cannam@0: 00245 }
cannam@0: 
cannam@0:
Generated on Wed Jul 9 11:36:07 2008 for VampPluginSDK by  cannam@0: cannam@0: doxygen 1.5.5
cannam@0: cannam@0: