← Back to branch summary

~ubuntu-branches/ubuntu/hoary/kdemultimedia/hoary

« back to all changes in this revision

Viewing changes to mpeglib/lib/util/timeStamp.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Martin Schulze
  • Date: 2003-01-22 15:00:51 UTC
  • Revision ID: james.westby@ubuntu.com-20030122150051-uihwkdoxf15mi1tn
Tags: upstream-2.2.2
Import upstream version 2.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
mpeglib/lib/util/timeStamp.cpp
 
1
/*
 
2
  class for managing byte positions and associated time positions
 
3
  Copyright (C) 1999  Martin Vogt
 
4
 
 
5
  This program is free software; you can redistribute it and/or modify
 
6
  it under the terms of the GNU Library General Public License as published by
 
7
  the Free Software Foundation.
 
8
 
 
9
  For more information look at the file COPYRIGHT in this package
 
10
 
 
11
 */
 
12
 
 
13
 
 
14
#include "timeStamp.h"
 
15
 
 
16
 
 
17
 
 
18
TimeStamp::TimeStamp() {
 
19
  key=0;
 
20
  keylen=0;
 
21
  time.tv_sec=0;
 
22
  time.tv_usec=0;
 
23
 
 
24
  ptsTimeStamp=0.0;
 
25
  scrTimeStamp=0.0;
 
26
  videoFrameCounter=0;
 
27
  dtsTimeStamp=0.0;
 
28
  lPTSFlag=false;
 
29
 
 
30
}
 
31
 
 
32
 
 
33
TimeStamp::~TimeStamp() {
 
34
}
 
35
 
 
36
 
 
37
void TimeStamp::copyTo(TimeStamp* dest) {
 
38
  dest->setKey(key,keylen);
 
39
  dest->setTime(&time);
 
40
  dest->setPTSTimeStamp(ptsTimeStamp);
 
41
  dest->setVideoFrameCounter(videoFrameCounter);
 
42
 
 
43
  dest->setSCRTimeStamp(scrTimeStamp);
 
44
  dest->setDTSTimeStamp(dtsTimeStamp);
 
45
  dest->setSyncClock(syncClock);
 
46
  dest->setPTSFlag(lPTSFlag);
 
47
}
 
48
 
 
49
 
 
50
long TimeStamp::getKey() {
 
51
  return key;
 
52
}
 
53
 
 
54
int TimeStamp::getKeyLen() {
 
55
  return keylen;
 
56
}
 
57
 
 
58
void TimeStamp::setKey(long key,int len) {
 
59
  this->key=key;
 
60
  this->keylen=len;
 
61
}
 
62
 
 
63
 
 
64
void TimeStamp::setTime(timeval_t* newTime) {
 
65
  time.tv_sec=newTime->tv_sec;
 
66
  time.tv_usec=newTime->tv_usec;
 
67
}
 
68
 
 
69
 
 
70
void TimeStamp::gettimeofday() {
 
71
  TimeWrapper::gettimeofday(&time);
 
72
}
 
73
 
 
74
 
 
75
timeval_t* TimeStamp::getTime() {
 
76
  return &time;
 
77
}
 
78
 
 
79
 
 
80
void TimeStamp::waitForIt() {
 
81
  timeval_t waitTime;
 
82
 
 
83
  waitTime.tv_sec=time.tv_sec;
 
84
  waitTime.tv_usec=time.tv_usec;
 
85
 
 
86
  if (isPositive()) {
 
87
    //cout << "wait:"<<waitTime.tv_sec<<" usec:"<<waitTime.tv_usec<<endl;
 
88
    TimeWrapper::usleep(&waitTime);
 
89
  }
 
90
    
 
91
}
 
92
 
 
93
void TimeStamp::addOffset(TimeStamp* stamp) {
 
94
  addOffset(stamp->time.tv_sec,stamp->time.tv_usec);
 
95
}
 
96
 
 
97
void TimeStamp::addOffset(int sec,long usec) {
 
98
  time.tv_sec=time.tv_sec+sec;
 
99
  time.tv_usec=time.tv_usec+usec;
 
100
  if (time.tv_usec >= 1000000) {
 
101
    time.tv_usec-=1000000;
 
102
    time.tv_sec++;
 
103
  }
 
104
  if (time.tv_usec < 0) {
 
105
    time.tv_usec+=1000000;
 
106
    time.tv_sec--;   
 
107
  }  
 
108
}
 
109
 
 
110
void TimeStamp::minus(int sec,long usec) {
 
111
 
 
112
  time.tv_usec-=usec;
 
113
  time.tv_sec-=sec;
 
114
  if (time.tv_usec <= 0) {
 
115
    time.tv_usec=time.tv_usec+1000000;
 
116
    time.tv_sec--;
 
117
  }
 
118
  if (time.tv_usec >= 1000000) {
 
119
    time.tv_usec=time.tv_usec-1000000;
 
120
    time.tv_sec++;
 
121
  }  
 
122
 
 
123
}
 
124
 
 
125
void TimeStamp::minus(TimeStamp* stamp,TimeStamp* dest) {
 
126
  
 
127
  long sec=time.tv_sec;
 
128
  long usec=time.tv_usec;
 
129
 
 
130
  minus(stamp->time.tv_sec,stamp->time.tv_usec);
 
131
 
 
132
  dest->set(time.tv_sec,time.tv_usec);
 
133
  if (dest != this) {
 
134
    time.tv_sec=sec;
 
135
    time.tv_usec=usec;
 
136
  }
 
137
}
 
138
 
 
139
 
 
140
int TimeStamp::lessThan(TimeStamp* stamp) {
 
141
  return lessThan(stamp->time.tv_sec,stamp->time.tv_usec);
 
142
}
 
143
 
 
144
 
 
145
int TimeStamp::lessThan(int sec,long usec) {
 
146
  int back=false;
 
147
  if (time.tv_sec < sec) {
 
148
    back=true;
 
149
  } else {
 
150
    if (time.tv_sec == sec) {
 
151
      if (time.tv_usec < usec) {
 
152
        back=true;
 
153
      }
 
154
    }
 
155
  }
 
156
  return back;
 
157
}
 
158
 
 
159
void TimeStamp::set(long sec,long usec) {
 
160
  time.tv_sec=sec;
 
161
  time.tv_usec=usec;
 
162
}
 
163
 
 
164
 
 
165
 
 
166
void TimeStamp::print(const char* name) {
 
167
  cout << name
 
168
       <<" lPTS:"<<lPTSFlag
 
169
       <<" pts:"<<ptsTimeStamp
 
170
       <<" dts:"<<dtsTimeStamp
 
171
       <<" scr:"<<scrTimeStamp
 
172
       <<" key:"<<key
 
173
       <<" sec:"<<time.tv_sec
 
174
       <<" usec:"<<time.tv_usec
 
175
       <<" v-Minor:"<<videoFrameCounter<<endl;
 
176
 
 
177
 
 
178
}
 
179
 
 
180
 
 
181
 
 
182
 
 
183
 
 
184
int TimeStamp::isPositive() {
 
185
  if ((time.tv_sec == 0) && (time.tv_usec == 0)) {
 
186
    return false;
 
187
  }
 
188
  return ((time.tv_sec >= 0) && (time.tv_usec >= 0));
 
189
}
 
190
 
 
191
 
 
192
int TimeStamp::isNegative() {
 
193
  if (time.tv_sec < 0) {
 
194
    return true;
 
195
  }
 
196
  if (time.tv_usec < 0) {
 
197
    return true;
 
198
  }
 
199
  return false;
 
200
}
 
201
 
 
202
 
 
203
int TimeStamp::getPTSFlag() {
 
204
  return lPTSFlag;
 
205
}
 
206
 
 
207
void TimeStamp::setPTSFlag(int lPTSFlag) {
 
208
  this->lPTSFlag=lPTSFlag;
 
209
}
 
210
 
 
211
double TimeStamp::getPTSTimeStamp() {
 
212
  return ptsTimeStamp;
 
213
}
 
214
 
 
215
 
 
216
void TimeStamp::setPTSTimeStamp(double ptsTimeStamp) {
 
217
  this->ptsTimeStamp=ptsTimeStamp;
 
218
}
 
219
 
 
220
 
 
221
double TimeStamp::getSCRTimeStamp() {
 
222
  return scrTimeStamp;
 
223
}
 
224
 
 
225
 
 
226
void TimeStamp::setSCRTimeStamp(double scrTimeStamp) {
 
227
  this->scrTimeStamp=scrTimeStamp;
 
228
}
 
229
 
 
230
 
 
231
double TimeStamp::getDTSTimeStamp() {
 
232
  return dtsTimeStamp;
 
233
}
 
234
 
 
235
 
 
236
void TimeStamp::setDTSTimeStamp(double dtsTimeStamp) {
 
237
  this->dtsTimeStamp=dtsTimeStamp;
 
238
}
 
239
 
 
240
int TimeStamp::getVideoFrameCounter() {
 
241
  return videoFrameCounter;
 
242
}
 
243
 
 
244
 
 
245
void TimeStamp::setVideoFrameCounter(int nr) {
 
246
  this->videoFrameCounter=nr;
 
247
}
 
248
 
 
249
 
 
250
 
 
251
double TimeStamp::getAsSeconds() {
 
252
  return (double)time.tv_sec+(double)time.tv_usec/(double)1000000;
 
253
}
 
254
 
 
255
  
 
256
 
 
257
SyncClock* TimeStamp::getSyncClock() {
 
258
  return syncClock;
 
259
}
 
260
 
 
261
void TimeStamp::setSyncClock(SyncClock* syncClock) {
 
262
  this->syncClock=syncClock;
 
263
}
 
264
 
 
265
 
 
266
 
 
267
 
 
268
 
 
269
 
 
270