// **************************************************************************** // // CMidiInQ.cpp // // Implementation file for the CMidiInQ class. // Use a simple fixed size queue for managing MIDI data. // Fill & drain pointers are maintained automatically whenever // an Add or Get function succeeds. // // Set editor tabs to 3 for your viewing pleasure. // // ---------------------------------------------------------------------------- // // This file is part of Echo Digital Audio's generic driver library. // Copyright Echo Digital Audio Corporation (c) 1998 - 2005 // All rights reserved // www.echoaudio.com // // This library 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 2.1 of the License, or (at your option) any later version. // // This library 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 this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // **************************************************************************** #include "CEchoGals.h" /**************************************************************************** Construction and destruction, clean up and init ****************************************************************************/ //============================================================================ // // Construction & destructor // //============================================================================ CMidiInQ::CMidiInQ() { m_pBuffer = NULL; m_ullLastActivityTime = 0; m_wMtcState = MIDI_IN_STATE_NORMAL; m_pEG = NULL; m_pMtcSync = NULL; } // CMidiInQ::CMidiInQ() CMidiInQ::~CMidiInQ() { Cleanup(); } // CMidiInQ::~CMidiInQ() //============================================================================ // // Init // //============================================================================ ECHOSTATUS CMidiInQ::Init( CEchoGals *pEG ) { ECHO_DEBUGPRINTF(("CMidiInQ::Init\n")); m_pEG = pEG; m_dwFill = 0; m_dwBufferSizeMask = MIDI_IN_Q_SIZE - 1; // MIDI_IN_Q_SIZE must be a power of 2 return ECHOSTATUS_OK; } // Init //============================================================================ // // Cleanup // //============================================================================ void CMidiInQ::Cleanup() { // // Free the MIDI input buffer // if (m_pBuffer) { OsFreeNonPaged( m_pBuffer ); m_pBuffer = NULL; } // // Free the MTC sync object if it exists // if (m_pMtcSync) { delete m_pMtcSync; m_pMtcSync = NULL; } } /**************************************************************************** Queue management - add and remove MIDI data ****************************************************************************/ //============================================================================ // // GetMidi - get oldest MIDI input byte from the Q // //============================================================================ ECHOSTATUS CMidiInQ::GetMidi ( ECHOGALS_MIDI_IN_CONTEXT *pContext, DWORD &dwMidiByte, LONGLONG &llTimestamp ) { DWORD dwDrain; if (NULL == m_pBuffer) return ECHOSTATUS_CHANNEL_NOT_OPEN; dwDrain = pContext->dwDrain; if ( m_dwFill == dwDrain) return ECHOSTATUS_NO_DATA; dwMidiByte = m_pBuffer[ dwDrain ].dwMidi; llTimestamp = m_pBuffer[ dwDrain ].llTimestamp; //ECHO_DEBUGPRINTF( ("CMidiInQ::GetMidi 0x%lx\n", dwMidiByte) ); dwDrain++; dwDrain &= m_dwBufferSizeMask; pContext->dwDrain = dwDrain; return ECHOSTATUS_OK; } // ECHOSTATUS CMidiInQ::GetMidi //============================================================================ // // AddMidi - add new MIDI input byte to the Q // //============================================================================ ECHOSTATUS CMidiInQ::AddMidi ( DWORD dwMidiByte, LONGLONG llTimestamp ) { DWORD dwFill; //ECHO_DEBUGPRINTF( ("CMidiInQ::AddMidi 0x%lx\n", dwMidiByte) ); dwFill = m_dwFill; m_pBuffer[ dwFill ].dwMidi = dwMidiByte; m_pBuffer[ dwFill ].llTimestamp = llTimestamp; dwFill++; dwFill &= m_dwBufferSizeMask; m_dwFill = dwFill; return ECHOSTATUS_OK; } // ECHOSTATUS CMidiInQ::AddMidi //============================================================================ // // Reset // //============================================================================ void CMidiInQ::Reset(ECHOGALS_MIDI_IN_CONTEXT *pContext) { pContext->dwDrain = m_dwFill; } // void CMidiInQ::Reset() /**************************************************************************** Arm and disarm ****************************************************************************/ //============================================================================ // // Arm - resets the Q and enables the Q to start receiving MIDI input data // //============================================================================ ECHOSTATUS CMidiInQ::Arm(ECHOGALS_MIDI_IN_CONTEXT *pContext) { ECHOSTATUS Status; pContext->fOpen = FALSE; // // Return if there is no Echogals pointer // if (NULL == m_pEG) { return ECHOSTATUS_CANT_OPEN; } //------------------------------------------------------------------------- // // Set up the MIDI input buffer // //------------------------------------------------------------------------- if (NULL == m_pBuffer) { // // Reset the buffer pointers // m_dwFill = 0; // // Allocate // Status = OsAllocateNonPaged( MIDI_IN_Q_SIZE * sizeof(MIDI_DATA), (PPVOID) &m_pBuffer); if (Status != ECHOSTATUS_OK) { ECHO_DEBUGPRINTF(("CMidiInQ::Arm - Could not allocate MIDI input buffer\n")); return Status; } } Reset(pContext); m_dwNumClients++; //------------------------------------------------------------------------- // // Enable MIDI input // //------------------------------------------------------------------------- m_pEG->GetDspCommObject()->SetMidiOn( TRUE ); pContext->fOpen = TRUE; return ECHOSTATUS_OK; } // Arm //============================================================================ // // Disarm - surprisingly, does the opposite of Arm // //============================================================================ ECHOSTATUS CMidiInQ::Disarm(ECHOGALS_MIDI_IN_CONTEXT *pContext) { // // Did this client open the MIDI input? // if (FALSE == pContext->fOpen) { ECHO_DEBUGPRINTF(("CMidiInQ::Disarm - trying to disarm with client that isn't open\n")); return ECHOSTATUS_CHANNEL_NOT_OPEN; } pContext->fOpen = FALSE; // // Last client? // if (0 == m_dwNumClients) return ECHOSTATUS_OK; m_dwNumClients--; if (0 == m_dwNumClients) { // // Tell the DSP to disable MIDI input // if (m_pEG) m_pEG->GetDspCommObject()->SetMidiOn( FALSE ); // // Free the MIDI input buffer // if (m_pBuffer) { OsFreeNonPaged( m_pBuffer ); m_pBuffer = NULL; } } return ECHOSTATUS_OK; } // Disarm //============================================================================ // // ArmMtcSync - turns on MIDI time code sync // //============================================================================ ECHOSTATUS CMidiInQ::ArmMtcSync() { if (NULL == m_pEG) return ECHOSTATUS_DSP_DEAD; if (NULL != m_pMtcSync) return ECHOSTATUS_OK; // // Create the MTC sync object // m_pMtcSync = new CMtcSync( m_pEG ); if (NULL == m_pMtcSync) return ECHOSTATUS_NO_MEM; // // Tell the DSP to enable MIDI input // m_pEG->GetDspCommObject()->SetMidiOn( TRUE ); return ECHOSTATUS_OK; } // ArmMtcSync //============================================================================ // // DisarmMtcSync - turn off MIDI time code sync // //============================================================================ ECHOSTATUS CMidiInQ::DisarmMtcSync() { if (NULL == m_pMtcSync) return ECHOSTATUS_OK; if (NULL == m_pEG) return ECHOSTATUS_DSP_DEAD; // // Tell the DSP to disable MIDI input // m_pEG->GetDspCommObject()->SetMidiOn( FALSE ); // // Free m_pMtcSync // CMtcSync *pTemp; // Use temp variable to avoid killing the object // while the ISR is using it pTemp = m_pMtcSync; m_pMtcSync = NULL; delete pTemp; return ECHOSTATUS_OK; } // DisarmMtcSync /**************************************************************************** Detect MIDI input activity - see if the driver has recently received any MIDI input ****************************************************************************/ BOOL CMidiInQ::IsActive() { ULONGLONG ullCurTime,ullDelta; // // See if anything has happened recently // m_pEG->m_pOsSupport->OsGetSystemTime( &ullCurTime ); ullDelta = ullCurTime - m_ullLastActivityTime; if (ullDelta > MIDI_ACTIVITY_TIMEOUT_USEC) return FALSE; return TRUE; } // IsActive /**************************************************************************** MIDI time code ****************************************************************************/ //=========================================================================== // // Get and set the base MTC sample rate // //=========================================================================== ECHOSTATUS CMidiInQ::GetMtcBaseRate(DWORD *pdwBaseRate) { ECHOSTATUS Status; if (m_pMtcSync) { *pdwBaseRate = m_pMtcSync->m_dwBaseSampleRate; Status = ECHOSTATUS_OK; } else { *pdwBaseRate = 0; Status = ECHOSTATUS_NO_DATA; } return Status; } // GetMtcBaseRate ECHOSTATUS CMidiInQ::SetMtcBaseRate(DWORD dwBaseRate) { ECHOSTATUS Status; if (m_pMtcSync) { m_pMtcSync->m_dwBaseSampleRate = dwBaseRate; Status = ECHOSTATUS_OK; } else { Status = ECHOSTATUS_NO_DATA; } return Status; } // SetMtcBaseRate //=========================================================================== // // Run the state machine for MIDI input data // // You need this state machine to parse the incoming // MIDI data stream. Every time the DSP sees a 0xF1 byte come in, // it adds the DSP sample position to the MIDI data stream. // The DSP sample position is represented as a 32 bit unsigned // value, with the high 16 bits first, followed by the low 16 bits. // // The following logic parses the incoming MIDI data. // //=========================================================================== DWORD CMidiInQ::MtcProcessData( DWORD dwMidiData ) { DWORD dwRval; dwRval = 0; switch ( m_wMtcState ) { case MIDI_IN_STATE_NORMAL : if ( dwMidiData == 0xF1L ) { m_wMtcState = MIDI_IN_STATE_TS_HIGH; } break; case MIDI_IN_STATE_TS_HIGH : if (m_pMtcSync) m_pMtcSync->StoreTimestampHigh( dwMidiData ); m_wMtcState = MIDI_IN_STATE_TS_LOW; dwRval = MIDI_IN_SKIP_DATA; break; case MIDI_IN_STATE_TS_LOW : if (m_pMtcSync) m_pMtcSync->StoreTimestampLow( dwMidiData ); m_wMtcState = MIDI_IN_STATE_F1_DATA; dwRval = MIDI_IN_SKIP_DATA; break; case MIDI_IN_STATE_F1_DATA : if (m_pMtcSync) m_pMtcSync->StoreMtcData( dwMidiData ); m_wMtcState = MIDI_IN_STATE_NORMAL; break; } return dwRval; } // DWORD CMidiInQ::MtcProcessData //=========================================================================== // // ServiceMtcSync // //=========================================================================== void CMidiInQ::ServiceMtcSync() { if (m_pMtcSync) m_pMtcSync->Sync(); } // ServiceMtcSync /**************************************************************************** Interrupt service ****************************************************************************/ ECHOSTATUS CMidiInQ::ServiceIrq() { DWORD dwMidiCount; WORD wIndex; ECHOSTATUS Status; CDspCommObject *pDCO; LONGLONG llTimestamp; // // Store the time for the activity detector // m_pEG->m_pOsSupport->OsGetSystemTime( &m_ullLastActivityTime ); // // Get the MIDI count // pDCO = m_pEG->GetDspCommObject(); pDCO->ReadMidi( 0, dwMidiCount ); // The count is at index 0 #ifdef ECHO_DEBUG //ECHO_DEBUGPRINTF( ("\tMIDI interrupt (%ld MIDI bytes)\n", dwMidiCount) ); if ( dwMidiCount == 0 ) { ECHO_DEBUGBREAK(); } #endif // // Get the timestamp // llTimestamp = m_pEG->m_pOsSupport->GetMidiInTimestamp(); // // Get the MIDI data from the comm page // wIndex = 1; // First MIDI byte is at index 1 while ( dwMidiCount-- > 0 ) { DWORD dwMidiByte; // // Get the MIDI byte // Status = pDCO->ReadMidi( wIndex++, dwMidiByte ); if ( ECHOSTATUS_OK != Status ) { ECHO_DEBUGPRINTF(("Failed on ReadMidi\n")); ECHO_DEBUGBREAK(); // should never happen... break; } // // Parse the incoming MIDI stream. The incoming MIDI data consists // of MIDI bytes and timestamps for the MIDI time code 0xF1 bytes. // MtcProcessData is a little state machine that parses the stream. // // If you get MIDI_IN_SKIP_DATA back, then this is a timestamp byte, // not a MIDI byte, so don't store it in the MIDI input buffer. // if ( MIDI_IN_SKIP_DATA == MtcProcessData( dwMidiByte ) ) continue; // // Only store the MIDI data if there is at least one // client // if (0 != m_dwNumClients) { // // Stash the MIDI data and check for overflow // if ( ECHOSTATUS_BUFFER_OVERFLOW == AddMidi( dwMidiByte, llTimestamp ) ) { break; } } } // while there is more MIDI data to read return ECHOSTATUS_OK; } // ServiceIrq // *** CMidiInQ.cpp ***
