void Synthesizer::setOffset(control_type_e control, float o)
{
if( ! config->enabled )
return;
switch( control )
{
case CT_PITCH:
{
float offset = o * config->semiRange;
int semis = (int) offset;
int cents = (int) (offset - semis) * 100;
float freqOffset = config->baseFreq;
if( semis < 0 )
{
semis *= -1;
cents *= -1;
if( semis > 0 ) freqOffset *= semif_minus[semis - 1];
if( cents > 0 ) freqOffset *= centf_minus[cents - 1];
}
else
{
if( semis > 0 ) freqOffset *= semif_plus[semis - 1];
if( cents > 0 ) freqOffset *= centf_plus[cents - 1];
}
updateFrequency();
break;
}
case CT_VOLUME:
{
break;
}
}
}
bool sdrServer::needPacket(mySocket *socket)
{
short *i, *q;
uint8_t *s;
int count = mSdrPlay.getSamplesPerPacket();
bool grChanged, rfChanged, fsChanged;
try {
if(mFrequencyChanged) updateFrequency();
if(mSamplerateChanged) updateSampleRate();
if(mGainChanged) updateGain();
if(mSdrPlay.readPacket(mI, mQ, &grChanged, &rfChanged, &fsChanged) == 0) {
for(i=mI, q=mQ, s=mS; i<mI+count; i++, q++) {
*(s++) = (uint8_t)((*i>>8)+128);
*(s++) = (uint8_t)((*q>>8)+128);
}
socket->send(mS, (size_t) count * 2);
}
}
catch(error *e) {
printf("%s\n", e->text());
return false;
}
return true;
}
void ratAnalyzer::compression0ToNon0()
{
if( _inCycle )
{
_frequencyNow = 60000.0 /
_startCompression.msecsTo( _currentData->time );
if( _frequencyNow > 10.0 && _frequencyNow < 300.0 )
{
_frequencyTotal = (_frequencyTotal*_frequencyCount + _frequencyNow)
/ (_frequencyCount + 1);
_frequencyCount++;
updateFrequency();
}
}
if( _currentData->compPosition != 0 && _currentData->compDepth > 1 )
{
_ppointOkay = false; // pressure for pp is too low on compDepth 1
}
if( _currentData->compDepth == 3 )
{
_depthReached = true;
}
_inCycle = true;
_startCompression = _currentData->time;
}
void NotePlayHandle::processMidiTime( const MidiTime& time )
{
if( detuning() && time >= songGlobalParentOffset()+pos() )
{
const float v = detuning()->automationPattern()->valueAt( time - songGlobalParentOffset() - pos() );
if( !typeInfo<float>::isEqual( v, m_baseDetuning->value() ) )
{
m_baseDetuning->setValue( v );
updateFrequency();
}
}
}
void ConnectionInfoWirelessTab::updateAccessPoint(const QString &uni)
{
Solid::Control::AccessPoint *ap = m_iface->findAccessPoint(uni);
// drop input from previous AP (if any)
if (m_ap != 0) {
disconnect(m_ap, SIGNAL(ssidChanged(QString)), this, SLOT(updateSsid(QString)));
disconnect(m_ap, SIGNAL(signalStrengthChanged(int)), this, SLOT(updateSignalStrength(int)));
disconnect(m_ap, SIGNAL(bitRateChanged(int)), this, SLOT(updateMaxBitRate(int)));
disconnect(m_ap, SIGNAL(frequencyChanged(uint)), this, SLOT(updateFrequency(uint)));
disconnect(m_ap, SIGNAL(wpaFlagsChanged(Solid::Control::AccessPoint::WpaFlags)), this, SLOT(updateWpa(Solid::Control::AccessPoint::WpaFlags)));
disconnect(m_ap, SIGNAL(rsnFlagsChanged(Solid::Control::AccessPoint::WpaFlags)), this, SLOT(updateRsn(Solid::Control::AccessPoint::WpaFlags)));
}
NotePlayHandle::NotePlayHandle( InstrumentTrack* instrumentTrack,
const f_cnt_t _offset,
const f_cnt_t _frames,
const note& n,
NotePlayHandle *parent,
int midiEventChannel,
Origin origin ) :
PlayHandle( TypeNotePlayHandle, _offset ),
note( n.length(), n.pos(), n.key(), n.getVolume(), n.getPanning(), n.detuning() ),
m_pluginData( NULL ),
m_filter( NULL ),
m_instrumentTrack( instrumentTrack ),
m_frames( 0 ),
m_totalFramesPlayed( 0 ),
m_framesBeforeRelease( 0 ),
m_releaseFramesToDo( 0 ),
m_releaseFramesDone( 0 ),
m_released( false ),
m_hasParent( parent != NULL ),
m_hadChildren( false ),
m_muted( false ),
m_bbTrack( NULL ),
m_origTempo( engine::getSong()->getTempo() ),
m_origBaseNote( instrumentTrack->baseNote() ),
m_frequency( 0 ),
m_unpitchedFrequency( 0 ),
m_baseDetuning( NULL ),
m_songGlobalParentOffset( 0 ),
m_midiChannel( midiEventChannel >= 0 ? midiEventChannel : instrumentTrack->midiPort()->realOutputChannel() ),
m_origin( origin )
{
if( hasParent() == false )
{
m_baseDetuning = new BaseDetuning( detuning() );
m_instrumentTrack->m_processHandles.push_back( this );
}
else
{
m_baseDetuning = parent->m_baseDetuning;
parent->m_subNotes.push_back( this );
parent->m_hadChildren = true;
m_bbTrack = parent->m_bbTrack;
}
updateFrequency();
setFrames( _frames );
// inform attached components about new MIDI note (used for recording in Piano Roll)
if( m_origin == OriginMidiInput )
{
m_instrumentTrack->midiNoteOn( *this );
}
if( hasParent() || ! m_instrumentTrack->isArpeggioEnabled() )
{
const int baseVelocity = m_instrumentTrack->midiPort()->baseVelocity();
// send MidiNoteOn event
m_instrumentTrack->processOutEvent(
MidiEvent( MidiNoteOn, midiChannel(), midiKey(), midiVelocity( baseVelocity ) ),
MidiTime::fromFrames( offset(), engine::framesPerTick() ),
offset() );
}
}
void NotePlayHandle::play( sampleFrame * _working_buffer )
{
if( m_muted )
{
return;
}
// if the note offset falls over to next period, then don't start playback yet
if( offset() >= Engine::mixer()->framesPerPeriod() )
{
setOffset( offset() - Engine::mixer()->framesPerPeriod() );
return;
}
lock();
if( m_frequencyNeedsUpdate )
{
updateFrequency();
}
// number of frames that can be played this period
f_cnt_t framesThisPeriod = m_totalFramesPlayed == 0
? Engine::mixer()->framesPerPeriod() - offset()
: Engine::mixer()->framesPerPeriod();
// check if we start release during this period
if( m_released == false &&
instrumentTrack()->isSustainPedalPressed() == false &&
m_totalFramesPlayed + framesThisPeriod > m_frames )
{
noteOff( m_totalFramesPlayed == 0
? ( m_frames + offset() ) // if we have noteon and noteoff during the same period, take offset in account for release frame
: ( m_frames - m_totalFramesPlayed ) ); // otherwise, the offset is already negated and can be ignored
}
// under some circumstances we're called even if there's nothing to play
// therefore do an additional check which fixes crash e.g. when
// decreasing release of an instrument-track while the note is active
if( framesLeft() > 0 )
{
// clear offset frames if we're at the first period
// skip for single-streamed instruments, because in their case NPH::play() could be called from an IPH without a buffer argument
// ... also, they don't actually render the sound in NPH's, which is an even better reason to skip...
if( m_totalFramesPlayed == 0 && ! ( m_instrumentTrack->instrument()->flags() & Instrument::IsSingleStreamed ) )
{
memset( _working_buffer, 0, sizeof( sampleFrame ) * offset() );
}
// play note!
m_instrumentTrack->playNote( this, _working_buffer );
}
if( m_released )
{
f_cnt_t todo = framesThisPeriod;
// if this note is base-note for arpeggio, always set
// m_releaseFramesToDo to bigger value than m_releaseFramesDone
// because we do not allow NotePlayHandle::isFinished() to be true
// until all sub-notes are completely played and no new ones
// are inserted by arpAndChordsTabWidget::processNote()
if( ! m_subNotes.isEmpty() )
{
m_releaseFramesToDo = m_releaseFramesDone + 2 * Engine::mixer()->framesPerPeriod();
}
// look whether we have frames left to be done before release
if( m_framesBeforeRelease )
{
// yes, then look whether these samples can be played
// within one audio-buffer
if( m_framesBeforeRelease <= framesThisPeriod )
{
// yes, then we did less releaseFramesDone
todo -= m_framesBeforeRelease;
m_framesBeforeRelease = 0;
}
else
{
// no, then just decrease framesBeforeRelease
// and wait for next loop... (we're not in
// release-phase yet)
todo = 0;
m_framesBeforeRelease -= framesThisPeriod;
}
}
// look whether we're in release-phase
if( todo && m_releaseFramesDone < m_releaseFramesToDo )
{
// check whether we have to do more frames in current
// loop than left in current loop
if( m_releaseFramesToDo - m_releaseFramesDone >= todo )
{
// yes, then increase number of release-frames
// done
m_releaseFramesDone += todo;
}
else
{
// no, we did all in this loop!
m_releaseFramesDone = m_releaseFramesToDo;
}
}
}
// play sub-notes (e.g. chords)
// handled by mixer now
/* foreach( NotePlayHandle * n, m_subNotes )
{
n->play( _working_buffer );
if( n->isFinished() )
{
NotePlayHandleManager::release( n );
}
}*/
// update internal data
m_totalFramesPlayed += framesThisPeriod;
unlock();
}
void Synthesizer::setSemiRange(uint8_t range)
{
config->semiRange = range;
updateFrequency();
}
void Synthesizer::setBaseFrequency(float f)
{
config->baseFreq = f;
updateFrequency();
}
void FrequencyScene::back(void*)
{
updateFrequency();
xSM->back();
}
Oscillator::Oscillator() : mCurrentPhase (0)
{
updateWave (SINE);
updateFrequency (440);
updatePhaseIncrement();
};
/*----------------------------------------------------------------------------*/
static enum result tmrInit(void *object, const void *configBase)
{
const struct GpTimerConfig * const config = configBase;
const struct GpTimerBaseConfig baseConfig = {
.channel = config->channel
};
struct GpTimer * const timer = object;
enum result res;
assert(config->event < GPTIMER_EVENT_END);
timer->event = config->event ? config->event : GPTIMER_MATCH0;
--timer->event;
/* Call base class constructor */
if ((res = GpTimerBase->init(object, &baseConfig)) != E_OK)
return res;
timer->base.handler = interruptHandler;
timer->callback = 0;
/* Initialize peripheral block */
LPC_TIMER_Type * const reg = timer->base.reg;
reg->TCR = TCR_CRES;
reg->IR = reg->IR; /* Clear pending interrupts */
reg->CCR = 0;
reg->CTCR = 0;
reg->MCR = 0;
updateFrequency(timer, config->frequency);
/* Configure prescaler and default match value */
reg->MR[timer->event] = getMaxValue(timer);
/* Enable external match to generate signals to other peripherals */
reg->EMR = EMR_CONTROL(timer->event, CONTROL_TOGGLE);
#ifdef CONFIG_GPTIMER_PM
if ((res = pmRegister(interface, powerStateHandler)) != E_OK)
return res;
#endif
/* Timer is disabled by default */
reg->TCR = 0;
irqSetPriority(timer->base.irq, config->priority);
irqEnable(timer->base.irq);
return E_OK;
}
/*----------------------------------------------------------------------------*/
static void tmrDeinit(void *object)
{
struct GpTimer * const timer = object;
LPC_TIMER_Type * const reg = timer->base.reg;
irqDisable(timer->base.irq);
reg->TCR = 0;
#ifdef CONFIG_GPTIMER_PM
pmUnregister(interface);
#endif
GpTimerBase->deinit(timer);
}
/*----------------------------------------------------------------------------*/
static void tmrCallback(void *object, void (*callback)(void *), void *argument)
{
struct GpTimer * const timer = object;
LPC_TIMER_Type * const reg = timer->base.reg;
timer->callbackArgument = argument;
timer->callback = callback;
if (callback)
{
reg->IR = reg->IR;
reg->MCR |= MCR_INTERRUPT(timer->event);
}
else
reg->MCR &= ~MCR_INTERRUPT(timer->event);
}
/*----------------------------------------------------------------------------*/
static void tmrSetEnabled(void *object, bool state)
{
struct GpTimer * const timer = object;
LPC_TIMER_Type * const reg = timer->base.reg;
/* Stop the timer */
reg->TCR = 0;
/* Clear pending interrupt flags and direct memory access requests */
reg->IR = IR_MATCH_INTERRUPT(timer->event);
if (state)
{
/* Clear match value to avoid undefined output level */
reg->EMR &= ~EMR_EXTERNAL_MATCH(timer->event);
reg->TCR = TCR_CEN;
}
}
/*----------------------------------------------------------------------------*/
static uint32_t tmrGetFrequency(const void *object)
{
const struct GpTimer * const timer = object;
const LPC_TIMER_Type * const reg = timer->base.reg;
const uint32_t baseClock = gpTimerGetClock((const struct GpTimerBase *)timer);
return baseClock / (reg->PR + 1);
}
/*----------------------------------------------------------------------------*/
static void tmrSetFrequency(void *object, uint32_t frequency)
{
updateFrequency(object, frequency);
}
static enum result powerStateHandler(void *object, enum pmState state)
{
struct GpTimer * const timer = object;
return state == PM_ACTIVE ? updateFrequency(timer, timer->frequency) : E_OK;
}
