void JamCracker::Play(void)
{
if (--waitCnt == 0)
{
NewNote();
waitCnt = wait;
}
SetChannel(&variables[0]);
SetChannel(&variables[1]);
SetChannel(&variables[2]);
SetChannel(&variables[3]);
}
void TrackList::GroupChannels(
Track &track, size_t groupSize, bool resetChannels )
{
// If group size is more than two, for now only the first two channels
// are grouped as stereo, and any others remain mono
auto list = track.mList.lock();
if ( groupSize > 0 && list.get() == this ) {
auto iter = track.mNode.first;
auto after = iter;
auto end = this->ListOfTracks::end();
auto count = groupSize;
for ( ; after != end && count; ++after, --count )
;
if ( count == 0 ) {
auto unlink = [&] ( Track &tr ) {
if ( tr.GetLinked() ) {
if ( resetChannels ) {
auto link = tr.GetLink();
if ( link )
link->SetChannel( Track::MonoChannel );
}
tr.SetLinked( false );
}
if ( resetChannels )
tr.SetChannel( Track::MonoChannel );
};
// Disassociate previous tracks -- at most one
auto pLeader = this->FindLeader( &track );
if ( *pLeader && *pLeader != &track )
unlink( **pLeader );
// First disassociate given and later tracks, then reassociate them
for ( auto iter2 = iter; iter2 != after; ++iter2 )
unlink( **iter2 );
if ( groupSize > 1 ) {
const auto channel = *iter++;
channel->SetLinked( true );
channel->SetChannel( Track::LeftChannel );
(*iter++)->SetChannel( Track::RightChannel );
while (iter != after)
(*iter++)->SetChannel( Track::MonoChannel );
}
return;
}
}
// *this does not contain the track or sufficient following channels
// or group size is zero
THROW_INCONSISTENCY_EXCEPTION;
}
void ChatPanel::Parted(User& who, const wxString& message)
{
// assert( m_type == CPT_Channel || m_type == CPT_Server || m_type == CPT_Battle || m_type == CPT_User );
const bool me_parted = m_channel && &who == &m_channel->GetMe();
const wxString nick = TowxString(who.GetNick());
const bool wasactive = m_active_users.erase(nick) > 0;
if (m_display_joinitem || (wasactive && !who.IsBot())) {
OutputLine(_T( "** " ) + wxString::Format(_("%s left %s (%s)."), nick.c_str(), GetChatTypeStr().c_str(), message.c_str()), sett().GetChatColorJoinPart());
}
if (m_type == CPT_Channel) {
if (m_channel == 0)
return;
if (me_parted) {
m_channel->panel = nullptr;
SetChannel(0);
return;
}
if (m_display_joinitem) {
// change the image of the tab to show new events
SetIconHighlight(highlight_join_leave);
}
} else if (m_type == CPT_Server && me_parted)
return;
if (m_show_nick_list && (m_nicklist != nullptr)) {
m_nicklist->RemoveUser(who);
UpdateUserCountLabel();
}
// Also remove the User from the TextCompletionDatabase
textcompletiondatabase.Delete_Mapping(TowxString(who.GetNick()));
}
CCircuitry* CNeighbour::ConnectTo(LPCTSTR xUserId, DWORD nTimeOut)
{
CSingleLock pLock( &m_pSection, TRUE );
CCircuitry* pChannel = FindChannel( xUserId );
if ( pChannel ) return pChannel;
NETRESOURCE ns;
ns.dwScope = RESOURCE_CONNECTED;
ns.dwType = RESOURCETYPE_ANY;
ns.dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
ns.dwUsage = RESOURCEUSAGE_CONNECTABLE;
ns.lpRemoteName = Settings.Centric.Remote.GetBuffer(0);
ns.lpLocalName = NULL;
ns.lpProvider = NULL;
WNetAddConnection2( &ns, Settings.Centric.Password, Settings.Centric.UserId, 0 );
if ( ! WaitNamedPipe( Settings.Centric.Remote, nTimeOut ) ) return NULL;
pChannel = SetChannel( new CCircuitry( xUserId ) );
pChannel->ConnectTo( Settings.Centric.Remote, nTimeOut );
pChannel->SendPacket( new CBindPacket( xUserId, "" ) );
Connect(); return pChannel;
}
void ChatPanel::Parted( User& who, const wxString& message )
{
// assert( m_type == CPT_Channel || m_type == CPT_Server || m_type == CPT_Battle || m_type == CPT_User );
bool me_parted = m_channel && &who == &m_channel->GetMe();
if ( m_type == CPT_Channel ) {
if ( m_channel == 0 ) return;
if ( me_parted ) {
m_channel->uidata.panel = 0;
SetChannel( 0 );
return;
}
if ( sett().GetDisplayJoinLeave( m_channel->GetName() ) ) {
// change the image of the tab to show new events
SetIconHighlight( highlight_join_leave );
OutputLine( _T( " ** " ) + who.GetNick() + _( " left the " ) + GetChatTypeStr() + _T( "( " ) + message + _T( " )." ), sett().GetChatColorJoinPart(), sett().GetChatFont() );
}
} else if ( m_type == CPT_Battle ) {
if ( sett().GetDisplayJoinLeave( _T( "game/battle" ) ) ) {
OutputLine( _T( " ** " ) + who.GetNick() + _( " left the " ) + GetChatTypeStr() + _T( "( " ) + message + _T( " )." ), sett().GetChatColorJoinPart(), sett().GetChatFont() );
}
}
else if ( m_type == CPT_Server && me_parted )
return;
if ( m_show_nick_list && ( m_nicklist != 0 ) )
{
unsigned int numusers = 0;
if ( m_type == CPT_Channel ) numusers = GetChannel()->GetNumUsers();
else if ( m_type == CPT_Server && m_server ) numusers = m_server->GetNumUsers();
m_usercount_label->SetLabel( wxString::Format( _("%d users"), numusers ) );
m_nicklist->RemoveUser( who );
}
// Also remove the User from the TextCompletionDatabase
textcompletiondatabase.Delete_Mapping( who.GetNick() );
}
int rtl8188eu_oid_rt_pro_set_channel_direct_call_hdl(struct oid_par_priv *poid_par_priv)
{
u32 Channel;
int status = NDIS_STATUS_SUCCESS;
struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_set_channel_direct_call_hdl\n"));
if (poid_par_priv->information_buf_len != sizeof(u32))
return NDIS_STATUS_INVALID_LENGTH;
if (poid_par_priv->type_of_oid == QUERY_OID) {
*((u32 *)poid_par_priv->information_buf) = Adapter->mppriv.channel;
return NDIS_STATUS_SUCCESS;
}
if (poid_par_priv->type_of_oid != SET_OID)
return NDIS_STATUS_NOT_ACCEPTED;
Channel = *((u32 *)poid_par_priv->information_buf);
RT_TRACE(_module_mp_, _drv_notice_, ("rtl8188eu_oid_rt_pro_set_channel_direct_call_hdl: Channel=%d\n", Channel));
if (Channel > 14)
return NDIS_STATUS_NOT_ACCEPTED;
Adapter->mppriv.channel = Channel;
_irqlevel_changed_(&oldirql, LOWER);
SetChannel(Adapter);
_irqlevel_changed_(&oldirql, RAISE);
return status;
}
void SX1276::RxChainCalibration( void )
{
uint8_t regPaConfigInitVal;
uint32_t initialFreq;
// Save context
regPaConfigInitVal = this->Read( REG_PACONFIG );
initialFreq = ( double )( ( ( uint32_t )this->Read( REG_FRFMSB ) << 16 ) |
( ( uint32_t )this->Read( REG_FRFMID ) << 8 ) |
( ( uint32_t )this->Read( REG_FRFLSB ) ) ) * ( double )FREQ_STEP;
// Cut the PA just in case, RFO output, power = -1 dBm
this->Write( REG_PACONFIG, 0x00 );
// Launch Rx chain calibration for LF band
Write ( REG_IMAGECAL, ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_MASK ) | RF_IMAGECAL_IMAGECAL_START );
while( ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_RUNNING ) == RF_IMAGECAL_IMAGECAL_RUNNING )
{
}
// Sets a Frequency in HF band
settings.Channel= 868000000 ;
// Launch Rx chain calibration for HF band
Write ( REG_IMAGECAL, ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_MASK ) | RF_IMAGECAL_IMAGECAL_START );
while( ( Read( REG_IMAGECAL ) & RF_IMAGECAL_IMAGECAL_RUNNING ) == RF_IMAGECAL_IMAGECAL_RUNNING )
{
}
// Restore context
this->Write( REG_PACONFIG, regPaConfigInitVal );
SetChannel( initialFreq );
}
Normalization::Normalization() :
mActualChannel(0),
mpActualParams(0),
mNFramesForEstim(0),
mMeanNorm(false),
mVarNorm(false),
mScaleToGVar(false)
{
strcpy(mpFile, "none");
SetChannel(0);
}
BOOL CNeighbour::AcceptCircuitry()
{
if ( m_hPipe == INVALID_HANDLE_VALUE ) return Connect( Settings.Centric.Local );
if ( ! HasOverlappedIoCompleted( &m_pOverlapped ) ) return TRUE;
SetChannel( new CCircuitry( m_hPipe ) );
m_hPipe = INVALID_HANDLE_VALUE;
return TRUE;
}
// Author & Date: Ehsan Azar 29 March 2011
// Purpose: Open and connect to the library
void CSDKSampleDlg::OnBtnConnect()
{
cbSdkResult res = cbSdkOpen(0);
if (res != CBSDKRESULT_SUCCESS)
{
PrintError(res);
return;
}
cbSdkConnectionType conType;
cbSdkInstrumentType instType;
// Return the actual openned connection
res = cbSdkGetType(0, &conType, &instType);
if (res != CBSDKRESULT_SUCCESS)
{
SetStatusWindow("Unable to determine connection type");
return;
}
cbSdkVersion ver;
res = cbSdkGetVersion(0, &ver);
if (res != CBSDKRESULT_SUCCESS)
{
SetStatusWindow("Unable to determine nsp version");
return;
}
if (conType < 0 || conType > CBSDKCONNECTION_CLOSED)
conType = CBSDKCONNECTION_CLOSED;
if (instType < 0 || instType > CBSDKINSTRUMENT_COUNT)
instType = CBSDKINSTRUMENT_COUNT;
char strConnection[CBSDKCONNECTION_CLOSED + 1][8] = {"Default", "Central", "Udp", "Closed"};
char strInstrument[CBSDKINSTRUMENT_COUNT + 1][13] = {"NSP", "nPlay", "Local NSP", "Remote nPlay", "Unknown"};
CString strStatus;
SetStatusWindow(strStatus);
strStatus.Format("%s real-time interface to %s (%d.%02d.%02d.%02d) successfully initialized\n", strConnection[conType], strInstrument[instType], ver.nspmajor, ver.nspminor, ver.nsprelease, ver.nspbeta);
SetStatusWindow(strStatus);
// Slider shows analog threshold
m_sldThresh.SetRange(-255, 255, TRUE);
m_sldThresh.SetPageSize(5);
m_cboChannel.ResetContent();
char label[cbLEN_STR_LABEL + 1];
for(UINT16 chan = 1; chan <= cbNUM_ANALOG_CHANS; chan++)
{
label[cbLEN_STR_LABEL] = 0;
res = cbSdkGetChannelLabel(0, chan, NULL, label, NULL, NULL);
if (res == CBSDKRESULT_SUCCESS)
m_cboChannel.AddString(label);
}
if (m_cboChannel.GetCount() > 0)
m_cboChannel.SetCurSel(m_channel - 1);
SetChannel(m_channel);
}
void RA_PWMClass::ChannelPWMParabola(byte Channel, byte Start, byte End)
{
SetChannel(Channel,PWMParabola(
InternalMemory.StdLightsOnHour_read(),
InternalMemory.StdLightsOnMinute_read(),
InternalMemory.StdLightsOffHour_read(),
InternalMemory.StdLightsOffMinute_read(),
Start,
End,
ExpansionChannel[Channel]
));
}
void ModuleTouch::Init(int chan) {
SetChannel(chan);
m_buttons[0].Setup(21);
m_buttons[1].Setup(20);
m_buttons[2].Setup(19);
m_buttons[3].Setup(18);
for (int n = 0; n < 4; n++) {
m_prevStates[n] = m_buttons[n].IsPressed();
}
}
void RA_PWMClass::ChannelPWMSlope(byte Channel, byte Start, byte End, byte Duration)
{
SetChannel(Channel,PWMSlope(
InternalMemory.StdLightsOnHour_read(),
InternalMemory.StdLightsOnMinute_read(),
InternalMemory.StdLightsOffHour_read(),
InternalMemory.StdLightsOffMinute_read(),
Start,
End,
Duration,
ExpansionChannel[Channel]
));
}
void RA_PWMClass::ChannelPWMParabola(byte Channel, byte Start, byte End, byte MinuteOffset)
{
int onTime=NumMins(InternalMemory.StdLightsOnHour_read(),InternalMemory.StdLightsOnMinute_read())-MinuteOffset;
int offTime=NumMins(InternalMemory.StdLightsOffHour_read(),InternalMemory.StdLightsOffMinute_read())+MinuteOffset;
SetChannel(Channel,PWMParabola(
onTime/60,
onTime%60,
offTime/60,
offTime%60,
Start,
End,
ExpansionChannel[Channel]
));
}
void cGraphLCDState::ChannelSwitch(const cDevice * Device, int ChannelNumber)
{
// printf("graphlcd plugin: cGraphLCDState::ChannelSwitch %d %d\n", Device->CardIndex(), ChannelNumber);
if (GraphLCDSetup.PluginActive)
{
if (ChannelNumber > 0 && Device->IsPrimaryDevice() && !EITScanner.UsesDevice(Device))
{
if (ChannelNumber == cDevice::CurrentChannel())
{
SetChannel(ChannelNumber);
}
}
}
}
bool
Instance::Move(short chan_id, const Time &t, const Time &d, bool display)
{
if (startTime != t) {
SetStartTime(t, display);
}
if (duration != d) {
SetDuration(d, display);
}
if (chan_id >= 0 && chan_id < uberQua->nChannel) {
Channel *c = uberQua->channel[chan_id];
SetChannel(c, display);
}
return true;
}
LRESULT CCompositeControl::OnClickedChannelup(WORD wNotifyCode, WORD wID,
HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
long lPhysicalChannel = 0;
// Get the current physical channel and increment it
hr =m_pATSCLocator->get_PhysicalChannel(&lPhysicalChannel);
if (FAILED(hr))
{
MessageBox(TEXT("Failed to read physical channel."), TEXT("Error"), MB_OK);
return hr;
}
lPhysicalChannel++;
hr = SetChannel(lPhysicalChannel);
return hr;
}
cGraphLCDState::cGraphLCDState()
: first(true),
tickUsed(false)
{
channel.number = 0;
channel.str = "";
channel.strTmp = "";
event.presentTime = 0;
event.presentTitle = "";
event.presentSubtitle = "";
event.followingTime = 0;
event.followingTitle = "";
event.followingSubtitle = "";
replay.name = "";
replay.loopmode = "";
replay.control = NULL;
replay.mode = eReplayNormal;
replay.current = 0;
replay.currentLast = FRAMESPERSEC;
replay.total = 0;
replay.totalLast = 1;
for (int i = 0; i < MAXDEVICES; i++)
{
card[i].recordingCount = 0;
card[i].recordingName = "";
}
osd.currentItem = "";
osd.title = "";
for (int i = 0; i < 4; i++)
osd.colorButton[i] = "";
osd.message = "";
osd.textItem = "";
osd.currentItemIndex = 0;
volume.value = -1;
volume.lastChange = 0;
SetChannel(cDevice::CurrentChannel());
}
void SetOption(option_types opt_code, void* value)
{ switch (opt_code)
{ case OPT_CONS_SPEED: { SetConsSpeed(*(uint32_t *) value); break; }
case OPT_GPS_SPEED: { SetGPSSpeed (*(uint32_t *) value); break; }
case OPT_ACFT_ID: { SetAcftID (*(uint32_t *) value); break; }
case OPT_TX_POWER: { SetTxPower (*(float *) value); break; }
case OPT_XTAL_CORR: { SetXtalCorr (*(int16_t *) value); break; }
case OPT_FREQ_OFS: { SetFreqOfs (*(int32_t *) value); break; }
case OPT_IWDG: { SetIWDGDis (*(uint8_t *) value); break; }
case OPT_OPER_MODE: { SetOperMode (*(uint8_t *) value); break; }
case OPT_CHANNEL: { SetChannel (*(uint8_t *) value); break; }
case OPT_GPSDUMP: { SetGPSDump (*(uint8_t *) value); break; }
case OPT_MAX_TX_PWR: { SetMaxTxPower (*(float *) value); break; }
case OPT_GPS_ALW_ON: { SetGPSAlwON (*(uint8_t *) value); break; }
case OPT_GPS_ANT: { SetGPSAnt (*(uint8_t *) value); break; }
case OPT_JAM_RATIO: { SetJamRatio (*(uint8_t *) value); break; }
case OPT_MIN_BAT_LVL:{ SetMinBatLvl(*(uint16_t *) value); break; }
case OPT_GPS_WDG_TIME:{SetGPSWdgTime(*(uint16_t *) value); break;}
default: break; }
}
int RxStop()
{
char buffer[512];
int ret;
int i;
ENTRY;
error_msg = no_error;
for(i=0; i <= LAST_RATE_XMIT_RATE; i++)
{
sprintf(buffer, "rxstat=%u,0\n",i);
ret = send_cmd(buffer);
}
//send some nonsense to make sure last results are read
SetChannel(current_channel);
RETURNI(ret);
return SUCCESS;
}
ChatPanel::ChatPanel(wxWindow* parent, Channel& chan, wxImageList* imaglist)
: wxPanel(parent, -1)
, m_show_nick_list(true)
, m_votePanel(0)
, m_nicklist(0)
, m_chat_tabs((SLNotebook*)parent)
, m_channel(&chan)
, m_server(0)
, m_user(0)
, m_battle(0)
, m_type(CPT_Channel)
, m_popup_menu(NULL)
, m_icon_index(2)
, m_imagelist(imaglist)
, m_disable_append(false)
, m_display_joinitem(false)
, m_topic_set(false)
, m_reactOnPromoteEvents(true)
{
Init(TowxString(chan.GetName()));
SetChannel(&chan);
}
bool SX1276::IsChannelFree( ModemType modem, uint32_t freq, int8_t rssiThresh )
{
int16_t rssi = 0;
SetModem( modem );
SetChannel( freq );
SetOpMode( RF_OPMODE_RECEIVER );
wait_ms( 1 );
rssi = GetRssi( modem );
/*************NULL*********/
if( rssi > ( int16_t )rssiThresh )
{
return false;
}
return true;
}
/*!
errorType STLServerCommandSetChannelXXX::Read()
will have already read the Socket command type and the command id
now need to read the command specific data from the client.
Should only be called from a GSISocket server or derived class
Note that the corresponding ::Write function will be waiting for a
ServerReturnRecord. This function does not return this record as it
doesn't know if the task was completed without error.
The calling code will need to perform the required hardware (or other) tasks
and return the ServerReturnRecord indicating status of the function
Reads
wxInt16 queuedFlag
wxUint16 atTick
wxInt16 channel
*************************************************************************/
errorType STLServerCommandSetChannelXXX::Read(wxSocketBase &sock)
{
//read amplitude
wxInt16 chan;
errorType rv;
rv=ReadFixedFields(sock); //reads qflag, at_tick
sock.Read(&chan,sizeof(chan));
SetReadFlag(true);
AppendToReadFromSocketString(chan);
if(sock.Error())
{
MapWxSocketError sockErr(sock.LastError());
SetLastError(sockErr.GetErrorType());
return(sockErr.GetErrorType());
}
SetChannel(chan);
FillGSIRecord();
wxString s;
s.Printf("Read SetChannel (%i) from client\n",chan);
AppendText(s);
return errNone;
}
void ModuleRainbow::Init(int chan) {
SetChannel(chan);
}
eOSState cOsdInfoWindow::ProcessKey(eKeys key)
{
time_t curTime;
switch (key)
{
case k0:
if (m_Number == 0) {
m_Group = -1;
Hide();
return osUnknown;
}
case k1...k9:
if (m_Number >= 0) {
m_Number = m_Number * 10 + key - k0;
if (m_Number > 0) {
cChannel *channel = Channels.GetByNumber(m_Number);
m_Channel = channel;
m_WithInfo = false;
Show(false, (OsdPipSetup.ShowInfo==0));
// Lets see if there can be any useful further input:
int n = channel ? m_Number * 10 : 0;
while (channel && (channel = Channels.Next(channel)) != NULL) {
if (!channel->GroupSep()) {
if (n <= channel->Number() && channel->Number() <= n + 9) {
n = 0;
break;
}
if (channel->Number() > n)
n *= 10;
}
}
if (n > 0) {
// This channel is the only one that fits the input, so let's take it right away:
int number = m_Number;
m_Number = 0;
m_Group = -1;
m_WithInfo = true;
Channels.SwitchTo(number);
}
}
}
return osContinue;
case kLeft | k_Repeat:
case kLeft:
case kRight | k_Repeat:
case kRight:
m_WithInfo = false;
if (m_Group < 0) {
cChannel *channel = Channels.GetByNumber(cDevice::CurrentChannel());
if (channel)
m_Group = channel->Index();
}
if (m_Group >= 0) {
int SaveGroup = m_Group;
if (NORMALKEY(key) == kRight)
m_Group = Channels.GetNextGroup(m_Group);
else
m_Group = Channels.GetPrevGroup(m_Group < 1 ? 1 : m_Group);
if (m_Group < 0)
m_Group = SaveGroup;
cChannel *channel = Channels.Get(m_Group);
if (channel) {
m_Channel = channel;
Show(false, (OsdPipSetup.ShowInfo==0));
if (!channel->GroupSep())
m_Group = -1;
}
}
return osContinue;
case kUp | k_Repeat:
case kUp:
case kDown | k_Repeat:
case kDown:
//std::cout << "cOsdInfoWindow::ProcessKey, vor cDevice::SwitchChannel" << std::endl;
if (cDevice::SwitchChannel(NORMALKEY(key) == kUp ? 1 : -1));
SetChannel(Channels.GetByNumber(cDevice::CurrentChannel()), false);
//std::cout << "cOsdInfoWindow::ProcessKey, nach cDevice::SwitchChannel" << std::endl;
m_WithInfo = true;
m_Number = 0;
m_Group = -1;
Show(false, (OsdPipSetup.ShowInfo==0));
return osContinue;
//case kChanUp|k_Repeat:
//case kChanUp:
//case kChanDn|k_Repeat:
//case kChanDn:
// m_WithInfo = true;
// m_Number = 0;
// m_Group = -1;
// return osContinue;//osUnknown;
case kNone:
if (Shown()) {
time(&curTime);
if (m_Number && curTime - m_LastTime > DIRECTCHANNELTIMEOUT) {
if (Channels.GetByNumber(m_Number)) {
int number = m_Number;
m_Number = 0;
m_Group = -1;
//std::cout << "cOsdInfoWindow::ProcessKey, vor Channels.SwitchTo" << std::endl;
/* TB: only switch the channel if we are in live-view-mode, not when replaying recordings */
if(cDevice::PrimaryDevice()->Transferring()) {
Channels.SwitchTo(number);
}
} else {
m_Number = 0;
m_Group = -1;
m_Channel = NULL;
Show(false, (OsdPipSetup.ShowInfo==0));
m_Channel = Channels.Get(cDevice::CurrentChannel());
m_WithInfo = true;
return osContinue;
}
return osContinue;
}
}
break;
case kOk:
if (Shown()) {
if (m_Group >= 0) {
int group = m_Group;
m_Group = -1;
m_Number = 0;
Channels.SwitchTo(Channels.Get(Channels.GetNextNormal(group))->Number());
} else {
m_Group = -1;
m_Number = 0;
m_Channel = Channels.Get(cDevice::CurrentChannel());
m_WithInfo = true;
Hide();
}
return osContinue;
}
break;
default:
return osUnknown;
}
if (Shown()) {
time(&curTime);
if (curTime - m_LastTime >= INFOTIMEOUT) {
m_Group = -1;
m_Number = 0;
Hide();
}
return osContinue;
}
return osContinue;
}
void Normalization::Load(char *pFile)
{
if(strlen(pFile) == 0 && strcmp(pFile, "none") != 0)
{
return;
}
mParams.clear();
SXMLDocument doc;
doc.Load(pFile);
SXMLNode &root_node = doc.GetRootNode();
root_node.FirstChild();
SXMLNode *pchannel_node;
while((pchannel_node = root_node.GetChild()) != 0)
{
if(pchannel_node->GetName() == "channel")
{
int id = 0;
sscanf((char *)(*pchannel_node->GetProperties())["id"].c_str(), "%d", &id);
SetChannel(id);
pchannel_node->FirstChild();
SXMLNode *pchild_node;
while((pchild_node = pchannel_node->GetChild()) != 0)
{
std::string name = pchild_node->GetName();
std::string text = pchild_node->GetText();
if(name == "mean")
{
float *pvct;
int len;
ParseFloatVector((char *)text.c_str(), &pvct, &len);
if(len != mpActualParams->GetFrameLength())
{
mpActualParams->Alloc(len);
mpActualParams->Null();
}
mpActualParams->SetMeans(pvct);
delete [] pvct;
}
else if(name == "variance")
{
float *pvct;
int len;
ParseFloatVector((char *)text.c_str(), &pvct, &len);
int i;
for(i = 0; i < len; i++)
{
pvct[i] = 1.0f / sqrt(pvct[i]);
}
if(len != mpActualParams->GetFrameLength())
{
mpActualParams->Alloc(len);
mpActualParams->Null();
}
mpActualParams->SetInvStds(pvct);
delete [] pvct;
}
else if(name == "gvariance")
{
float *pvct;
int len;
ParseFloatVector((char *)text.c_str(), &pvct, &len);
int i;
for(i = 0; i < len; i++)
{
pvct[i] = sqrt(pvct[i]);
}
if(len != mpActualParams->GetFrameLength())
{
mpActualParams->Alloc(len);
mpActualParams->Null();
}
mpActualParams->SetGlobStds(pvct);
delete [] pvct;
}
}
}
}
SetChannel(0);
}
// Author & Date: Ehsan Azar 30 March 2011
// Purpose: Current channel changed
void CSDKSampleDlg::OnSelchangeComboChannel()
{
UINT16 newchan = m_cboChannel.GetCurSel() + 1;
if (newchan != m_channel)
SetChannel(newchan);
}
printf("Loading alignment HMM set %s\n",q);
}
AddMMF(&al_hset,q);
if (eos)
break;
q=p+1;
}
p++;
}
}
if (strlen(al_hmmLst) > 0 )
MakeHMMSet(&al_hset, al_hmmLst );
else /* use same hmmList */
MakeHMMSet(&al_hset, hmmListFn );
if (strlen(al_hmmDir) > 0 )
LoadHMMSet(&al_hset,al_hmmDir,al_hmmExt);
else
LoadHMMSet(&al_hset,NULL,NULL);
/* switch model set */
UseAlignHMMSet(fbInfo,x,&al_hset);
if (parMode != 0) {
ConvDiagC(&al_hset,TRUE);
ConvLogWt(&al_hset);
}
/* and echo status */
if (trace&T_TOP) {
if (strlen(al_hmmDir) > 0 )
printf(" HMM Dir %s",al_hmmDir);
if (strlen(al_hmmExt) > 0 )
printf(" Ext %s",al_hmmExt);
void ControlToolBar::OnRecord(wxCommandEvent &evt)
{
auto doubleClicked = mRecord->IsDoubleClicked();
mRecord->ClearDoubleClicked();
if (doubleClicked) {
// Display a fixed recording head while scrolling the waves continuously.
// If you overdub, you may want to anticipate some context in existing tracks,
// so center the head. If not, put it rightmost to display as much wave as we can.
const auto project = GetActiveProject();
bool duplex;
gPrefs->Read(wxT("/AudioIO/Duplex"), &duplex, true);
if (duplex) {
// See if there is really anything being overdubbed
if (gAudioIO->GetNumPlaybackChannels() == 0)
// No.
duplex = false;
}
using Mode = AudacityProject::PlaybackScroller::Mode;
project->GetPlaybackScroller().Activate(duplex ? Mode::Centered : Mode::Right);
return;
}
if (gAudioIO->IsBusy()) {
if (!CanStopAudioStream() || 0 == gAudioIO->GetNumCaptureChannels())
mRecord->PopUp();
else
mRecord->PushDown();
return;
}
AudacityProject *p = GetActiveProject();
if( evt.GetInt() == 1 ) // used when called by keyboard shortcut. Default (0) ignored.
mRecord->SetShift(true);
if( evt.GetInt() == 2 )
mRecord->SetShift(false);
SetRecord(true, mRecord->WasShiftDown());
if (p) {
TrackList *trackList = p->GetTracks();
TrackListIterator it(trackList);
if(it.First() == NULL)
mRecord->SetShift(false);
double t0 = p->GetSel0();
double t1 = p->GetSel1();
if (t1 == t0)
t1 = 1000000000.0; // record for a long, long time (tens of years)
/* TODO: set up stereo tracks if that is how the user has set up
* their preferences, and choose sample format based on prefs */
WaveTrackArray newRecordingTracks, playbackTracks;
#ifdef EXPERIMENTAL_MIDI_OUT
NoteTrackArray midiTracks;
#endif
bool duplex;
gPrefs->Read(wxT("/AudioIO/Duplex"), &duplex, true);
if(duplex){
playbackTracks = trackList->GetWaveTrackArray(false);
#ifdef EXPERIMENTAL_MIDI_OUT
midiTracks = trackList->GetNoteTrackArray(false);
#endif
}
else {
playbackTracks = WaveTrackArray();
#ifdef EXPERIMENTAL_MIDI_OUT
midiTracks = NoteTrackArray();
#endif
}
// If SHIFT key was down, the user wants append to tracks
int recordingChannels = 0;
TrackList tracksCopy{};
bool tracksCopied = false;
bool shifted = mRecord->WasShiftDown();
if (shifted) {
bool sel = false;
double allt0 = t0;
// Find the maximum end time of selected and all wave tracks
// Find whether any tracks were selected. (If any are selected,
// record only into them; else if tracks exist, record into all.)
for (Track *tt = it.First(); tt; tt = it.Next()) {
if (tt->GetKind() == Track::Wave) {
WaveTrack *wt = static_cast<WaveTrack *>(tt);
if (wt->GetEndTime() > allt0) {
allt0 = wt->GetEndTime();
}
if (tt->GetSelected()) {
sel = true;
if (wt->GetEndTime() > t0) {
t0 = wt->GetEndTime();
}
}
}
}
// Use end time of all wave tracks if none selected
if (!sel) {
t0 = allt0;
}
// Pad selected/all wave tracks to make them all the same length
// Remove recording tracks from the list of tracks for duplex ("overdub")
// playback.
for (Track *tt = it.First(); tt; tt = it.Next()) {
if (tt->GetKind() == Track::Wave && (tt->GetSelected() || !sel)) {
WaveTrack *wt = static_cast<WaveTrack *>(tt);
if (duplex) {
auto end = playbackTracks.end();
auto it = std::find(playbackTracks.begin(), end, wt);
if (it != end)
playbackTracks.erase(it);
}
t1 = wt->GetEndTime();
if (t1 < t0) {
if (!tracksCopied) {
tracksCopied = true;
tracksCopy = *trackList;
}
auto newTrack = p->GetTrackFactory()->NewWaveTrack();
newTrack->InsertSilence(0.0, t0 - t1);
newTrack->Flush();
wt->Clear(t1, t0);
bool bResult = wt->Paste(t1, newTrack.get());
wxASSERT(bResult); // TO DO: Actually handle this.
wxUnusedVar(bResult);
}
newRecordingTracks.push_back(wt);
}
}
t1 = 1000000000.0; // record for a long, long time (tens of years)
}
else {
bool recordingNameCustom, useTrackNumber, useDateStamp, useTimeStamp;
wxString defaultTrackName, defaultRecordingTrackName;
int numTracks = 0;
for (Track *tt = it.First(); tt; tt = it.Next()) {
if (tt->GetKind() == Track::Wave && !tt->GetLinked())
numTracks++;
}
numTracks++;
recordingChannels = gPrefs->Read(wxT("/AudioIO/RecordChannels"), 2);
gPrefs->Read(wxT("/GUI/TrackNames/RecordingNameCustom"), &recordingNameCustom, false);
gPrefs->Read(wxT("/GUI/TrackNames/TrackNumber"), &useTrackNumber, false);
gPrefs->Read(wxT("/GUI/TrackNames/DateStamp"), &useDateStamp, false);
gPrefs->Read(wxT("/GUI/TrackNames/TimeStamp"), &useTimeStamp, false);
/* i18n-hint: The default name for an audio track. */
gPrefs->Read(wxT("/GUI/TrackNames/DefaultTrackName"),&defaultTrackName, _("Audio Track"));
gPrefs->Read(wxT("/GUI/TrackNames/RecodingTrackName"), &defaultRecordingTrackName, defaultTrackName);
wxString baseTrackName = recordingNameCustom? defaultRecordingTrackName : defaultTrackName;
for (int c = 0; c < recordingChannels; c++) {
auto newTrack = p->GetTrackFactory()->NewWaveTrack();
newTrack->SetOffset(t0);
wxString nameSuffix = wxString(wxT(""));
if (useTrackNumber) {
nameSuffix += wxString::Format(wxT("%d"), numTracks + c);
}
if (useDateStamp) {
if (!nameSuffix.IsEmpty()) {
nameSuffix += wxT("_");
}
nameSuffix += wxDateTime::Now().FormatISODate();
}
if (useTimeStamp) {
if (!nameSuffix.IsEmpty()) {
nameSuffix += wxT("_");
}
nameSuffix += wxDateTime::Now().FormatISOTime();
}
// ISO standard would be nice, but ":" is unsafe for file name.
nameSuffix.Replace(wxT(":"), wxT("-"));
if (baseTrackName.IsEmpty()) {
newTrack->SetName(nameSuffix);
}
else if (nameSuffix.IsEmpty()) {
newTrack->SetName(baseTrackName);
}
else {
newTrack->SetName(baseTrackName + wxT("_") + nameSuffix);
}
if (recordingChannels > 2)
newTrack->SetMinimized(true);
if (recordingChannels == 2) {
if (c == 0) {
newTrack->SetChannel(Track::LeftChannel);
newTrack->SetLinked(true);
}
else {
newTrack->SetChannel(Track::RightChannel);
}
}
else {
newTrack->SetChannel( Track::MonoChannel );
}
// Let the list hold the track, and keep a pointer to it
newRecordingTracks.push_back(
static_cast<WaveTrack*>(
trackList->Add(
std::move(newTrack))));
}
}
//Automated Input Level Adjustment Initialization
#ifdef EXPERIMENTAL_AUTOMATED_INPUT_LEVEL_ADJUSTMENT
gAudioIO->AILAInitialize();
#endif
AudioIOStartStreamOptions options(p->GetDefaultPlayOptions());
int token = gAudioIO->StartStream(playbackTracks,
newRecordingTracks,
#ifdef EXPERIMENTAL_MIDI_OUT
midiTracks,
#endif
t0, t1, options);
bool success = (token != 0);
if (success) {
p->SetAudioIOToken(token);
mBusyProject = p;
}
else {
if (shifted) {
// Restore the tracks to remove any inserted silence
if (tracksCopied)
*trackList = std::move(tracksCopy);
}
else {
// msmeyer: Delete recently added tracks if opening stream fails
for (unsigned int i = 0; i < newRecordingTracks.size(); i++) {
trackList->Remove(newRecordingTracks[i]);
}
}
// msmeyer: Show error message if stream could not be opened
wxMessageBox(_("Error while opening sound device. Please check the recording device settings and the project sample rate."),
_("Error"), wxOK | wxICON_EXCLAMATION, this);
SetPlay(false);
SetStop(false);
SetRecord(false);
}
}
UpdateStatusBar(GetActiveProject());
}
bool ofxCrazyradio::init() {
int ret = libusb_init(&ctx_);
// std::cout << "libusb_init: " << ret << std::endl;
// libusb_set_debug(ctx_, 3);
bool found = false;
libusb_device **list;
ssize_t count = libusb_get_device_list(ctx_, &list);
// std::cout << "libusb_get_device_list: " << count << std::endl;
for (int i = 0; i < count; i++) {
struct libusb_device_descriptor desc;
ret = libusb_get_device_descriptor(list[i], &desc);
if (desc.idVendor == 0x1915 && desc.idProduct == 0x7777) {
found = true;
ret = libusb_open(list[i], &handle_);
// std::cout << "libusb_open: " << ret << std::endl;
// std::cout << "version: " << std::hex << desc.bcdDevice << std::dec << std::endl;
// uint8_t string_desc[256];
// ret = libusb_get_string_descriptor_ascii(handle_, desc.iManufacturer, string_desc, 256);
// std::cout << "libusb_get_string_descriptor_ascii: " << ret << std::endl;
// std::cout << string_desc << std::endl;
//
// for (int n = 0; n < desc.bNumConfigurations; n++) {
// libusb_config_descriptor *config_desc;
// const libusb_interface_descriptor *inter_desc;
// const libusb_endpoint_descriptor *ep_desc;
// const libusb_interface *inter;
// libusb_get_config_descriptor(list[i], n, &config_desc);
// std::cout << "config: " << (int)config_desc->bConfigurationValue << std::endl;
// std::cout << "bNumInterfaces: " << (int)config_desc->bNumInterfaces << std::endl;
// for (int i = 0; i < (int)config_desc->bNumInterfaces; i++) {
// inter = &config_desc->interface[i];
// std::cout << " num_altsetting: " << inter->num_altsetting << std::endl;
// for (int j = 0; j < inter->num_altsetting; j++) {
// inter_desc = &inter->altsetting[j];
// std::cout << " Interface number: " << (int)inter_desc->bInterfaceNumber << std::endl;
// std::cout << " number of endpoint: " << (int)inter_desc->bNumEndpoints << std::endl;
// for (int k = 0; k < (int)inter_desc->bNumEndpoints; k++) {
// ep_desc = &inter_desc->endpoint[k];
// std::cout << " desc type: " << (int)ep_desc->bDescriptorType << std::endl;
// std::cout << " ep address: " << (int)ep_desc->bEndpointAddress << std::endl;
// std::cout << " attributes: " << std::hex << (int)ep_desc->bmAttributes << std::dec << std::endl;
// }
// }
// }
// }
// ret = libusb_kernel_driver_active(handle_, 0);
// std::cout << "libusb_kernel_driver_active: " << ret << std::endl;
ret = libusb_claim_interface(handle_, 0);
// std::cout << "libusb_claim_interface: " << ret << std::endl;
libusb_set_configuration(handle_, 1);
SetDataRate(DR_250KPS);
SetChannel(2);
arc_ = -1;
SetContCarrier(false);
uint8_t address[] = "\xe7\xe7\xe7\xe7\xe7";
SetAddress(address);
SetPower(P_0DBM);
SetArc(3);
SetArdBytes(32);
break;
}
}
libusb_free_device_list(list, 1);
return found;
}
