Use an enumeration type rather than unnamed integers to specify the different types...
[synfig.git] / synfig-core / trunk / src / synfig / time.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file time.cpp
3 **      \brief Template File
4 **
5 **      $Id$
6 **
7 **      \legal
8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 **      Copyright (c) 2007 Chris Moore
10 **
11 **      This package is free software; you can redistribute it and/or
12 **      modify it under the terms of the GNU General Public License as
13 **      published by the Free Software Foundation; either version 2 of
14 **      the License, or (at your option) any later version.
15 **
16 **      This package is distributed in the hope that it will be useful,
17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 **      General Public License for more details.
20 **      \endlegal
21 */
22 /* ========================================================================= */
23
24 /* === H E A D E R S ======================================================= */
25
26 #ifdef USING_PCH
27 #       include "pch.h"
28 #else
29 #ifdef HAVE_CONFIG_H
30 #       include <config.h>
31 #endif
32
33 #include "time.h"
34 #include <ETL/stringf>
35 #include <ETL/misc>
36 #include "general.h"
37 #include <cmath>
38 #include <cassert>
39 #include <algorithm>
40 #include <ctype.h>
41 #include <math.h>
42
43
44 #ifdef WIN32
45 #include <float.h>
46 #ifndef isnan
47 extern "C" { int _isnan(double x); }
48 #define isnan _isnan
49 #endif
50 #endif
51
52 // For some reason isnan() isn't working on macosx any more.
53 // This is a quick fix.
54 #if defined(__APPLE__) && !defined(SYNFIG_ISNAN_FIX)
55 #ifdef isnan
56 #undef isnan
57 #endif
58 inline bool isnan(double x) { return x != x; }
59 inline bool isnan(float x) { return x != x; }
60 #define SYNFIG_ISNAN_FIX 1
61 #endif
62
63
64 #endif
65
66 /* === U S I N G =========================================================== */
67
68 using namespace std;
69 using namespace etl;
70 using namespace synfig;
71
72 #define tolower ::tolower
73
74 /* === M A C R O S ========================================================= */
75
76 /* === G L O B A L S ======================================================= */
77
78 /* === M E T H O D S ======================================================= */
79
80 Time::Time(const String &str_, float fps):
81         value_(0)
82 {
83         String str(str_);
84         std::transform(str.begin(),str.end(),str.begin(),&tolower);
85
86         // Start/Begin Of Time
87         if(str=="sot" || str=="bot")
88         {
89                 operator=(begin());
90                 return;
91         }
92         // End Of Time
93         if(str=="eot")
94         {
95                 operator=(end());
96                 return;
97         }
98
99
100         unsigned int pos=0;
101         int read;
102         float amount;
103
104         // Now try to read it in the letter-abreviated format
105         while(pos<str.size() && sscanf(String(str,pos).c_str(),"%f%n",&amount,&read))
106         {
107                 pos+=read;
108                 if(pos>=str.size() || read==0)
109                 {
110                         // Throw up a warning if there are no units
111                         // and the amount isn't zero. There is no need
112                         // to warn about units if the value is zero
113                         // it is the only case where units are irrelevant.
114                         if(amount!=0)
115                                 synfig::warning("Time(): No unit provided in time code, assuming SECONDS (\"%s\")",str.c_str());
116                         value_+=amount;
117                         return;
118                 }
119                 switch(str[pos])
120                 {
121                         case 'h':
122                         case 'H':
123                                 value_+=amount*3600;
124                                 break;
125                         case 'm':
126                         case 'M':
127                                 value_+=amount*60;
128                                 break;
129                         case 's':
130                         case 'S':
131                                 value_+=amount;
132                                 break;
133                         case 'f':
134                         case 'F':
135                                 if(fps)
136                                         value_+=amount/fps;
137                                 else
138                                         synfig::warning("Time(): Individual frames referenced, but frame rate is unknown");
139                                 break;
140                         case ':':
141                                 // try to read it in as a traditional time format
142                                 {
143                                         int hour,minute,second;
144                                         float frame;
145                                         if(fps && sscanf(str.c_str(),"%d:%d:%d.%f",&hour,&minute,&second,&frame)==4)
146                                         {
147                                                         value_=frame/fps+(hour*3600+minute*60+second);
148                                                         return;
149                                         }
150
151                                         if(sscanf(str.c_str(),"%d:%d:%d",&hour,&minute,&second)==3)
152                                         {
153                                                 value_=hour*3600+minute*60+second;
154                                                 return;
155                                         }
156                                 }
157                                 synfig::warning("Time(): Bad time format");
158                                 break;
159
160                         default:
161                                 value_+=amount;
162                                 synfig::warning("Time(): Unexpected character '%c' when parsing time string \"%s\"",str[pos],str.c_str());
163                                 break;
164                 }
165                 pos++;
166                 amount=0;
167         }
168 }
169
170 String
171 Time::get_string(float fps, Time::Format format)const
172 {
173         Time time(*this);
174
175         if(time<=begin())
176                 return "SOT";   // Start Of Time
177         if(time>=end())
178                 return "EOT";   // End Of Time
179
180         if(fps<0)fps=0;
181
182         if(ceil(time.value_)-time.value_<epsilon_())
183                 time.value_=ceil(time.value_);
184
185         int hour,minute;
186
187         hour=time/3600;time-=hour*3600;
188         minute=time/60;time-=minute*60;
189
190         // <= is redefined, so this means "is the FORMAT_VIDEO bit set in the format?"
191         if(format<=FORMAT_VIDEO)
192         {
193                 int second;
194                 second=time;time-=second;
195
196                 if(fps)
197                 {
198                         int frame;
199                         frame=round_to_int(time*fps);
200
201                         return strprintf("%02d:%02d:%02d.%02d",hour,minute,second,frame);
202                 }
203                 else
204                         return strprintf("%02d:%02d:%02d",hour,minute,second);
205         }
206
207         String ret;
208         bool started = false;
209
210         if(format<=FORMAT_FULL || hour)
211         {
212                 ret+=strprintf(format<=FORMAT_NOSPACES?"%dh":"%dh ",hour);
213                 started = true;
214         }
215
216         if(format<=FORMAT_FULL || minute)
217         {
218                 ret+=strprintf(format<=FORMAT_NOSPACES?"%dm":"%dm ",minute);
219                 started = true;
220         }
221
222         if(fps)
223         {
224                 int second;
225                 float frame;
226                 second=time;time-=second;
227                 frame=time*fps;
228                 if(format<=FORMAT_FULL || second)
229                 {
230                         ret+=strprintf(format<=FORMAT_NOSPACES?"%ds":"%ds ",(int)second);
231                         started = true;
232                 }
233
234                 if(format<=FORMAT_FULL || frame || !started)
235                 {
236                         if(abs(frame-floor(frame)>=epsilon_()))
237                                 ret+=strprintf("%0.3ff",frame);
238                         else
239                                 ret+=strprintf("%0.0ff",frame);
240                 }
241         }
242         else
243         {
244                 float second;
245                 second=time;
246                 if(format<=FORMAT_FULL || second || !started)
247                 {
248                         if(abs(second-floor(second))>=epsilon_())
249                                 ret+=strprintf("%0.8fs",second);
250                         else
251                                 ret+=strprintf("%0.0fs",second);
252                 }
253         }
254
255         return ret;
256 }
257
258 Time
259 Time::round(float fps)const
260 {
261         assert(fps>0);
262
263         value_type time(*this);
264
265         time*=fps;
266
267         if(abs(time-floor(time))<0.5)
268                 return floor(time)/fps;
269         else
270                 return ceil(time)/fps;
271 }
272
273 //! \writeme
274 bool
275 Time::is_valid()const
276 {
277         return !isnan(value_);
278 }