blob: 05e4287c9e0c76c4ab677fa13a7ba99561f4a0c9 [file] [log] [blame]
///////////////////////////////////////////////////////////////////////////////
//
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// http://www.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
// License for the specific language governing rights and limitations
// under the License.
//
// The Original Code is MP4v2.
//
// The Initial Developer of the Original Code is Kona Blend.
// Portions created by Kona Blend are Copyright (C) 2008.
// All Rights Reserved.
//
// Contributors:
// Kona Blend, kona8lend@@gmail.com
//
///////////////////////////////////////////////////////////////////////////////
#include "libutil/impl.h"
namespace mp4v2 { namespace util {
///////////////////////////////////////////////////////////////////////////////
Timecode::Timecode( const Timecode& obj )
: _scale ( 1.0 )
, _duration ( 0 )
, _format ( FRAME )
, _svalue ( "" )
, _hours ( 0 )
, _minutes ( 0 )
, _seconds ( 0 )
, _subseconds ( 0 )
, scale ( _scale )
, duration ( _duration )
, format ( _format )
, svalue ( _svalue )
, hours ( _hours )
, minutes ( _minutes )
, seconds ( _seconds )
, subseconds ( _subseconds )
{
operator=( obj );
}
///////////////////////////////////////////////////////////////////////////////
Timecode::Timecode( const string& time_, double scale_ )
: _scale ( scale_ < 1.0 ? 1.0 : scale_ )
, _duration ( 0 )
, _format ( FRAME )
, _svalue ( "" )
, _hours ( 0 )
, _minutes ( 0 )
, _seconds ( 0 )
, _subseconds ( 0 )
, scale ( _scale )
, duration ( _duration )
, format ( _format )
, svalue ( _svalue )
, hours ( _hours )
, minutes ( _minutes )
, seconds ( _seconds )
, subseconds ( _subseconds )
{
parse( time_ );
}
///////////////////////////////////////////////////////////////////////////////
Timecode::Timecode( uint64_t duration_, double scale_ )
: _scale ( scale_ < 1.0 ? 1.0 : scale_ )
, _duration ( 0 )
, _format ( FRAME )
, _svalue ( "" )
, _hours ( 0 )
, _minutes ( 0 )
, _seconds ( 0 )
, _subseconds ( 0 )
, scale ( _scale )
, duration ( _duration )
, format ( _format )
, svalue ( _svalue )
, hours ( _hours )
, minutes ( _minutes )
, seconds ( _seconds )
, subseconds ( _subseconds )
{
setDuration( duration_ );
}
///////////////////////////////////////////////////////////////////////////////
uint64_t
Timecode::convertDuration( const Timecode& obj ) const
{
if( _scale == obj._scale )
return obj._duration;
return static_cast<uint64_t>( ( _scale / obj._scale ) * obj._duration );
}
///////////////////////////////////////////////////////////////////////////////
Timecode&
Timecode::operator=( const Timecode& rhs )
{
_scale = rhs._scale;
_duration = rhs._duration;
_format = FRAME;
_svalue = rhs._svalue;
_hours = rhs._hours;
_minutes = rhs._minutes;
_seconds = rhs._seconds;
_subseconds = rhs._subseconds;
return *this;
}
///////////////////////////////////////////////////////////////////////////////
Timecode&
Timecode::operator+=( const Timecode& rhs )
{
uint64_t dur = _duration + convertDuration( rhs );
// overflow check
if( dur < _duration )
dur = std::numeric_limits<long long>::max();
setDuration( dur );
return *this;
}
///////////////////////////////////////////////////////////////////////////////
Timecode&
Timecode::operator-=( const Timecode& rhs )
{
uint64_t dur = _duration - convertDuration( rhs );
// underflow check
if( dur > _duration )
dur = 0;
setDuration( dur );
return *this;
}
///////////////////////////////////////////////////////////////////////////////
bool
Timecode::operator<( const Timecode& obj ) const
{
return _duration < convertDuration( obj );
}
///////////////////////////////////////////////////////////////////////////////
bool
Timecode::operator<=( const Timecode& obj ) const
{
return _duration <= convertDuration( obj );
}
///////////////////////////////////////////////////////////////////////////////
bool
Timecode::operator>( const Timecode& obj ) const
{
return _duration < convertDuration( obj );
}
///////////////////////////////////////////////////////////////////////////////
bool
Timecode::operator>=( const Timecode& obj ) const
{
return _duration < convertDuration( obj );
}
///////////////////////////////////////////////////////////////////////////////
bool
Timecode::operator!=( const Timecode& obj ) const
{
return _duration != convertDuration( obj );
}
///////////////////////////////////////////////////////////////////////////////
bool
Timecode::operator==( const Timecode& obj ) const
{
return _duration == convertDuration( obj );
}
///////////////////////////////////////////////////////////////////////////////
Timecode
Timecode::operator+( const Timecode& obj ) const
{
Timecode t( *this );
t += obj;
return t;
}
///////////////////////////////////////////////////////////////////////////////
Timecode
Timecode::operator-( const Timecode& obj ) const
{
Timecode t( *this );
t -= obj;
return t;
}
///////////////////////////////////////////////////////////////////////////////
bool
Timecode::parse( const string& time, string* outError )
{
string outErrorPlacebo;
string& error = outError ? *outError : outErrorPlacebo;
error.clear();
_format = FRAME;
_hours = 0;
_minutes = 0;
_seconds = 0;
_subseconds = 0;
// bail if empty
if( time.empty() ) {
recompute();
return false;
}
// count number of ':'
int nsect = 0;
int nsemi = 0;
int ndot = 0;
const string::size_type max = time.length();
for( string::size_type i = 0; i < max; i++ ) {
switch( time[i] ) {
case ':':
nsect++;
break;
case ';':
if( nsemi++ ) {
error = "too many semicolons";
return true;
}
nsect++;
break;
case '.':
if( ndot++ ) {
error = "too many periods";
return true;
}
nsect++;
break;
default:
break;
}
}
// bail if impossible number of sections
if( nsect > 3 ) {
recompute();
error = "too many sections";
return true;
}
enum Target {
HOURS,
MINUTES,
SECONDS,
SUBSECONDS,
};
// setup target before parsing
Target target;
uint64_t* tvalue;
switch( nsect ) {
default:
case 0:
target = SUBSECONDS;
tvalue = &_subseconds;
break;
case 1:
target = SECONDS;
tvalue = &_seconds;
break;
case 2:
target = MINUTES;
tvalue = &_minutes;
break;
case 3:
target = HOURS;
tvalue = &_hours;
break;
}
istringstream convert;
string tbuffer;
for( string::size_type i = 0; i < max; i++ ) {
const char c = time[i];
switch( c ) {
case ':':
switch( target ) {
case HOURS:
convert.clear();
convert.str( tbuffer );
if( !tbuffer.empty() && !(convert >> *tvalue) ) {
error = "failed to convert integer";
return true;
}
tbuffer.clear();
target = MINUTES;
tvalue = &_minutes;
break;
case MINUTES:
convert.clear();
convert.str( tbuffer );
if( !tbuffer.empty() && !(convert >> *tvalue) ) {
error = "failed to convert integer";
return true;
}
tbuffer.clear();
target = SECONDS;
tvalue = &_seconds;
break;
case SECONDS:
convert.clear();
convert.str( tbuffer );
if( !tbuffer.empty() && !(convert >> *tvalue) ) {
error = "failed to convert integer";
return true;
}
tbuffer.clear();
target = SUBSECONDS;
tvalue = &_subseconds;
break;
default:
case SUBSECONDS:
error = "unexpected char ':'";
return true;
}
break;
case '.':
{
if( target != SECONDS ) {
error = "unexpected char '.'";
return true;
}
_format = DECIMAL;
convert.clear();
convert.str( tbuffer );
if( !tbuffer.empty() && !(convert >> *tvalue) ) {
error = "failed to convert integer";
return true;
}
tbuffer.clear();
target = SUBSECONDS;
tvalue = &_subseconds;
break;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
tbuffer += c;
if( tbuffer.length() > 16 ) {
error = "overflow";
return true;
}
break;
default:
error = "unexpected char '";
error += c;
error += "'";
return true;
}
}
// apply final section
if( !tbuffer.empty() ) {
convert.clear();
convert.str( tbuffer );
if( !tbuffer.empty() && !(convert >> *tvalue) ) {
error = "failed to convert integer";
return true;
}
}
// special post processing
switch( _format ) {
case FRAME:
default:
break;
case DECIMAL:
{
double div = std::pow( 10.0, static_cast<double>(tbuffer.length()) );
if( div < 1.0 )
div = 1.0;
*tvalue = static_cast<uint64_t>( static_cast<double>(*tvalue) / div * std::ceil( _scale ));
break;
}
}
recompute();
return false;
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::recompute()
{
// case: 29.97 becomes 30.0
// case: 30.0 becomes 30.0
const uint64_t iscale = uint64_t( std::ceil( _scale ));
if( _subseconds > iscale - 1 ) {
uint64_t n = _subseconds / iscale;
_seconds += n;
_subseconds -= n * iscale;
}
if( _seconds > 59 ) {
uint64_t n = _seconds / 60;
_minutes += n;
_seconds -= n * 60;
}
if( _minutes > 59 ) {
uint64_t n = _minutes / 60;
_hours += n;
_minutes -= n * 60;
}
_duration = _subseconds + (iscale * _seconds) + (iscale * _minutes * 60) + (iscale * _hours * 3600);
ostringstream oss;
oss << std::setfill('0') << right << std::setw(2) << _hours << ':'
<< std::setw(2) << _minutes << ':' << std::setw(2) << _seconds;
switch( _format ) {
case FRAME:
oss << ':' << std::setw(2) << std::setfill('0') << _subseconds;
break;
case DECIMAL:
{
oss << '.' << std::setw(3) << std::setfill('0')
<< static_cast<uint64_t>(_subseconds / _scale * 1000.0 + 0.5);
break;
}
}
_svalue = oss.str();
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::reset()
{
setDuration( 0 );
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::setDuration( uint64_t duration_, double scale_ )
{
if( scale_ != 0.0 ) {
_scale = scale_;
if( _scale < 1.0 )
_scale = 1.0;
}
_duration = duration_;
const uint64_t iscale = uint64_t( std::ceil( _scale ));
uint64_t i = _duration;
_hours = i / (iscale * 3600);
i -= (iscale * 3600 * _hours);
_minutes = i / (iscale * 60);
i -= (iscale * 60 * _minutes);
_seconds = i / iscale;
i -= (iscale * _seconds);
_subseconds = i;
recompute();
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::setFormat( Format format_ )
{
_format = format_;
recompute();
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::setHours( uint64_t hours_ )
{
_hours = hours_;
recompute();
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::setMinutes( uint64_t minutes_ )
{
_minutes = minutes_;
recompute();
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::setScale( double scale_ )
{
const double oldscale = _scale;
_scale = scale_;
if( _scale < 1.0 )
_scale = 1.0;
_subseconds = static_cast<uint64_t>( (_scale / oldscale) * _subseconds );
recompute();
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::setSeconds( uint64_t seconds_ )
{
_seconds = seconds_;
recompute();
}
///////////////////////////////////////////////////////////////////////////////
void
Timecode::setSubseconds( uint64_t subseconds_ )
{
_subseconds = subseconds_;
recompute();
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace mp4v2::util