//*********************************************************
// returns the total duration in REFERENCE_TIME
// of the file (or timeshifting files) since start of playback
// The TotalDuration() >= Duration() since the timeshifting files may have been
// wrapped and reused.
CRefTime CTsDuration::TotalDuration()
{
CAutoLock rLock (&m_accessLock);
if (!m_firstStartPcr.IsValid || !m_endPcr.IsValid)
{
return 0L;
}
else if (m_maxPcr.IsValid)
{
double duration= m_endPcr.ToClock() + (m_maxPcr.ToClock()- m_firstStartPcr.ToClock());
CPcr pcr;
pcr.FromClock(duration);
//LogDebug("Duration:%f %s", duration, pcr.ToString());
CRefTime refTime((LONG)(duration*1000.0f));
return refTime;
}
else
{
double duration= m_endPcr.ToClock() - m_firstStartPcr.ToClock();
CPcr pcr;
pcr.FromClock(duration);
//LogDebug("Duration:%f %s", duration, pcr.ToString());
CRefTime refTime((LONG)(duration*1000.0f));
return refTime;
}
}
void CBDReaderFilter::Seek(REFERENCE_TIME rtAbsSeek)
{
CAutoLock cObjectLock(m_pLock);
LogDebug("CBDReaderFilter::--Seek()-- %6.3f, media changing %d", rtAbsSeek / 10000000.0, m_demultiplexer.IsMediaChanging());
if (!m_bUpdateStreamPositionOnly)
{
LogDebug("CBDReaderFilter::Seek - Flush");
m_demultiplexer.Flush(true, true, rtAbsSeek);
lib.Seek(CONVERT_DS_90KHz(rtAbsSeek));
}
m_bUpdateStreamPositionOnly = false;
if (m_pDVBSubtitle)
{
m_pDVBSubtitle->SetFirstPcr(0); // TODO: check if we need ot set the 1st PTS
CRefTime refTime(rtAbsSeek);
m_pDVBSubtitle->SeekDone(refTime);
}
}
void
TrackerNodePrivate::solveTransformParams()
{
setTransformOutOfDate(false);
std::vector<TrackMarkerPtr> markers;
knobsTable->getAllMarkers(&markers);
if ( markers.empty() ) {
return;
}
resetTransformParamsAnimation();
KnobChoicePtr motionTypeKnob = motionType.lock();
int motionType_i = motionTypeKnob->getValue();
TrackerMotionTypeEnum type = (TrackerMotionTypeEnum)motionType_i;
TimeValue refTime(referenceFrame.lock()->getValue());
int jitterPer = 0;
bool jitterAdd = false;
switch (type) {
case eTrackerMotionTypeNone:
return;
case eTrackerMotionTypeMatchMove:
case eTrackerMotionTypeStabilize:
break;
case eTrackerMotionTypeAddJitter:
case eTrackerMotionTypeRemoveJitter: {
jitterPer = jitterPeriod.lock()->getValue();
jitterAdd = type == eTrackerMotionTypeAddJitter;
break;
}
}
setSolverParamsEnabled(false);
std::set<TimeValue> keyframes;
{
for (std::size_t i = 0; i < markers.size(); ++i) {
std::set<double> keys;
markers[i]->getCenterKeyframes(&keys);
for (std::set<double>::iterator it = keys.begin(); it != keys.end(); ++it) {
keyframes.insert(TimeValue(*it));
}
}
}
KnobChoicePtr transformTypeKnob = transformType.lock();
assert(transformTypeKnob);
int transformType_i = transformTypeKnob->getValue();
TrackerTransformNodeEnum transformType = (TrackerTransformNodeEnum)transformType_i;
NodePtr node = publicInterface->getNode();
invertTransform.lock()->setValue(type == eTrackerMotionTypeStabilize);
KnobDoublePtr centerKnob = center.lock();
// Set the center at the reference frame
Point centerValue = {0, 0};
int nSamplesAtRefTime = 0;
for (std::size_t i = 0; i < markers.size(); ++i) {
if ( !markers[i]->isEnabled(refTime) ) {
continue;
}
KnobDoublePtr markerCenterKnob = markers[i]->getCenterKnob();
centerValue.x += markerCenterKnob->getValueAtTime(refTime);
centerValue.y += markerCenterKnob->getValueAtTime(refTime, DimIdx(1));
++nSamplesAtRefTime;
}
if (nSamplesAtRefTime) {
centerValue.x /= nSamplesAtRefTime;
centerValue.y /= nSamplesAtRefTime;
{
std::vector<double> values(2);
values[0] = centerValue.x;
values[1] = centerValue.y;
centerKnob->setValueAcrossDimensions(values);
}
}
bool robust;
robust = robustModel.lock()->getValue();
KnobDoublePtr maxFittingErrorKnob = fittingErrorWarnIfAbove.lock();
const double maxFittingError = maxFittingErrorKnob->getValue();
node->getApp()->progressStart( node, tr("Solving for transform parameters...").toStdString(), std::string() );
lastSolveRequest.refTime = refTime;
lastSolveRequest.jitterPeriod = jitterPer;
lastSolveRequest.jitterAdd = jitterAdd;
lastSolveRequest.allMarkers = markers;
lastSolveRequest.keyframes = keyframes;
lastSolveRequest.robustModel = robust;
lastSolveRequest.maxFittingError = maxFittingError;
switch (transformType) {
case eTrackerTransformNodeTransform:
computeTransformParamsFromTracks();
break;
case eTrackerTransformNodeCornerPin:
computeCornerParamsFromTracks();
break;
}
} // TrackerNodePrivate::solveTransformParams