| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // 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 |
