Sample.h

Go to the documentation of this file.

/*
 * Hydrogen
 * Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
 * Copyright(c) 2008-2025 The hydrogen development team [hydrogen-devel@lists.sourceforge.net]
 *
 * http://www.hydrogen-music.org
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see https://www.gnu.org/licenses
 *
 */
 
#ifndef H2C_SAMPLE_H
#define H2C_SAMPLE_H
 
#include <memory>
#include <vector>
#include <sndfile.h>
 
#include <core/License.h>
#include <core/Object.h>
 
namespace H2Core
{


class EnvelopePoint : public H2Core::Object<EnvelopePoint>
{
                H2_OBJECT(EnvelopePoint)
        public:
                int frame;  
                int value;  
                struct Comparator {
                        bool operator()( const EnvelopePoint& a, const EnvelopePoint& b )
                        {
                                return a.frame < b.frame;
                        }
                };

                EnvelopePoint();
                EnvelopePoint( int f, int v );
                EnvelopePoint( const EnvelopePoint& other );
};
 
class Sample : public H2Core::Object<Sample>
{
                H2_OBJECT(Sample)
        public:

                using PanEnvelope = std::vector<EnvelopePoint>;
                using VelocityEnvelope = std::vector<EnvelopePoint>;
        class Loops
                {
                        public:
                                enum LoopMode {
                                        FORWARD=0,
                                        REVERSE,
                                        PINGPONG
                                };
                                int start_frame;        
                                int loop_frame;         
                                int end_frame;          
                                int count;              
                                LoopMode mode;          
                                Loops() : start_frame( 0 ), loop_frame( 0 ), end_frame( 0 ), count( 0 ), mode( FORWARD ) { };
                                Loops( const Loops* other ) :
                                        start_frame( other->start_frame ),
                                        loop_frame( other->loop_frame ),
                                        end_frame( other->end_frame ),
                                        count( other->count ),
                                        mode( other->mode ) { };

                                bool operator ==( const Loops& b ) const
                                {
                                        return ( start_frame==b.start_frame && loop_frame==b.loop_frame && end_frame==b.end_frame && count==b.count && mode==b.mode );
                                }
                                QString toQString( const QString& sPrefix = "", bool bShort = true ) const;
                };

        class Rubberband
                {
                        public:
                                bool use;               
                                float divider;          
                                float pitch;            
                                int c_settings;        
                                Rubberband() : use( false ), divider ( 1.0 ), pitch( 1.0 ), c_settings( 4 ) { };
                                Rubberband( const Rubberband* other ) :
                                        use( other->use ),
                                        divider ( other->divider ),
                                        c_settings( other->c_settings ),
                                        pitch( other->pitch ) { };

                                bool operator ==( const Rubberband& b ) const
                                {
                                        return ( use==b.use && divider==b.divider && c_settings==b.c_settings && pitch==b.pitch );
                                }
                                QString toQString( const QString& sPrefix = "", bool bShort = true ) const;
                };
 
        static QString sndfileFormatToQString( int nFormat );

                Sample( const QString& filepath, const License& license = License(), int frames=0, int sample_rate=0, float* data_l=nullptr, float* data_r=nullptr );
                Sample( std::shared_ptr<Sample> other );
                ~Sample();
 

                bool write( const QString& path, int format= ( SF_FORMAT_WAV|SF_FORMAT_PCM_16 ) );
        
        static std::shared_ptr<Sample> load( const QString& filepath, const License& license = License() );

                bool load( float fBpm = 120 );
                void unload();

                bool is_empty() const;
                QString get_filepath() const;
                const QString get_raw_filepath() const;
                const QString get_filename() const;
                void set_filename( const QString& filename );
                void set_filepath( const QString& sFilepath );
                void set_frames( int value );
                int get_frames() const;
                void set_sample_rate( const int sampleRate );
                int get_sample_rate() const;
                double get_sample_duration( ) const;
        
                int get_size() const;
                float* get_data_l() const;
                float* get_data_r() const;
                void set_is_modified( bool value );
                bool get_is_modified() const;
                PanEnvelope* get_pan_envelope();
                VelocityEnvelope* get_velocity_envelope();
                Loops get_loops() const;
                Rubberband get_rubberband() const;
        void set_pan_envelope( PanEnvelope envelope );
        void set_velocity_envelope( VelocityEnvelope envelope );
        void set_loops( Loops loops );
        void set_rubberband( Rubberband rubberband );
 
        License getLicense() const;
        void setLicense( const License& license );
        
                static Loops::LoopMode parse_loop_mode( const QString& string );
                QString get_loop_mode_string() const;
                QString toQString( const QString& sPrefix = "", bool bShort = true ) const override;
        private:
                bool apply_loops();
                void apply_velocity();
                void apply_pan();
                void apply_rubberband( float fBpm );
                bool exec_rubberband_cli( float fBpm );
        
                QString                         __filepath;          
                int                                     __frames;            
                int                                     __sample_rate;       
                float*                          __data_l;            
                float*                          __data_r;            
                bool                            __is_modified;       
                PanEnvelope                  __pan_envelope;      
                VelocityEnvelope        __velocity_envelope; 
                Loops                              __loops;             
                Rubberband                    __rubberband;        
                static const std::vector<QString> __loop_modes;

        License m_license;
};
 
// DEFINITIONS
 
inline void Sample::unload()
{
        if ( __data_l != nullptr ) {
                delete [] __data_l;
        }
        
        if ( __data_r != nullptr ) {
                delete [] __data_r;
        }
        __frames = __sample_rate = 0;
 
        __data_l = __data_r = nullptr;
}
 
inline bool Sample::is_empty() const
{
        return ( __data_l == 0 && __data_r == 0 );
}
 
inline const QString Sample::get_raw_filepath() const
{
        return __filepath;
}
 
inline void Sample::set_filepath( const QString& sFilepath )
{
        __filepath = sFilepath;
}
 
inline const QString Sample::get_filename() const
{
        return __filepath.section( "/", -1 );
}
 
inline void Sample::set_frames( int frames )
{
        __frames = frames;
}
 
inline int Sample::get_frames() const
{
        return __frames;
}
 
inline int Sample::get_sample_rate() const
{
        return __sample_rate;
}
 
inline void Sample::set_sample_rate( const int sampleRate )
{
        __sample_rate = sampleRate;
}
 
inline double Sample::get_sample_duration() const
{
        return static_cast<double>(__frames) / static_cast<double>(__sample_rate);
}
 
inline int Sample::get_size() const
{
        return __frames * sizeof( float ) * 2;
}
 
inline float* Sample::get_data_l() const
{
        return __data_l;
}
 
inline float* Sample::get_data_r() const
{
        return __data_r;
}
 
inline void Sample::set_is_modified( bool is_modified )
{
        __is_modified = is_modified;
}
 
inline bool Sample::get_is_modified() const
{
        return __is_modified;
}
 
inline QString Sample::get_loop_mode_string() const
{
        return __loop_modes.at(__loops.mode);
}
 
inline Sample::PanEnvelope* Sample::get_pan_envelope()
{
        return &__pan_envelope;
}
 
inline Sample::VelocityEnvelope* Sample::get_velocity_envelope()
{
        return &__velocity_envelope;
}
 
inline Sample::Loops Sample::get_loops() const
{
        return __loops;
}
 
inline Sample::Rubberband Sample::get_rubberband() const
{
        return __rubberband;
}
inline void Sample::set_pan_envelope( PanEnvelope envelope ) {
        __pan_envelope = envelope;
}
inline void Sample::set_velocity_envelope( VelocityEnvelope envelope ) {
        __velocity_envelope = envelope;
}
inline void Sample::set_loops( Loops loops ) {
        __loops = loops;
}
inline void Sample::set_rubberband( Rubberband rubberband ) {
        __rubberband = rubberband;
}
 
inline License Sample::getLicense() const {
        return m_license;
}
inline void Sample::setLicense( const License& license ) {
        m_license = license;
}
 
};
 
#endif // H2C_SAMPLE_H
 
/* vim: set softtabstop=4 noexpandtab: */