smpte.h

Go to the documentation of this file.

/*
 *   NiCMidi - A C++ Class Library for MIDI
 *
 *   Copyright (C) 2004  J.D. Koftinoff Software, Ltd.
 *   www.jdkoftinoff.com jeffk@jdkoftinoff.com
 *   Copyright (C) 2010 V.R.Madgazin
 *   www.vmgames.com vrm@vmgames.com
 *   Copyright (C) 2021, 2022  Nicola Cassetta
 *   https://github.com/ncassetta/NiCMidi
 *
 *   This file is part of NiCMidi
 *
 *   NiCMidi is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation, either version 3 of
 *   the License, or (at your option) any later version.
 *
 *   NiCMidi is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with NiCMidi. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 
#ifndef _NICMIDI_SMPTE_H
#define _NICMIDI_SMPTE_H
 
 
 
enum SMPTE_RATE {
    SMPTE_RATE_24 = 0,          
    SMPTE_RATE_25,              
    SMPTE_RATE_2997,            
    SMPTE_RATE_2997DF,          
    SMPTE_RATE_30,              
    SMPTE_RATE_30DF             
};
 
 
enum SAMPLE_RATE {
    SAMPLE_32000 = 0,           
    SAMPLE_44056,               
    SAMPLE_44100,               
    SAMPLE_47952,               
    SAMPLE_48000,               
    SAMPLE_48048                
};
 
 
class  SMPTE {
    public:
 
                            SMPTE (SMPTE_RATE smpte_rate = SMPTE_RATE_30,
                                   SAMPLE_RATE sample_rate = SAMPLE_48000);
        void                SetSMPTERate (SMPTE_RATE r)     { smpte_rate = r; sample_number_dirty = true; }
        SMPTE_RATE          GetSMPTERate() const            { return smpte_rate; }
        void                SetSampleRate (SAMPLE_RATE r)   { sample_rate = r; sample_number_dirty = true; }
 
        SAMPLE_RATE         GetSampleRate() const           { return sample_rate; }
 
        /* NEW */
        void                SetOffset (unsigned long n)     { sample_offset = n; }
        void                SetOffset (unsigned char h, unsigned char m, unsigned char s,
                                       unsigned char f = 0, unsigned char sf = 0);
        unsigned long       GetOffset () const              { return sample_offset; }
        /* end NEW */
 
        unsigned long       GetSampleNumber();
        void                SetSampleNumber (unsigned long n)
                                                            { sample_number = n; sample_number_dirty = true; }
        unsigned long       GetMilliSeconds ();
        void                SetMilliSeconds (unsigned long msecs);
 
 
        unsigned char       GetHours();             // TODO: is this right? perhaps hours could be an int
        unsigned char       GetMinutes();
        unsigned char       GetSeconds();
        unsigned char       GetFrames();
        unsigned char       GetSubFrames();
 
 
        void                SetTime (unsigned char h, unsigned char m, unsigned char s,
                                     unsigned char f = 0, unsigned char sf = 0);
        void                SetHours (unsigned char h)      { hours = h; sample_number_dirty = true; }
        void                SetMinutes (unsigned char m)    { minutes = m; sample_number_dirty = true; }
        void                SetSeconds (unsigned char s)    { seconds = s; sample_number_dirty = true; }
        void                SetFrames (unsigned char f)     { frames = f; sample_number_dirty = true; }
        void                SetSubFrames (unsigned char sf) { sub_frames = sf; sample_number_dirty = true; }
 
 
        void                AddSamples (long n);
        void                IncSamples()                    { AddSamples (1); }
        void                DecSamples()                    { AddSamples (-1); }
 
 
        void                AddHours (signed char h);
        void                AddMinutes (signed char m);
        void                AddSeconds (signed char s);
        void                AddFrames (signed char f);
        void                AddSubFrames (signed char sf);
        void                IncHours()                      { AddHours (1); }
        void                IncMinutes()                    { AddMinutes (1); }
        void                IncSeconds()                    { AddSeconds (1); }
        void                IncFrames()                     { AddFrames (1); }
        void                IncSubFrames()                  { AddSubFrames (1); }
        void                DecHours()                      { AddHours (-1); }
        void                DecMinutes()                    { AddMinutes (-1); }
        void                DecSeconds()                    { AddSeconds (-1); }
        void                DecFrames()                     { AddFrames (-1); }
        void                DecSubFrames()                  { AddSubFrames (-1); }
 
 
        bool                operator== (SMPTE &s)           { return Compare (s) == 0; }
        bool                operator!= (SMPTE &s)           { return Compare (s) != 0; }
        bool                operator< (SMPTE &s)            { return Compare (s) < 0; }
        bool                operator> (SMPTE &s)            { return Compare (s) > 0; }
        bool                operator<= (SMPTE &s)           { return Compare (s) <= 0; }
        bool                operator>= (SMPTE &s)           { return Compare (s) >= 0; }
        /* These were eliminated: what should return if SMPTE rates are not equal?
        SMPTE&          operator+= (SMPTE &s)           { SetSampleNumber (sample_number + s.GetSampleNumber()); return *this; }
        SMPTE&          operator-= (SMPTE &s)           { SetSampleNumber (sample_number - s.GetSampleNumber()); return *this; }
        SMPTE&          operator+ (SMPTE &s);
        SMPTE&          operator- (SMPTE &s);
        */
 
    protected:
        void                SampleToTime();
        void                TimeToSample();
        int                 Compare (SMPTE &s);
 
        // Max frames for every SMPTE_RATE.
        static const unsigned char  smpte_max_frames[];
        // Converts the SMPTE_RATE enum to a double frequency.
        static const double         smpte_rates[];
        // Converts the SMPTE_RATE enum to a long frequency times 100.
        static const long           smpte_rates_long[];
        // Converts the SAMPLE_RATE enum to a double frequency.
        static const double         sample_rates[];
        // Converts the SAMPLE_RATE enum to a long frequency times 10.
        static const long           sample_rates_long[];
 
    private:
        SMPTE_RATE          smpte_rate;         // The SMPTE rate
        SAMPLE_RATE         sample_rate;        // The sample rate
        unsigned long       sample_number;      // The sample number
    /* NEW */
        unsigned long       sample_offset;      // The initial time offset
 
        unsigned char       hours;              // SMPTE hours
        unsigned char       minutes;            // SMPTE minutes
        unsigned char       seconds;            // SMPTE seconds
        unsigned char       frames;             // SMPTE frames
        unsigned char       sub_frames;         // SMPTE subframes
        bool                sample_number_dirty;// True if we must perform a conversion
 
/* These were eliminated: what if SMPTE rates are not equal?
        friend SMPTE operator + ( SMPTE a, SMPTE b );
        friend SMPTE operator - ( SMPTE a, SMPTE b );
*/
};
 
 
#endif