Changeset 1569

Show
Ignore:
Timestamp:
02/26/10 21:54:51 (3 years ago)
Author:
wolke
Message:

fix the export audio file length bug

Location:
branches/0.9.4
Files:
5 modified

Legend:

Unmodified
Added
Removed
  • branches/0.9.4/gui/src/ExportSongDialog.cpp

    r1236 r1569  
    108108        QString filename = exportNameTxt->text(); 
    109109        m_bExporting = true; 
    110         Hydrogen::get_instance()->startExportSong( filename ); 
     110        Hydrogen::get_instance()->startExportSong( filename , 44100, 16 ); 
    111111} 
    112112 
     
    140140                //INFOLOG("SONO A 100"); 
    141141                 
    142                 Hydrogen::get_instance()->stopExportSong(); 
     142                //Hydrogen::get_instance()->stopExportSong(); 
    143143                m_bExporting = false; 
    144144                QFile check( exportNameTxt->text() ); 
     
    146146                        QMessageBox::information( this, "Hydrogen", trUtf8("Export failed!") ); 
    147147                } 
    148                 accept(); 
    149148        } 
    150149} 
  • branches/0.9.4/libs/hydrogen/include/hydrogen/hydrogen.h

    r1236 r1569  
    114114        void restartDrivers(); 
    115115 
    116         void startExportSong( const QString& filename ); 
     116        void startExportSong( const QString& filename, int rate, int depth ); 
    117117        void stopExportSong(); 
    118118 
  • branches/0.9.4/libs/hydrogen/src/IO/DiskWriterDriver.h

    r127 r1569  
    4141class DiskWriterDriver : public AudioOutput 
    4242{ 
    43 public: 
    44         unsigned m_nSampleRate; 
    45         QString m_sFilename; 
    46         unsigned m_nBufferSize; 
    47         audioProcessCallback m_processCallback; 
    48         float* m_pOut_L; 
    49         float* m_pOut_R; 
     43        public: 
    5044 
    51         DiskWriterDriver( audioProcessCallback processCallback, unsigned nSamplerate, const QString& sFilename ); 
    52         ~DiskWriterDriver(); 
    53  
    54         int init( unsigned nBufferSize ); 
    55  
    56         int connect(); 
    57         void disconnect(); 
    58  
    59         void write( float* buffer_L, float* buffer_R, unsigned int bufferSize ); 
    60  
    61         unsigned getBufferSize() { 
    62                 return m_nBufferSize; 
    63         } 
    64  
    65         unsigned getSampleRate(); 
    66         float* getOut_L() { 
    67                 return m_pOut_L; 
    68         } 
    69         float* getOut_R() { 
    70                 return m_pOut_R; 
    71         } 
    72  
    73         virtual void play(); 
    74         virtual void stop(); 
    75         virtual void locate( unsigned long nFrame ); 
    76         virtual void updateTransportInfo(); 
    77         virtual void setBpm( float fBPM ); 
    78  
    79 private: 
     45                unsigned m_nSampleRate; 
     46                QString m_sFilename; 
     47                unsigned m_nBufferSize; 
     48                int m_nSampleDepth; 
     49                audioProcessCallback m_processCallback; 
     50                float* m_pOut_L; 
     51                float* m_pOut_R; 
     52         
     53                DiskWriterDriver( audioProcessCallback processCallback, unsigned nSamplerate, const QString& sFilename, int nSampleDepth ); 
     54                ~DiskWriterDriver(); 
     55         
     56                int init( unsigned nBufferSize ); 
     57         
     58                int connect(); 
     59                void disconnect(); 
     60         
     61                void write( float* buffer_L, float* buffer_R, unsigned int bufferSize ); 
     62         
     63                unsigned getBufferSize() { 
     64                        return m_nBufferSize; 
     65                } 
     66         
     67                unsigned getSampleRate(); 
     68                float* getOut_L() { 
     69                        return m_pOut_L; 
     70                } 
     71                float* getOut_R() { 
     72                        return m_pOut_R; 
     73                } 
     74         
     75                virtual void play(); 
     76                virtual void stop(); 
     77                virtual void locate( unsigned long nFrame ); 
     78                virtual void updateTransportInfo(); 
     79                virtual void setBpm( float fBPM ); 
     80         
     81        private: 
    8082 
    8183}; 
  • branches/0.9.4/libs/hydrogen/src/IO/disk_writer_driver.cpp

    r687 r1569  
    2525#include <hydrogen/event_queue.h> 
    2626#include <hydrogen/hydrogen.h> 
     27#include <hydrogen/Pattern.h> 
    2728 
    2829#include <pthread.h> 
     
    4142        // always rolling, no user interaction 
    4243        pDriver->m_transport.m_status = TransportInfo::ROLLING; 
    43  
    4444 
    4545        SF_INFO soundInfo; 
     
    4747//      soundInfo.frames = -1;//getNFrames();           ///\todo: da terminare 
    4848        soundInfo.channels = 2; 
    49         soundInfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16; 
     49        //default format = waf 16bit 
     50        int sfformat = 0x010000; 
     51        int bits = 0x0002; 
     52 
     53        soundInfo.format =  sfformat|bits; 
    5054 
    5155        if ( !sf_format_check( &soundInfo ) ) { 
     
    5458        } 
    5559 
    56         SNDFILE* m_file = sf_open( pDriver->m_sFilename.toAscii(), SFM_WRITE, &soundInfo ); 
     60 
     61        SNDFILE* m_file = sf_open( pDriver->m_sFilename.toLocal8Bit(), SFM_WRITE, &soundInfo ); 
    5762 
    5863        float *pData = new float[ pDriver->m_nBufferSize * 2 ]; // always stereo 
     
    6166        float *pData_R = pDriver->m_pOut_R; 
    6267 
    63         while ( pDriver->m_processCallback( pDriver->m_nBufferSize, NULL ) == 0 ) { 
    64                 // process... 
    65                 for ( unsigned i = 0; i < pDriver->m_nBufferSize; i++ ) { 
     68 
     69        //calculate exaxt song frames. 
     70        std::vector<PatternList*> *pPatternColumns = Hydrogen::get_instance()->getSong()->get_pattern_group_vector(); 
     71        int nColumns = pPatternColumns->size(); 
     72 
     73        int nPatternSize; 
     74        int nSongSize = 0; 
     75        for ( int i = 0; i < nColumns; ++i ) { 
     76                PatternList *pColumn = ( *pPatternColumns )[ i ]; 
     77                if ( pColumn->get_size() != 0 ) { 
     78                        nPatternSize = pColumn->get( 0 )->get_length(); 
     79                } else { 
     80                        nPatternSize = MAX_NOTES; 
     81                } 
     82                nSongSize += nPatternSize; 
     83        } 
     84 
     85        float ticksize = pDriver->m_nSampleRate * 60.0 /  Hydrogen::get_instance()->getSong()->__bpm / 192 *4; 
     86        unsigned songLengthinFrames = ticksize * nSongSize;  
     87 
     88        unsigned frameNumber = 0; 
     89        int lastRun = 0; 
     90        while ( frameNumber < songLengthinFrames ) { 
     91 
     92                int usedBuffer = pDriver->m_nBufferSize; 
     93 
     94                if( songLengthinFrames - frameNumber <  pDriver->m_nBufferSize ){ 
     95                        lastRun = songLengthinFrames - frameNumber; 
     96                        usedBuffer = lastRun; 
     97                }; 
     98 
     99                frameNumber += usedBuffer; 
     100                int ret = pDriver->m_processCallback( usedBuffer, NULL ); 
     101 
     102                for ( unsigned i = 0; i < usedBuffer; i++ ) { 
    66103                        if(pData_L[i] > 1){ 
    67104                                pData[i * 2] = 1; 
     
    84121                        } 
    85122                } 
    86                 int res = sf_writef_float( m_file, pData, pDriver->m_nBufferSize ); 
    87                 if ( res != ( int )pDriver->m_nBufferSize ) { 
     123                int res = sf_writef_float( m_file, pData, usedBuffer ); 
     124                if ( res != ( int )usedBuffer ) { 
    88125                        _ERRORLOG( "Error during sf_write_float" ); 
    89126                } 
    90127 
    91                 if ( ( pDriver->m_transport.m_nFrames % 65536 ) == 0 ) { 
    92                         int nPatterns = Hydrogen::get_instance()->getSong()->get_pattern_group_vector()->size(); 
    93                         int nCurrentPatternPos = Hydrogen::get_instance()->getPatternPos(); 
    94                         assert( nCurrentPatternPos != -1 ); 
    95  
    96                         float fPercent = ( float ) nCurrentPatternPos / ( float )nPatterns * 100.0; 
    97                         EventQueue::get_instance()->push_event( EVENT_PROGRESS, ( int )fPercent ); 
    98                         _INFOLOG( QString( "DiskWriterDriver: %1%, transport frames:%2" ).arg( fPercent ).arg( pDriver->m_transport.m_nFrames ) ); 
    99                 } 
     128                float fPercent = ( float ) frameNumber / ( float )songLengthinFrames * 100.0; 
     129                EventQueue::get_instance()->push_event( EVENT_PROGRESS, ( int )fPercent ); 
     130//              frameNuber += lastrun; 
    100131        } 
    101         EventQueue::get_instance()->push_event( EVENT_PROGRESS, 100 ); 
    102132 
    103133        delete[] pData; 
     
    109139 
    110140        pthread_exit( NULL ); 
     141 
     142//      Hydrogen::get_instance()->stopExportSong(); 
    111143        return NULL; 
    112144} 
     
    115147 
    116148 
    117 DiskWriterDriver::DiskWriterDriver( audioProcessCallback processCallback, unsigned nSamplerate, const QString& sFilename ) 
     149DiskWriterDriver::DiskWriterDriver( audioProcessCallback processCallback, unsigned nSamplerate, const QString& sFilename, int nSampleDepth ) 
    118150                : AudioOutput( "DiskWriterDriver" ) 
    119151                , m_nSampleRate( nSamplerate ) 
    120152                , m_sFilename( sFilename ) 
     153                , m_nSampleDepth ( nSampleDepth ) 
    121154                , m_processCallback( processCallback ) 
    122155{ 
  • branches/0.9.4/libs/hydrogen/src/hydrogen.cpp

    r1284 r1569  
    21192119 
    21202120/// Export a song to a wav file, returns the elapsed time in mSec 
    2121 void Hydrogen::startExportSong( const QString& filename ) 
     2121void Hydrogen::startExportSong( const QString& filename, int rate, int depth ) 
    21222122{ 
    21232123        if ( getState() == STATE_PLAYING ) { 
    21242124                sequencer_stop(); 
    21252125        } 
     2126        AudioEngine::get_instance()->get_sampler()->stop_playing_notes(); 
    21262127        Preferences *pPref = Preferences::get_instance(); 
    21272128 
     
    21302131 
    21312132        m_pSong->set_mode( Song::SONG_MODE ); 
    2132         m_pSong->set_loop_enabled( false ); 
    2133         unsigned nSamplerate = m_pAudioDriver->getSampleRate(); 
    2134  
     2133        m_pSong->set_loop_enabled( true ); 
     2134//      unsigned nSamplerate = m_pAudioDriver->getSampleRate(); 
     2135        unsigned nSamplerate = (unsigned)rate; 
    21352136        // stop all audio drivers 
    21362137        audioEngine_stopAudioDrivers(); 
     
    21412142 
    21422143 
    2143         m_pAudioDriver = new DiskWriterDriver( audioEngine_process, nSamplerate, filename ); 
    2144  
    2145         AudioEngine::get_instance()->get_sampler()->stop_playing_notes(); 
    2146  
     2144        m_pAudioDriver = new DiskWriterDriver( audioEngine_process, nSamplerate, filename, depth); 
     2145 
     2146         
    21472147        // reset 
    21482148        m_pAudioDriver->m_transport.m_nFrames = 0;      // reset total frames 
     
    22042204        } 
    22052205} 
    2206  
    22072206 
    22082207