TEST_F(Solver580DTest, Example4)
{
setInput("2 1 0 15 14");
Solver580D().run();
EXPECT_EQ("15", getOutput());
}
void MLProcRate::process(const int samples)
{
const MLSignal& x = getInput(1);
const MLSignal& ratioSig = getInput(2);
MLSignal& y = getOutput(1);
const float isr = getContextInvSampleRate();
const float kFeedback = isr*10.f;
// allow ratio change once per buffer
float rIn = ratioSig[samples - 1];
if (rIn != mFloatRatio)
{
mCorrectedRatio = correctRatio(rIn);
mFloatRatio = rIn;
}
// if input phasor is off, reset and return.
if(x[0] < 0.f)
{
mOmega = 0.f;
y.fill(-0.0001f);
return;
}
if(mCorrectedRatio)
{
// run the PLL, correcting the output phasor to the input phasor and ratio.
float r = mCorrectedRatio.getFloat();
float rInv = 1.0f/r;
float numerator = mCorrectedRatio.top;
float numeratorInv = 1.0f/numerator;
float error;
for (int n=0; n<samples; ++n)
{
float px = x[n];
float dxdt = px - mx1;
mx1 = px;
float dydt = ml::max(dxdt*r, 0.f);
float dxy = px - mOmega*rInv;
// get modOffset, such that phase difference is 0 at each integer value of modOffset
float modOffset = dxy*numerator;
// get error term, valid at any phase difference.
error = roundf(modOffset) - modOffset;
// convert back to absolute phase difference
error *= numeratorInv;
// feedback = negative error * time constant
dydt -= kFeedback*error;
// don't ever run clock backwards.
dydt = ml::max(dydt, 0.f);
// wrap phasor
mOmega += dydt;
if(mOmega >= 1.0f)
{
mOmega -= 1.0f;
}
y[n] = mOmega;
}
}
else
{
// don't correct the phase, just run phasor at float ratio of input rate.
for (int n=0; n<samples; ++n)
{
float px = x[n];
float dxdt = px - mx1;
mx1 = px;
float dydt = ml::max(dxdt*mFloatRatio, 0.f);
// wrap phasor
mOmega += dydt;
if(mOmega >= 1.0f)
{
mOmega -= 1.0f;
}
y[n] = mOmega;
}
}
}
BOOL BuildGUI(char *screenname) {
Object **ar = Window_Objs;
struct Screen *screen;
BOOL OptionFrame = FALSE;
LONG indicatorwidth = 100;
UpdateStrings();
// Kludge for Piccaso 96/BGUI.
if(FindTask("Picasso96"))
{
PopUpMenus = FALSE;
}
BGUIBase = (void *)OpenLibrary("bgui.library", 41);
if(BGUIBase == NULL) {
Printf((char *) msgTextNoOpen, (ULONG) "bgui.library", 41);
Printf("\n");
return FALSE;
}
screen = LockPubScreen(screenname);
indicatorwidth = max(indicatorwidth, 16 * screen->RastPort.Font->tf_XSize);
if(screen->Height > 240) {
OptionFrame = TRUE;
}
WO_Window = WindowObject,
WINDOW_PubScreen, screen,
WINDOW_Title, (char *) msgTextProgramName,
WINDOW_CloseGadget, FALSE,
WINDOW_MenuStrip, Menus,
WINDOW_AutoAspect, TRUE,
WINDOW_AutoKeyLabel, TRUE,
WINDOW_ScaleWidth, 60,
WINDOW_ScaleHeight, 20,
WINDOW_HelpFile, HELPFILE,
WINDOW_HelpNode, "AHI",
WINDOW_IDCMPHook, &IDCMPhook,
WINDOW_IDCMPHookBits, IDCMP_RAWKEY,
WINDOW_MasterGroup, VGroupObject, NormalOffset,
/* TABS */
StartMember, ar[ACTID_TABS] = MxObject,
MX_Labels, PageNames,
MX_TabsObject, TRUE,
GA_ID, ACTID_TABS,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_PAGE] = PageObject, NormalSpacing,
PAGE_NoBufferRP, TRUE,
/* PAGE 1 */
PageMember, HGroupObject, NormalOffset, NormalSpacing, TabAboveFrame,
StartMember, vgroup = VGroupObject, NormalSpacing,
StartMember, ar[ACTID_UNIT] = CycleObject,
CYC_Labels, Units,
CYC_Active, state.UnitSelected,
CYC_PopActive, PopUpMenus,
CYC_Popup, PopUpMenus,
GA_ID, ACTID_UNIT,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_MODE] = ListviewObject,
// LISTV_EntryArray, Modes,
// LISTV_Select, state.ModeSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_MODE,
EndObject, EndMember,
StartMember, HGroupObject,
ButtonFrame, FRM_Flags, FRF_RECESSED,
StartMember, InfoObject,
INFO_TextFormat, (char *) msgProperties,
INFO_FixTextWidth,TRUE,
INFO_MinLines, 6,
EndObject, FixMinWidth, EndMember,
StartMember, ar[SHOWID_MODE] = InfoObject,
INFO_MinLines, 6,
EndObject, EndMember,
EndObject, FixMinHeight, EndMember,
EndObject /* vgroup */, EndMember,
StartMember, VGroupObject, NormalSpacing,
VarSpace(1),
StartMember, VGroupObject,
(OptionFrame ? GROUP_HorizOffset : TAG_IGNORE), GRSPACE_NORMAL,
(OptionFrame ? GROUP_VertOffset : TAG_IGNORE), GRSPACE_NORMAL,
(OptionFrame ? GROUP_Spacing : TAG_IGNORE), GRSPACE_NORMAL,
(OptionFrame ? FRM_Type : TAG_IGNORE), FRTYPE_RIDGE,
(OptionFrame ? FRM_Flags : TAG_IGNORE), FRF_RECESSED,
(OptionFrame ? FRM_Title : TAG_IGNORE), (char *) msgOptions,
StartMember, HGroupObject,
StartMember, ar[ACTID_FREQ] = SliderObject,
LAB_Label, (char *) msgOptFrequency,
SLIDER_Min, 0,
SLIDER_Max, state.Frequencies -1 ,
SLIDER_Level, state.FreqSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_FREQ,
EndObject, EndMember,
StartMember, ar[SHOWID_FREQ] = InfoObject,
INFO_TextFormat, getFreq(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_CHANNELS] = SliderObject,
LAB_Label, (char *) msgOptChannels,
SLIDER_Min, 1,
SLIDER_Max, state.Channels,
SLIDER_Level, state.ChannelsSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_CHANNELS,
EndObject, EndMember,
StartMember, ar[SHOWID_CHANNELS] = InfoObject,
INFO_TextFormat, getChannels(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_OUTVOL] = SliderObject,
LAB_Label, (char *) msgOptVolume,
SLIDER_Min, 0,
SLIDER_Max, state.OutVols-1 ,
SLIDER_Level, state.OutVolSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_OUTVOL,
EndObject, EndMember,
StartMember, ar[SHOWID_OUTVOL] = InfoObject,
INFO_TextFormat, getOutVol(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_MONVOL] = SliderObject,
LAB_Label, (char *) msgOptMonitor,
SLIDER_Min, 0,
SLIDER_Max, state.MonVols-1 ,
SLIDER_Level, state.MonVolSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_MONVOL,
EndObject, EndMember,
StartMember, ar[SHOWID_MONVOL] = InfoObject,
INFO_TextFormat, getMonVol(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_GAIN] = SliderObject,
LAB_Label, (char *) msgOptGain,
SLIDER_Min, 0,
SLIDER_Max, state.Gains-1 ,
SLIDER_Level, state.GainSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_GAIN,
EndObject, EndMember,
StartMember, ar[SHOWID_GAIN] = InfoObject,
INFO_TextFormat, getGain(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_INPUT] = SliderObject,
LAB_Label, (char *) msgOptInput,
SLIDER_Min, 0,
SLIDER_Max, state.Inputs-1 ,
SLIDER_Level, state.InputSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_INPUT,
EndObject, EndMember,
StartMember, ar[SHOWID_INPUT] = InfoObject,
INFO_TextFormat, getInput(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
StartMember, HGroupObject,
StartMember, ar[ACTID_OUTPUT] = SliderObject,
LAB_Label, (char *) msgOptOutput,
SLIDER_Min, 0,
SLIDER_Max, state.Outputs-1 ,
SLIDER_Level, state.OutputSelected,
PGA_NewLook, TRUE,
GA_ID, ACTID_OUTPUT,
EndObject, EndMember,
StartMember, ar[SHOWID_OUTPUT] = InfoObject,
INFO_TextFormat, getOutput(),
INFO_VertOffset, 0,
EndObject, FixWidth(indicatorwidth), EndMember,
EndObject, FixMinHeight, EndMember,
EndObject /* vgroup "Options" */, FixMinHeight, EndMember,
VarSpace(1),
EndObject /* vgroup */, EndMember,
EndObject, /* (EndMember) page */
/* PAGE 2 */
PageMember, HGroupObject, NormalSpacing, TabAboveFrame,
VarSpace(1),
StartMember, VGroupObject, NormalSpacing,
VarSpace(1),
StartMember, VGroupObject, NormalOffset, NormalSpacing,
RidgeFrame, FRM_Flags, FRF_RECESSED, FrameTitle((char *) msgGlobalOptions),
StartMember, HGroupObject, NormalSpacing,
StartMember, VGroupObject, NormalSpacing,
StartMember, ar[ACTID_DEBUG] = CycleObject,
LAB_Label, (char *) msgGlobOptDebugLevel,
LAB_Place, PLACE_LEFT,
CYC_Labels, DebugLabels,
CYC_Active, globalprefs.ahigp_DebugLevel,
CYC_PopActive, PopUpMenus,
CYC_Popup, PopUpMenus,
GA_ID, ACTID_DEBUG,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_ECHO] = CycleObject,
LAB_Label, (char *) msgGlobOptEcho,
LAB_Place, PLACE_LEFT,
CYC_Labels, EchoLabels,
CYC_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) |
(globalprefs.ahigp_FastEcho ? 1 : 0),
CYC_PopActive, PopUpMenus,
CYC_Popup, PopUpMenus,
GA_ID, ACTID_ECHO,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_SURROUND] = CycleObject,
LAB_Label, (char *) msgGlobOptSurround,
LAB_Place, PLACE_LEFT,
CYC_Labels, SurroundLabels,
CYC_Active, globalprefs.ahigp_DisableSurround,
GA_ID, ACTID_SURROUND,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_CLIPMV] = CycleObject,
LAB_Label, (char *) msgGlobOptMasterVol,
LAB_Place, PLACE_LEFT,
CYC_Labels, ClipMVLabels,
CYC_Active, globalprefs.ahigp_ClipMasterVolume,
GA_ID, ACTID_CLIPMV,
EndObject, FixMinHeight, EndMember,
StartMember, ar[ACTID_CPULIMIT] = SliderObject,
LAB_Label, (char *) msgGlobOptCPULimit,
SLIDER_Min, 0,
SLIDER_Max, 100,
SLIDER_Level, (globalprefs.ahigp_MaxCPU * 100 + 32768) >> 16,
PGA_NewLook, TRUE,
GA_ID, ACTID_CPULIMIT,
EndObject, EndMember,
EndObject /* vgroup */, EndMember,
StartMember, VGroupObject, NormalSpacing,
VarSpace(1),
StartMember, ar[SHOWID_CPULIMIT] = IndicatorObject,\
INDIC_Min, 0,
INDIC_Max, 100,
INDIC_Level, (globalprefs.ahigp_MaxCPU * 100 + 32768) / 65536,
INDIC_Justification, IDJ_LEFT,
INDIC_FormatString, "%ld%%",
EndObject, FixMinWidth, FixMinHeight, EndMember,
EndObject /* vgroup */, EndMember,
EndObject /* hgroup */, EndMember,
EndObject, FixMinWidth, FixMinHeight, EndMember,
VarSpace(1),
EndObject /* vgroup */ , FixMinWidth, EndMember,
VarSpace(1),
EndObject, /* (EndMember) page */
EndObject /* page */, EndMember,
/* BUTTONS */
StartMember, HGroupObject, NormalSpacing, NormalVOffset,
StartMember, ar[ACTID_SAVE] = ButtonObject,
ButtonFrame,
LAB_Label, (char *) msgButtonSave,
GA_ID, ACTID_SAVE,
EndObject, EndMember,
StartMember, ar[ACTID_USE] = ButtonObject,
ButtonFrame,
LAB_Label, (char *) msgButtonUse,
GA_ID, ACTID_USE,
EndObject, EndMember,
StartMember, ar[ACTID_QUIT] = ButtonObject,
ButtonFrame,
LAB_Label, (char *) msgButtonCancel,
GA_ID, ACTID_QUIT,
EndObject, EndMember,
EndObject, FixMinHeight, EndMember,
EndObject,
EndObject;
if(WO_Window) {
AddMap( ar[ACTID_TABS], ar[ACTID_PAGE], pagemap );
DoMethod( ar[ACTID_FREQ], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_CHANNELS], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_OUTVOL], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_MONVOL], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_GAIN], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_INPUT], BASE_ADDHOOK, &GadgetHook );
DoMethod( ar[ACTID_OUTPUT], BASE_ADDHOOK, &GadgetHook );
AddMap( ar[ACTID_CPULIMIT], ar[SHOWID_CPULIMIT], cpumap);
window = WindowOpen(WO_Window);
}
if(screen) {
UnlockPubScreen(NULL, screen);
}
if(window == NULL) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
openreq = FileReqObject,
ASLFR_Window, window,
ASLFR_SleepWindow, TRUE,
ASLFR_RejectIcons, TRUE,
ASLFR_InitialDrawer, "SYS:Prefs/Presets",
EndObject;
savereq = FileReqObject,
ASLFR_Window, window,
ASLFR_SleepWindow, TRUE,
ASLFR_RejectIcons, TRUE,
ASLFR_InitialDrawer, "SYS:Prefs/Presets",
ASLFR_DoSaveMode, TRUE,
EndObject;
if((openreq == NULL) || (savereq == NULL)) {
Printf((char *) msgTextNoFileRequester);
Printf("\n");
return FALSE;
}
// Update the checkmark for "Create Icons?"
{
struct Menu *menu = NULL;
struct MenuItem *item;
GetAttr( WINDOW_MenuStrip, WO_Window, (ULONG *) &menu);
ClearMenuStrip(window);
item = FindMenuItem(ACTID_ICONS);
if(item) {
if(SaveIcons)
item->Flags |= CHECKED;
else
item->Flags &= ~CHECKED;
}
ResetMenuStrip(window, menu);
}
GUINewUnit();
return TRUE;
}
bool licence(int argc, char* argv[])
{
bool help = false;
char* desc = 0;
char* author = 0;
char* year = 0;
for(int i = 0; i < argc; ++i)
{
if(::strncmp(argv[i], "-y", 2) == 0)
year = argv[i] + 2;
else if(::strncmp(argv[i], "-a", 2) == 0)
author = argv[i] + 2;
else if(::strncmp(argv[i], "-d", 2) == 0)
desc = argv[i] + 2;
else if(::strcmp(argv[i], "-h") == 0)
help = true;
else
{
getOutput() << "Unkown parameter : \"" << argv[i] << "\"" << std::endl;
help = true;
}
}
if(help)
{
getOutput() << "Help :" << std::endl;
getOutput() << " Produce a GNU GENERAL PUBLIC LICENCE (GPLv2) in US_en" << std::endl;
getOutput() << " -h : Display this help" << std::endl;
getOutput() << " -d<description> ; \"-d<...>\" : Set the description" << std::endl;
getOutput() << " -a<author> : Set the author's name" << std::endl;
getOutput() << " -y<year> : Set the year" << std::endl;
return true;
}
if(!desc)
getOutput() << "/!\\ Description is not set!" << std::endl;
if(!author)
getOutput() << "/!\\ Author is not set!" << std::endl;
if(!year)
getOutput() << "/!\\ Year is not set!" << std::endl;
if(desc && author && year)
{
char licence1Path[strlen(LICENCE_1_PATH) + 2 + strlen(appRoot)];
sprintf(licence1Path, "%s\\%s", appRoot, LICENCE_1_PATH);
char licence2Path[strlen(LICENCE_2_PATH) + 2 + strlen(appRoot)];
sprintf(licence2Path, "%s\\%s", appRoot, LICENCE_2_PATH);
getOutput() << licence2Path << std::endl;
std::ifstream licence1Stream(licence1Path, std::ios::binary);
std::ifstream licence2Stream(licence2Path, std::ios::binary);
std::ofstream licenceStream("LICENCE", std::ios::binary);
licenceStream << licence1Stream.rdbuf();
licenceStream << desc << std::endl;
licenceStream << " Copyright (C) ";
licenceStream << year << " ";
licenceStream << author << std::endl;
licenceStream << licence2Stream.rdbuf();
licenceStream.close();
licence1Stream.close();
licence2Stream.close();
return true;
}
else
return false;
}
static void GUINewMode(void) {
int Max, Sel;
sprintf(modetext,"0x%08lx", getAudioMode());
infoargs[0] = modetext;
infoargs[1] = getRecord();
infoargs[2] = getAuthor();
infoargs[3] = getCopyright();
sprintf(drivertext, "Devs:AHI/%s.audio", getDriver());
infoargs[4] = drivertext;
infoargs[5] = getVersion();
MySetGadgetAttrs(Window_Objs[SHOWID_MODE],
LISTBROWSER_Labels, ~0,
TAG_DONE);
if(infolist) FreeBrowserNodes2(infolist);
infolist = BrowserNodes2(infotexts, infoargs);
MySetGadgetAttrs(Window_Objs[SHOWID_MODE],
LISTBROWSER_Labels, infolist,
TAG_DONE);
Max = max(state.Frequencies -1, 0);
Sel = min(Max, state.FreqSelected);
MySetGadgetAttrs(Window_Objs[ACTID_FREQ],
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Channels, 1);
Sel = min(Max, state.ChannelsSelected);
MySetGadgetAttrs(Window_Objs[ACTID_CHANNELS],
SLIDER_Min, 1,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 1) || state.ChannelsDisabled,
TAG_DONE );
Max = max(state.OutVols -1, 0);
Sel = min(Max, state.OutVolSelected);
MySetGadgetAttrs(Window_Objs[ACTID_OUTVOL],
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.MonVols -1, 0);
Sel = min(Max, state.MonVolSelected);
MySetGadgetAttrs(Window_Objs[ACTID_MONVOL],
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Gains -1, 0);
Sel = min(Max, state.GainSelected);
MySetGadgetAttrs(Window_Objs[ACTID_GAIN],
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Inputs -1, 0);
Sel = min(Max, state.InputSelected);
MySetGadgetAttrs(Window_Objs[ACTID_INPUT],
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Outputs -1, 0);
Sel = min(Max, state.OutputSelected);
MySetGadgetAttrs(Window_Objs[ACTID_OUTPUT],
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
// Update indicators..
MySetGadgetAttrs(Window_Objs[SHOWID_FREQ],
GA_Text, getFreq(), TAG_DONE );
MySetGadgetAttrs(Window_Objs[SHOWID_CHANNELS],
GA_Text, getChannels(), TAG_DONE );
MySetGadgetAttrs(Window_Objs[SHOWID_OUTVOL],
GA_Text, getOutVol(), TAG_DONE );
MySetGadgetAttrs(Window_Objs[SHOWID_MONVOL],
GA_Text, getMonVol(), TAG_DONE );
MySetGadgetAttrs(Window_Objs[SHOWID_GAIN],
GA_Text, getGain(), TAG_DONE );
MySetGadgetAttrs(Window_Objs[SHOWID_INPUT],
GA_Text, getInput(), TAG_DONE );
MySetGadgetAttrs(Window_Objs[SHOWID_OUTPUT],
GA_Text, getOutput(), TAG_DONE );
}
BOOL BuildGUI(char *screenname)
{
Object *MUISave, *MUIUse, *MUICancel;
Object *page1,*page2;
Object *MUITFreq,*MUITChannels,*MUITOutvol,*MUITMonvol,*MUITGain,*MUITInput,*MUITOutput,*MUITDebug,*MUITEcho,*MUITSurround,*MUITClipvol,*MUITCpu,*MUITACTime;
UpdateStrings();
MUIMasterBase = (void *)OpenLibrary("muimaster.library", MUIMASTER_VLATEST);
if(MUIMasterBase == NULL)
{
Printf((char *) msgTextNoOpen, (ULONG) "muimaster.library", MUIMASTER_VLATEST);
Printf("\n");
return FALSE;
}
page1 = HGroup,
Child, VGroup,
Child, MUIUnit = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, Units,
MUIA_Cycle_Active, state.UnitSelected,
End,
Child, ListviewObject,
MUIA_CycleChain, 1,
MUIA_Listview_List, MUIList = ListObject,
InputListFrame,
MUIA_List_AutoVisible, TRUE,
End,
End,
Child, HGroup,
ReadListFrame,
MUIA_Background, MUII_TextBack,
Child, TextObject,
MUIA_Text_Contents, msgProperties,
MUIA_Text_SetMax, TRUE,
End,
Child, MUIInfos = TextObject,
MUIA_Text_Contents, "\n\n\n\n\n",
MUIA_Text_SetMin, FALSE,
End,
End,
End,
Child, BalanceObject,
End,
Child, VGroup,
Child, HVSpace,
Child, ColGroup(3),
GroupFrameT(msgOptions),
Child, MUITFreq = SpecialButton((STRPTR)msgOptFrequency),
Child, MUIFreq = SpecialSlider(0,max(state.Frequencies-1,0),state.FreqSelected),
Child, MUILFreq = SpecialLabel(getFreq()),
Child, MUITChannels = SpecialButton((STRPTR)msgOptChannels),
Child, MUIChannels = SpecialSlider(1,state.Channels,state.ChannelsSelected),
Child, MUILChannels = SpecialLabel(getChannels()),
Child, MUITOutvol = SpecialButton((STRPTR)msgOptVolume),
Child, MUIOutvol = SpecialSlider(0,max(state.OutVols-1,0),state.OutVolSelected),
Child, MUILOutvol = SpecialLabel(getOutVol()),
Child, MUITMonvol = SpecialButton((STRPTR)msgOptMonitor),
Child, MUIMonvol = SpecialSlider(0,max(state.MonVols-1,1),state.MonVolSelected),
Child, MUILMonvol = SpecialLabel(getMonVol()),
Child, MUITGain = SpecialButton((STRPTR)msgOptGain),
Child, MUIGain = SpecialSlider(0,max(state.Gains-1,0),state.GainSelected),
Child, MUILGain = SpecialLabel(getGain()),
Child, MUITInput = SpecialButton((STRPTR)msgOptInput),
Child, MUIInput = SpecialSlider(0,max(state.Inputs-1,0),state.InputSelected),
Child, MUILInput = SpecialLabel(getInput()),
Child, MUITOutput = SpecialButton((STRPTR)msgOptOutput),
Child, MUIOutput = SpecialSlider(0,max(state.Outputs-1,0),state.OutputSelected),
Child, MUILOutput = SpecialLabel(getOutput()),
End,
Child, HVSpace,
End,
End;
page2 = VGroup,
Child, HVSpace,
Child, HGroup,
Child, HVSpace,
Child, ColGroup(2),
GroupFrameT(msgGlobalOptions),
Child, MUITDebug = SpecialButton((STRPTR)msgGlobOptDebugLevel),
Child, MUIDebug = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, DebugLabels,
MUIA_Cycle_Active, globalprefs.ahigp_DebugLevel,
End,
Child, MUITEcho = SpecialButton((STRPTR)msgGlobOptEcho),
Child, MUIEcho = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, EchoLabels,
MUIA_Cycle_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) | (globalprefs.ahigp_FastEcho ? 1 : 0),
End,
Child, MUITSurround = SpecialButton((STRPTR)msgGlobOptSurround),
Child, MUISurround = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, SurroundLabels,
MUIA_Cycle_Active, globalprefs.ahigp_DisableSurround,
End,
Child, MUITClipvol = SpecialButton((STRPTR)msgGlobOptMasterVol),
Child, MUIClipvol = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, ClipMVLabels,
MUIA_Cycle_Active, globalprefs.ahigp_ClipMasterVolume,
End,
Child, MUITCpu = SpecialButton((STRPTR)msgGlobOptCPULimit),
Child, MUICpu = SliderObject,
MUIA_CycleChain, 1,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Min, 0,
MUIA_Numeric_Max, 100,
MUIA_Numeric_Value,(globalprefs.ahigp_MaxCPU * 100 + 32768) / 65536,
MUIA_Numeric_Format,"%ld%%",
End,
Child, MUITACTime = SpecialButton((STRPTR)msgGlobOptACTime),
Child, MUIACTime = SliderObject,
MUIA_CycleChain, 1,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Min, 0,
MUIA_Numeric_Max, 100,
MUIA_Numeric_Value,(globalprefs.ahigp_AntiClickTime * 1000 + 32768) >> 16,
MUIA_Numeric_Format,"%ld% ms",
End,
End,
Child, HVSpace,
End,
Child, HVSpace,
End;
MUIApp = ApplicationObject,
MUIA_Application_Title, (char *) msgTextProgramName,
MUIA_Application_Version, Version,
MUIA_Application_Copyright, "©1996-1999 Martin Blom",
MUIA_Application_Author, "Stéphane Barbaray/Martin Blom",
MUIA_Application_Base, "AHI",
MUIA_Application_HelpFile, HELPFILE,
MUIA_Application_Menustrip, MUIMenu = MUI_MakeObject(MUIO_MenustripNM,Menus,0),
MUIA_Application_SingleTask, TRUE,
SubWindow, MUIWindow = WindowObject,
MUIA_Window_Title, (char *) msgTextProgramName,
MUIA_Window_ID , MAKE_ID('M','A','I','N'),
MUIA_HelpNode, "AHI",
WindowContents, VGroup,
Child, RegisterGroup(PageNames),
MUIA_CycleChain, 1,
Child, page1,
Child, page2,
End,
Child, HGroup,
Child, MUISave = SimpleButton(msgButtonSave),
Child, MUIUse = SimpleButton(msgButtonUse),
Child, MUICancel = SimpleButton(msgButtonCancel),
End,
End,
End,
End;
if( MUIApp != NULL )
{
APTR item = (APTR)DoMethod(MUIMenu,MUIM_FindUData,ACTID_ICONS);
if(item)
{
set(item, MUIA_Menuitem_Checked, SaveIcons);
}
DoMethod(MUIWindow, MUIM_MultiSet, MUIA_Text_PreParse,"\033l",MUILFreq,MUILChannels,MUILOutvol,MUILMonvol,MUILGain,MUILInput,MUILOutput,NULL);
DoMethod(MUIWindow, MUIM_MultiSet, MUIA_CycleChain, 1, MUISave,MUIUse,MUICancel,NULL);
DoMethod(MUITFreq, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIFreq);
DoMethod(MUITChannels, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIChannels);
DoMethod(MUITOutvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutvol);
DoMethod(MUITMonvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIMonvol);
DoMethod(MUITGain, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIGain);
DoMethod(MUITInput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIInput);
DoMethod(MUITOutput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutput);
DoMethod(MUITDebug, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIDebug);
DoMethod(MUITEcho, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIEcho);
DoMethod(MUITSurround, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUISurround);
DoMethod(MUITClipvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIClipvol);
DoMethod(MUITCpu, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUICpu);
DoMethod(MUITACTime, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIACTime);
DoMethod(MUIWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(MUISave, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SAVE);
DoMethod(MUIUse, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_USE);
DoMethod(MUICancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(MUIUnit, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_UNIT);
DoMethod(MUIList, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_MODE);
DoMethod(MUIDebug, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_DEBUG);
DoMethod(MUISurround, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SURROUND);
DoMethod(MUIEcho, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_ECHO);
DoMethod(MUICpu, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_CPULIMIT);
DoMethod(MUIClipvol, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_CLIPMV);
DoMethod(MUIACTime, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_ACTIME);
DoMethod(MUIFreq, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIChannels, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIOutvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIMonvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIGain, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIInput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIOutput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
set(MUIWindow, MUIA_Window_Open, TRUE);
GUINewUnit();
return TRUE;
}
return FALSE;
}
void Log::flush()
{
fflush(getOutput());
}
status_t BnAudioPolicyService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case SET_DEVICE_CONNECTION_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_devices_t device =
static_cast <audio_devices_t>(data.readInt32());
audio_policy_dev_state_t state =
static_cast <audio_policy_dev_state_t>(data.readInt32());
const char *device_address = data.readCString();
reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
state,
device_address)));
return NO_ERROR;
} break;
case GET_DEVICE_CONNECTION_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_devices_t device =
static_cast<audio_devices_t> (data.readInt32());
const char *device_address = data.readCString();
reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
device_address)));
return NO_ERROR;
} break;
case SET_PHONE_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
reply->writeInt32(static_cast <uint32_t>(setPhoneState(
(audio_mode_t) data.readInt32())));
return NO_ERROR;
} break;
case SET_FORCE_USE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
data.readInt32());
audio_policy_forced_cfg_t config =
static_cast <audio_policy_forced_cfg_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
return NO_ERROR;
} break;
case GET_FORCE_USE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
data.readInt32());
reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
return NO_ERROR;
} break;
case GET_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
uint32_t samplingRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
audio_output_flags_t flags =
static_cast <audio_output_flags_t>(data.readInt32());
audio_io_handle_t output = getOutput(stream,
samplingRate,
format,
channelMask,
flags);
reply->writeInt32(static_cast <int>(output));
return NO_ERROR;
} break;
case START_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
uint32_t stream = data.readInt32();
int session = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(startOutput(output,
(audio_stream_type_t)stream,
session)));
return NO_ERROR;
} break;
case STOP_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
uint32_t stream = data.readInt32();
int session = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(stopOutput(output,
(audio_stream_type_t)stream,
session)));
return NO_ERROR;
} break;
case RELEASE_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
releaseOutput(output);
return NO_ERROR;
} break;
case GET_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_source_t inputSource = (audio_source_t) data.readInt32();
uint32_t samplingRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
int audioSession = data.readInt32();
audio_io_handle_t input = getInput(inputSource,
samplingRate,
format,
channelMask,
audioSession);
reply->writeInt32(static_cast <int>(input));
return NO_ERROR;
} break;
case START_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(startInput(input)));
return NO_ERROR;
} break;
case STOP_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(stopInput(input)));
return NO_ERROR;
} break;
case RELEASE_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
releaseInput(input);
return NO_ERROR;
} break;
case INIT_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
int indexMin = data.readInt32();
int indexMax = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
return NO_ERROR;
} break;
case SET_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
int index = data.readInt32();
audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
index,
device)));
return NO_ERROR;
} break;
case GET_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
int index;
status_t status = getStreamVolumeIndex(stream, &index, device);
reply->writeInt32(index);
reply->writeInt32(static_cast <uint32_t>(status));
return NO_ERROR;
} break;
case GET_STRATEGY_FOR_STREAM: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
reply->writeInt32(getStrategyForStream(stream));
return NO_ERROR;
} break;
case GET_DEVICES_FOR_STREAM: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
return NO_ERROR;
} break;
case GET_OUTPUT_FOR_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
effect_descriptor_t desc;
data.read(&desc, sizeof(effect_descriptor_t));
audio_io_handle_t output = getOutputForEffect(&desc);
reply->writeInt32(static_cast <int>(output));
return NO_ERROR;
} break;
case REGISTER_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
effect_descriptor_t desc;
data.read(&desc, sizeof(effect_descriptor_t));
audio_io_handle_t io = data.readInt32();
uint32_t strategy = data.readInt32();
int session = data.readInt32();
int id = data.readInt32();
reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
io,
strategy,
session,
id)));
return NO_ERROR;
} break;
case UNREGISTER_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int id = data.readInt32();
reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
return NO_ERROR;
} break;
case SET_EFFECT_ENABLED: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int id = data.readInt32();
bool enabled = static_cast <bool>(data.readInt32());
reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
return NO_ERROR;
} break;
case IS_STREAM_ACTIVE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
uint32_t inPastMs = (uint32_t)data.readInt32();
reply->writeInt32( isStreamActive((audio_stream_type_t) stream, inPastMs) );
return NO_ERROR;
} break;
case IS_STREAM_ACTIVE_REMOTELY: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
uint32_t inPastMs = (uint32_t)data.readInt32();
reply->writeInt32( isStreamActiveRemotely((audio_stream_type_t) stream, inPastMs) );
return NO_ERROR;
} break;
case IS_SOURCE_ACTIVE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_source_t source = (audio_source_t) data.readInt32();
reply->writeInt32( isSourceActive(source));
return NO_ERROR;
}
case QUERY_DEFAULT_PRE_PROCESSING: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int audioSession = data.readInt32();
uint32_t count = data.readInt32();
uint32_t retCount = count;
effect_descriptor_t *descriptors =
(effect_descriptor_t *)new char[count * sizeof(effect_descriptor_t)];
status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
reply->writeInt32(status);
if (status != NO_ERROR && status != NO_MEMORY) {
retCount = 0;
}
reply->writeInt32(retCount);
if (retCount) {
if (retCount < count) {
count = retCount;
}
reply->write(descriptors, sizeof(effect_descriptor_t) * count);
}
delete[] descriptors;
return status;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
// LEARNING FUNCTION: add new patterns and run optimization steps selected with adaptative schedule
virtual int add (int x_id, int yi)
{
++nb_seen_examples;
// create a new output object if this one has never been seen before
if (!getOutput (yi))
{
outputs.insert (std::make_pair (yi, LaRankOutput ()));
LaRankOutput *cur = getOutput (yi);
cur->initialize (kfunc, cache);
if (outputs.size () == 1)
y0 = outputs.begin ()->first;
// link the cache of this new output to a buddy
if (outputs.size () > 1)
{
LaRankOutput *out0 = getOutput (y0);
cur->set_kernel_buddy (out0->getKernel ());
}
}
LaRankPattern tpattern (x_id, yi);
LaRankPattern & pattern = (patterns.isPattern (x_id)) ? patterns.getPattern (x_id) : tpattern;
// ProcessNew with the "fresh" pattern
double time1 = getTime ();
process_return_t pro_ret = process (pattern, processNew);
double dual_increase = pro_ret.dual_increase;
double duration = (getTime () - time1);
double coeff = dual_increase / (0.00001 + duration);
dual += dual_increase;
n_pro++;
w_pro = 0.05 * coeff + (1 - 0.05) * w_pro;
// ProcessOld & Optimize until ready for a new processnew
// (Adaptative schedule here)
for (;;)
{
double w_sum = w_pro + w_rep + w_opt;
double prop_min = w_sum / 20;
if (w_pro < prop_min)
w_pro = prop_min;
if (w_rep < prop_min)
w_rep = prop_min;
if (w_opt < prop_min)
w_opt = prop_min;
w_sum = w_pro + w_rep + w_opt;
double r = rand () / (double) RAND_MAX * w_sum;
if (r <= w_pro)
{
break;
}
else if ((r > w_pro) && (r <= w_pro + w_rep)) // ProcessOld here
{
double time1 = getTime ();
double dual_increase = reprocess ();
double duration = (getTime () - time1);
double coeff = dual_increase / (0.00001 + duration);
dual += dual_increase;
n_rep++;
w_rep = 0.05 * coeff + (1 - 0.05) * w_rep;
}
else // Optimize here
{
double time1 = getTime ();
double dual_increase = optimize ();
double duration = (getTime () - time1);
double coeff = dual_increase / (0.00001 + duration);
dual += dual_increase;
n_opt++;
w_opt = 0.05 * coeff + (1 - 0.05) * w_opt;
}
}
if (nb_seen_examples % 100 == 0) // Cleanup useless Support Vectors/Patterns sometimes
nb_removed += cleanup ();
return pro_ret.ypred;
}
void ScalarSensor::initialize() {
encodedOutput_ = getOutput("encoded");
bucketOutput_ = getOutput("bucket");
}
//TODO: See the processing function below for a more detailed explanation - can't send so many setParam commands in a row
void ADAFRUITBLE::handleTick() {
MotorController* motorController = DeviceManager::getInstance()->getMotorController();
Throttle *accelerator = DeviceManager::getInstance()->getAccelerator();
Throttle *brake = DeviceManager::getInstance()->getBrake();
BatteryManager *bms = reinterpret_cast<BatteryManager *>(DeviceManager::getInstance()->getDeviceByType(DEVICE_BMS));
uint32_t ms = millis();
uint32_t IOTemp = 0;
uint8_t brklt;
tickCounter++;
if (ms < 1000) return; //wait 1 seconds for things to settle before doing a thing
// Do a delayed parameter load once about a second after startup
if (!didParamLoad && ms > 5000) {
loadParameters();
Logger::console("BLE characteristics loaded...");
bleBitFields.bitfield1 = motorController->getStatusBitfield1();
bleBitFields.bitfield2 = motorController->getStatusBitfield2();
bleBitFields.doUpdate = 1;
// DeviceManager::getInstance()->updateWifiByID(BRUSA_DMC5);
didParamLoad = true;
}
if (paramCache.timeRunning != (ms / 1000))
{
paramCache.timeRunning = ms / 1000;
if (!gatt.setChar(MeasureCharId[0], (uint8_t*)¶mCache.timeRunning, 4))
{
Logger::error("Could not update timeRunning");
}
else Logger::debug(ADABLUE, "Updated timeRunning");
dumpRawData((uint8_t *)¶mCache.timeRunning, 4);
}
//every other time - 80ms by default
if (tickCounter & 1)
{
if (motorController) {
if ( bleTrqReqAct.torqueRequested != motorController->getTorqueRequested() ) {
bleTrqReqAct.torqueRequested = motorController->getTorqueRequested();
bleTrqReqAct.doUpdate = 1;
}
if ( bleTrqReqAct.torqueActual != motorController->getTorqueActual() ) {
bleTrqReqAct.torqueActual = motorController->getTorqueActual();
bleTrqReqAct.doUpdate = 1;
}
if ( bleSpeeds.speedRequested != motorController->getSpeedRequested() ) {
bleSpeeds.speedRequested = motorController->getSpeedRequested();
bleSpeeds.doUpdate = 1;
}
if ( bleSpeeds.speedActual != motorController->getSpeedActual() ) {
bleSpeeds.speedActual = motorController->getSpeedActual();
bleSpeeds.doUpdate = 1;
}
}
if (accelerator) {
RawSignalData *rawSignal = accelerator->acquireRawSignal();
if ( bleThrBrkLevels.throttleRawLevel1 != rawSignal->input1)
{
bleThrBrkLevels.throttleRawLevel1 = rawSignal->input1;
bleThrBrkLevels.doUpdate = 1;
}
if ( bleThrBrkLevels.throttleRawLevel2 != rawSignal->input2)
{
bleThrBrkLevels.throttleRawLevel2 = rawSignal->input2;
bleThrBrkLevels.doUpdate = 1;
}
if (bleThrBrkLevels.throttlePercentage != accelerator->getLevel() / 10)
{
bleThrBrkLevels.throttlePercentage = accelerator->getLevel() / 10;
bleThrBrkLevels.doUpdate = 1;
}
}
if (brake) {
RawSignalData *rawSignal = brake->acquireRawSignal();
if (bleThrBrkLevels.brakeRawLevel != rawSignal->input1) {
bleThrBrkLevels.brakeRawLevel = rawSignal->input1;
paramCache.brakeNotAvailable = false;
bleThrBrkLevels.doUpdate = 1;
}
if (bleThrBrkLevels.brakePercentage != brake->getLevel() / 10) {
bleThrBrkLevels.brakePercentage = brake->getLevel() / 10;
bleThrBrkLevels.doUpdate = 1;
}
} else {
if ( paramCache.brakeNotAvailable == true ) {
paramCache.brakeNotAvailable = false; // no need to keep sending this
bleThrBrkLevels.brakeRawLevel = 0;
bleThrBrkLevels.doUpdate = 1;
}
}
}
if (tickCounter == 2) {
if (bms)
{
if (blePowerStatus.SOC != bms->getSOC())
{
blePowerStatus.SOC = bms->getSOC();
blePowerStatus.doUpdate = 1;
}
}
if (motorController) {
//Logger::console("Wifi tick counter 2...");
if ( blePowerStatus.busVoltage != motorController->getDcVoltage() ) {
blePowerStatus.busVoltage = motorController->getDcVoltage();
if(blePowerStatus.busVoltage<0) blePowerStatus.busVoltage=0;
//if(blePowerStatus.busVoltage>4500) blePowerStatus.busVoltage=4500;
blePowerStatus.doUpdate = 1;
}
if ( blePowerStatus.busCurrent != motorController->getDcCurrent() ) {
blePowerStatus.busCurrent = motorController->getDcCurrent();
blePowerStatus.doUpdate = 1;
}
if ( blePowerStatus.motorCurrent != motorController->getAcCurrent() ) {
blePowerStatus.motorCurrent = motorController->getAcCurrent();
blePowerStatus.doUpdate = 1;
}
if ( blePowerStatus.kwHours != motorController->getKiloWattHours()/3600000 ) {
blePowerStatus.kwHours = motorController->getKiloWattHours()/3600000;
if(blePowerStatus.kwHours<0)blePowerStatus.kwHours = 0;
if(blePowerStatus.kwHours>300)blePowerStatus.kwHours = 300;
blePowerStatus.doUpdate = 1;
}
if ( blePowerStatus.mechPower != motorController->getMechanicalPower() ) {
blePowerStatus.mechPower = motorController->getMechanicalPower();
if (blePowerStatus.mechPower<-250)blePowerStatus.mechPower=-250;
if (blePowerStatus.mechPower>1500)blePowerStatus.mechPower=1500;
blePowerStatus.doUpdate = 1;
}
//DeviceManager::getInstance()->updateWifi();
}
} else if (tickCounter == 3) {
if (motorController) {
//Logger::console("Wifi tick counter 3...");
if ( bleMaxParams.nomVoltage != motorController->getnominalVolt() ) {
bleMaxParams.nomVoltage = motorController->getnominalVolt();
bleMaxParams.doUpdate = 1;
}
if ( bleBitFields.bitfield1 != motorController->getStatusBitfield1() ) {
bleBitFields.bitfield1 = motorController->getStatusBitfield1();
bleBitFields.doUpdate = 1;
}
if ( bleBitFields.bitfield2 != motorController->getStatusBitfield2() ) {
bleBitFields.bitfield2 = motorController->getStatusBitfield2();
bleBitFields.doUpdate = 1;
}
IOTemp = 0;
for (int i = 0; i < 4; i++)
{
if (getDigital(i)) bleBitFields.digitalInputs |= 1 << i;
}
if ( bleBitFields.digitalInputs != IOTemp ) {
bleBitFields.digitalInputs = IOTemp;
bleBitFields.doUpdate = 1;
}
IOTemp = 0;
for (int i = 0; i < 8; i++)
{
if (getOutput(i)) bleBitFields.digitalOutputs |= 1 << i;
}
if ( bleBitFields.digitalOutputs != IOTemp ) {
bleBitFields.digitalOutputs = IOTemp;
bleBitFields.doUpdate = 1;
}
if ( bleModes.isRunning != motorController->isRunning() ) {
bleModes.isRunning = motorController->isRunning();
bleModes.doUpdate = 1;
}
if ( bleModes.isFaulted != motorController->isFaulted() ) {
bleModes.isFaulted = motorController->isFaulted();
bleModes.doUpdate = 1;
}
if ( bleModes.isWarning != motorController->isWarning() ) {
bleModes.isWarning = motorController->isWarning();
bleModes.doUpdate = 1;
}
if ( bleModes.gear != motorController->getSelectedGear() ) {
bleModes.gear = motorController->getSelectedGear();
bleModes.doUpdate = 1;
}
if ( bleModes.powerMode != motorController->getPowerMode() ) {
bleModes.powerMode = motorController->getPowerMode();
bleModes.doUpdate = 1;
}
}
} else if (tickCounter == 4) {
if (motorController) {
//Logger::console("Wifi tick counter 4...");
if ( bleDigIO.prechargeDuration != motorController->getprechargeR() ) {
bleDigIO.prechargeDuration = motorController->getprechargeR();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.prechargeRelay != motorController->getprechargeRelay() ) {
bleDigIO.prechargeRelay = motorController->getprechargeRelay();
bleDigIO.doUpdate = 1;
//Logger::console("Precharge Relay %i", paramCache.prechargeRelay);
//Logger::console("motorController:prechargeRelay:%d, paramCache.prechargeRelay:%d, Constants:prechargeRelay:%s", motorController->getprechargeRelay(),paramCache.prechargeRelay, Constants::prechargeRelay);
}
if ( bleDigIO.mainContRelay != motorController->getmainContactorRelay() ) {
bleDigIO.mainContRelay = motorController->getmainContactorRelay();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.coolingRelay != motorController->getCoolFan() ) {
bleDigIO.coolingRelay = motorController->getCoolFan();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.coolOnTemp != motorController->getCoolOn() ) {
bleDigIO.coolOnTemp = motorController->getCoolOn();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.coolOffTemp != motorController->getCoolOff() ) {
bleDigIO.coolOffTemp = motorController->getCoolOff();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.brakeLightOut != motorController->getBrakeLight() ) {
bleDigIO.brakeLightOut = motorController->getBrakeLight();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.reverseLightOut != motorController->getRevLight() ) {
bleDigIO.reverseLightOut = motorController->getRevLight();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.enableIn != motorController->getEnableIn() ) {
bleDigIO.enableIn = motorController->getEnableIn();
bleDigIO.doUpdate = 1;
}
if ( bleDigIO.reverseIn != motorController->getReverseIn() ) {
bleDigIO.reverseIn = motorController->getReverseIn();
bleDigIO.doUpdate = 1;
}
}
} else if (tickCounter > 4) {
if (motorController) {
//Logger::console("Wifi tick counter 5...");
if ( bleTemperatures.motorTemperature != motorController->getTemperatureMotor() ) {
bleTemperatures.motorTemperature = motorController->getTemperatureMotor();
bleTemperatures.doUpdate = 1;
}
if ( bleTemperatures.inverterTemperature != motorController->getTemperatureInverter() ) {
bleTemperatures.inverterTemperature = motorController->getTemperatureInverter();
bleTemperatures.doUpdate = 1;
}
if ( bleTemperatures.systemTemperature != motorController->getTemperatureSystem() ) {
bleTemperatures.systemTemperature = motorController->getTemperatureSystem();
bleTemperatures.doUpdate = 1;
}
}
tickCounter = 0;
}
transferUpdates(); //send out any updates required
}
int main(int argc, char* argv[])
{
getOutput() << "Hello world!" << std::endl;
return 0;
}
TEST_F(Solver580DTest, Example3)
{
setInput("2 2 0 100 0");
Solver580D().run();
EXPECT_EQ("100", getOutput());
}
TEST_F(Solver580DTest, Example1)
{
setInput("2 2 1 1 1 2 1 1");
Solver580D().run();
EXPECT_EQ("3", getOutput());
}
OutputBase&
ProcessNode::getOutput() {
return getOutput(0);
}
// IMPORTANT Main SMO optimization step
process_return_t process (const LaRankPattern & pattern, process_type ptype)
{
process_return_t pro_ret = process_return_t (0, 0);
/*
** compute gradient and sort
*/
std::vector < outputgradient_t > outputgradients;
outputgradients.reserve (getNumOutputs ());
std::vector < outputgradient_t > outputscores;
outputscores.reserve (getNumOutputs ());
for (outputhash_t::iterator it = outputs.begin (); it != outputs.end (); ++it)
if (ptype != processOptimize
|| it->second.isSupportVector (pattern.x_id))
{
double g =
it->second.computeGradient (pattern.x_id, pattern.y, it->first);
outputgradients.push_back (outputgradient_t (it->first, g));
if (it->first == pattern.y)
outputscores.push_back (outputgradient_t (it->first, (1 - g)));
else
outputscores.push_back (outputgradient_t (it->first, -g));
}
std::sort (outputgradients.begin (), outputgradients.end ());
/*
** determine the prediction
*/
std::sort (outputscores.begin (), outputscores.end ());
pro_ret.ypred = outputscores[0].output;
/*
** Find yp (1st part of the pair)
*/
outputgradient_t ygp;
LaRankOutput *outp = NULL;
unsigned p;
for (p = 0; p < outputgradients.size (); ++p)
{
outputgradient_t & current = outputgradients[p];
LaRankOutput *output = getOutput (current.output);
bool support = ptype == processOptimize || output->isSupportVector (pattern.x_id);
bool goodclass = current.output == pattern.y;
if ((!support && goodclass) || (support && output->getBeta (pattern.x_id) < (goodclass ? C : 0)))
{
ygp = current;
outp = output;
break;
}
}
if (p == outputgradients.size ())
return pro_ret;
/*
** Find ym (2nd part of the pair)
*/
outputgradient_t ygm;
LaRankOutput *outm = NULL;
int m;
for (m = outputgradients.size () - 1; m >= 0; --m)
{
outputgradient_t & current = outputgradients[m];
LaRankOutput *output = getOutput (current.output);
bool support = ptype == processOptimize || output->isSupportVector (pattern.x_id);
bool goodclass = current.output == pattern.y;
if (!goodclass || (support && output->getBeta (pattern.x_id) > 0))
{
ygm = current;
outm = output;
break;
}
}
if (m < 0)
return pro_ret;
/*
** Throw or Insert pattern
*/
if ((ygp.gradient - ygm.gradient) < tau)
return pro_ret;
if (ptype == processNew)
patterns.insert (pattern);
/*
** compute lambda and clip it
*/
double kii = outp->getKii (pattern.x_id);
double lambda = (ygp.gradient - ygm.gradient) / (2 * kii);
if (ptype == processOptimize || outp->isSupportVector (pattern.x_id))
{
double beta = outp->getBeta (pattern.x_id);
if (ygp.output == pattern.y)
lambda = jmin (lambda, C - beta);
else
lambda = jmin (lambda, fabs (beta));
}
else
lambda = jmin (lambda, C);
/*
** update the solution
*/
outp->update (pattern.x_id, lambda, ygp.gradient);
outm->update (pattern.x_id, -lambda, ygm.gradient);
pro_ret.dual_increase = lambda * ((ygp.gradient - ygm.gradient) - lambda * kii);
return pro_ret;
}
static void GUINewMode(void)
{
int Max, Sel;
char* buffer;
char* arg1 = getRecord();
char* arg2 = getAuthor();
char* arg3 = getCopyright();
char* arg4 = getDriver();
char* arg5 = getVersion();
buffer = AllocVec( strlen( arg1 ) +
strlen( arg2 ) +
strlen( arg3 ) +
strlen( arg4 ) +
strlen( arg5 ) +
128,
MEMF_ANY);
if( buffer != NULL )
{
sprintf( buffer,"0x%08lx\n%s\n%s\n%s\nDevs:AHI/%s.audio\n%s",
getAudioMode(),
arg1,
arg2,
arg3,
arg4,
arg5 );
set(MUIInfos, MUIA_Text_Contents, (ULONG) buffer);
FreeVec(buffer);
}
Max = max(state.Frequencies -1, 0);
Sel = min(Max, state.FreqSelected);
set(MUIFreq, MUIA_Disabled, Max==0);
set(MUIFreq, MUIA_Numeric_Max, Max);
set(MUIFreq, MUIA_Numeric_Value, Sel);
set(MUILFreq, MUIA_Text_Contents, (ULONG) getFreq());
Max = max(state.Channels, 0);
Sel = min(Max, state.ChannelsSelected);
set(MUIChannels, MUIA_Disabled, (Max == 1) || state.ChannelsDisabled);
set(MUIChannels, MUIA_Numeric_Max, Max);
set(MUIChannels, MUIA_Numeric_Value, Sel);
set(MUILChannels, MUIA_Text_Contents, (ULONG) getChannels());
Max = max(state.OutVols -1, 0);
Sel = min(Max, state.OutVolSelected);
set(MUIOutvol, MUIA_Disabled, Max==0);
set(MUIOutvol, MUIA_Numeric_Max, Max);
set(MUIOutvol, MUIA_Numeric_Value, Sel);
set(MUILOutvol, MUIA_Text_Contents, (ULONG) getOutVol());
Max = max(state.MonVols -1, 0);
Sel = min(Max, state.MonVolSelected);
set(MUIMonvol, MUIA_Disabled, Max==0);
set(MUIMonvol, MUIA_Numeric_Max, Max);
set(MUIMonvol, MUIA_Numeric_Value, Sel);
set(MUILMonvol, MUIA_Text_Contents, (ULONG) getMonVol());
Max = max(state.Gains -1, 0);
Sel = min(Max, state.GainSelected);
set(MUIGain, MUIA_Disabled, Max==0);
set(MUIGain, MUIA_Numeric_Max, Max);
set(MUIGain, MUIA_Numeric_Value, Sel);
set(MUILGain, MUIA_Text_Contents, (ULONG) getGain());
Max = max(state.Inputs -1, 0);
Sel = min(Max, state.InputSelected);
set(MUIInput, MUIA_Disabled, Max==0);
set(MUIInput, MUIA_Numeric_Max, Max);
set(MUIInput, MUIA_Numeric_Value, Sel);
set(MUILInput, MUIA_Text_Contents, (ULONG) getInput());
Max = max(state.Outputs -1, 0);
Sel = min(Max, state.OutputSelected);
set(MUIOutput, MUIA_Disabled, Max==0);
set(MUIOutput, MUIA_Numeric_Max, Max);
set(MUIOutput, MUIA_Numeric_Value, Sel);
set(MUILOutput, MUIA_Text_Contents, (ULONG) getOutput());
}
static void GUINewMode(void)
{
int Max, Sel, Dis;
char* buffer;
char* arg1 = getRecord();
char* arg2 = getAuthor();
char* arg3 = getCopyright();
char* arg4 = getDriver();
char* arg5 = getVersion();
char* arg6 = getAnnotation();
buffer = AllocVec( strlen( arg1 ) +
strlen( arg2 ) +
strlen( arg3 ) +
strlen( arg4 ) +
strlen( arg5 ) +
strlen( arg6 ) +
128,
MEMF_ANY);
if( buffer != NULL )
{
sprintf( buffer,"0x%08lx\n%s\n%s\n%s\nDevs:AHI/%s.audio\n%s\n%s",
getAudioMode(),
arg1,
arg2,
arg3,
arg4,
arg5,
arg6 );
set(MUIInfos, MUIA_Text_Contents, (ULONG) buffer);
FreeVec(buffer);
}
Max = max(state.Frequencies -1, 0);
Sel = min(Max, state.FreqSelected);
Dis = Max==0;
set(MUIFreq, MUIA_Disabled, Dis);
if( !Dis )
{
set(MUIFreq, MUIA_Numeric_Max, Max);
set(MUIFreq, MUIA_Numeric_Value, Sel);
}
set(MUILFreq, MUIA_Text_Contents, (ULONG) getFreq());
Max = max(state.Channels, 0);
Sel = min(Max, state.ChannelsSelected);
Dis = (Max == 0 || Max == 1) || state.ChannelsDisabled;
set(MUIChannels, MUIA_Disabled, Dis);
if( !Dis )
{
set(MUIChannels, MUIA_Numeric_Max, Max);
set(MUIChannels, MUIA_Numeric_Value, Sel);
}
set(MUILChannels, MUIA_Text_Contents, (ULONG) getChannels());
if( state.ChannelsDisabled || AHIBase->lib_Version < 5)
{
set(MUIScalemode, MUIA_Disabled, TRUE);
set(MUIScalemode, MUIA_Cycle_Active, AHI_SCALE_FIXED_SAFE);
}
else
{
set(MUIScalemode, MUIA_Disabled, FALSE);
set(MUIScalemode, MUIA_Cycle_Active, state.ScaleModeSelected);
}
Max = max(state.OutVols -1, 0);
Sel = min(Max, state.OutVolSelected);
Dis = Max==0;
set(MUIOutvol, MUIA_Disabled, Dis);
if( !Dis )
{
set(MUIOutvol, MUIA_Numeric_Max, Max);
set(MUIOutvol, MUIA_Numeric_Value, Sel);
}
set(MUILOutvol, MUIA_Text_Contents, (ULONG) getOutVol());
Max = max(state.MonVols -1, 0);
Sel = min(Max, state.MonVolSelected);
Dis = Max==0;
set(MUIMonvol, MUIA_Disabled, Dis);
if( !Dis )
{
set(MUIMonvol, MUIA_Numeric_Max, Max);
set(MUIMonvol, MUIA_Numeric_Value, Sel);
}
set(MUILMonvol, MUIA_Text_Contents, (ULONG) getMonVol());
Max = max(state.Gains -1, 0);
Sel = min(Max, state.GainSelected);
Dis = Max==0;
set(MUIGain, MUIA_Disabled, Dis);
if( !Dis )
{
set(MUIGain, MUIA_Numeric_Max, Max);
set(MUIGain, MUIA_Numeric_Value, Sel);
}
set(MUILGain, MUIA_Text_Contents, (ULONG) getGain());
Max = max(state.Inputs -1, 0);
Sel = min(Max, state.InputSelected);
Dis = Max==0;
set(MUIInput, MUIA_Disabled, Dis);
if( !Dis )
{
set(MUIInput, MUIA_Numeric_Max, Max);
set(MUIInput, MUIA_Numeric_Value, Sel);
}
set(MUILInput, MUIA_Text_Contents, (ULONG) getInput());
Max = max(state.Outputs -1, 0);
Sel = min(Max, state.OutputSelected);
Dis = Max==0;
set(MUIOutput, MUIA_Disabled, Dis);
if( !Dis )
{
set(MUIOutput, MUIA_Numeric_Max, Max);
set(MUIOutput, MUIA_Numeric_Value, Sel);
}
set(MUILOutput, MUIA_Text_Contents, (ULONG) getOutput());
set(MUIPlay, MUIA_Disabled, getAudioMode() == AHI_INVALID_ID);
}
void Heartbeat::handleTick() {
// Print a dot if no other output has been made since the last tick
if (Logger::getLastLogTime() < lastTickTime) {
SerialUSB.print('.');
if ((++dotCount % 80) == 0) {
SerialUSB.println();
}
}
lastTickTime = millis();
if (led) {
digitalWrite(BLINK_LED, HIGH);
} else {
digitalWrite(BLINK_LED, LOW);
}
led = !led;
if (throttleDebug) {
MotorController *motorController = DeviceManager::getInstance()->getMotorController();
Throttle *accelerator = DeviceManager::getInstance()->getAccelerator();
Throttle *brake = DeviceManager::getInstance()->getBrake();
Logger::console("");
if (motorController) {
Logger::console("Motor Controller Status: isRunning: %T isFaulted: %T", motorController->isRunning(), motorController->isFaulted());
}
Logger::console("AIN0: %d, AIN1: %d, AIN2: %d, AIN3: %d", getAnalog(0), getAnalog(1), getAnalog(2), getAnalog(3));
Logger::console("DIN0: %d, DIN1: %d, DIN2: %d, DIN3: %d", getDigital(0), getDigital(1), getDigital(2), getDigital(3));
Logger::console("DOUT0: %d, DOUT1: %d, DOUT2: %d, DOUT3: %d,DOUT4: %d, DOUT5: %d, DOUT6: %d, DOUT7: %d", getOutput(0), getOutput(1), getOutput(2), getOutput(3),getOutput(4), getOutput(5), getOutput(6), getOutput(7));
if (accelerator) {
Logger::console("Throttle Status: isFaulted: %T level: %i", accelerator->isFaulted(), accelerator->getLevel());
RawSignalData *rawSignal = accelerator->acquireRawSignal();
Logger::console("Throttle rawSignal1: %d, rawSignal2: %d", rawSignal->input1, rawSignal->input2);
}
if (brake) {
Logger::console("Brake Output: %i", brake->getLevel());
RawSignalData *rawSignal = brake->acquireRawSignal();
Logger::console("Brake rawSignal1: %d", rawSignal->input1);
}
}
}
void Configuration::afterHelp()
{
getOutput() << std::endl
<< "****************************************" << std::endl;
}
void ConferenceDialog::onSipReply(const AmSipReply& reply)
{
int status = dlg.getStatus();
AmSession::onSipReply(reply);
DBG("ConferenceDialog::onSipReply: code = %i, reason = %s\n, status = %i\n",
reply.code,reply.reason.c_str(),dlg.getStatus());
if(!dialedout &&
!transfer_req.get())
return;
if(status < AmSipDialog::Connected){
switch(dlg.getStatus()){
case AmSipDialog::Connected:
// connected!
try {
acceptAudio(reply.body,reply.hdrs);
if(getDetached() && !getStopped()){
setupAudio();
if(getInput() || getOutput())
AmMediaProcessor::instance()->addSession(this,
getCallgroup());
else {
ERROR("missing audio input and/or ouput.\n");
return;
}
if(!transfer_req.get()){
// send connect event
AmSessionContainer::instance()
->postEvent(dialout_channel->getConfID(),
new DialoutConfEvent(DoConfConnect,
dialout_channel->getConfID()));
}
else {
dlg.reply(*(transfer_req.get()),202,"Accepted");
transfer_req.reset(0);
connectMainChannel();
}
}
}
catch(const AmSession::Exception& e){
ERROR("%i %s\n",e.code,e.reason.c_str());
dlg.bye();
setStopped();
}
break;
case AmSipDialog::Pending:
switch(reply.code){
case 180:
// send ringing event
AmSessionContainer::instance()
->postEvent(dialout_channel->getConfID(),
new DialoutConfEvent(DoConfRinging,
dialout_channel->getConfID()));
break;
case 183: break;//TODO: remote ring tone.
default: break;// continue waiting.
}
break;
case AmSipDialog::Disconnected:
if(!transfer_req.get()){
disconnectDialout();
//switch(reply.code){
//default:
AmSessionContainer::instance()
->postEvent(dialout_channel->getConfID(),
new DialoutConfEvent(DoConfError,
dialout_channel->getConfID()));
//}
}
else {
dlg.reply(*(transfer_req.get()),reply.code,reply.reason);
transfer_req.reset(0);
setStopped();
}
break;
default: break;
}
}
}
int main(int argc, char **argv) {
//flush for eclipse console output
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
struct firFilter fir;
printf("Let's configure the FIR filter.\nThe maximum Value of N is set to %d! \n", (Nmax+1));
printf("Do you want to do want to make a test run without preconfigurering all the variables? Please type [y|n]: ");
char preconf;
scanf("%c",&preconf);
if (preconf=='n') {
printf("Please type in the number of coefficients you want to use for the FIR filter:");
scanf("%d",&fir.length);
}
else fir.length = 63;
fir.coefficients=malloc(fir.length*sizeof(int));
fir.impulseResponse=fir.coefficients;
fir.delay=malloc(fir.length*sizeof(int));
fir.count=0;
int i =0;
int coeff[] =
{
-1468, 1058, 594, 287, 186, 284, 485, 613,
495, 90, -435, -762, -615, 21, 821, 1269,
982, 9, -1132, -1721, -1296, 1, 1445, 2136,
1570, 0, -1666, -2413, -1735, -2, 1770, 2512,
1770, -2, -1735, -2413, -1666, 0, 1570, 2136,
1445, 1, -1296, -1721, -1132, 9, 982, 1269,
821, 21, -615, -762, -435, 90, 495, 613,
485, 284, 186, 287, 594, 1058, -1468
};
printf("The number of coefficients is set to %d.\n",fir.length);
if (preconf=='n') {
printf(" Please enter each coefficient.\n");
while (i<fir.length) {
printf("Coefficient %d:",i+1);
scanf("%d",fir.coefficients+i);
i++;
}
}
else {
fir.coefficients = &coeff[0];
}
printf("You set the coefficients to: {");
i=0;
while (i<fir.length) {
printf("%d, ",*(fir.coefficients+i));
i++;
}
printf("}\n");
int input;
printf("Now please type the input x(n) integer value:");
scanf("%d",&input);
int output = getOutput(&fir,input);
printf("The output is: %d", output );
freeMem();
return 0;
}
bool getOutputPin(Pin* pin)
{
return getOutput(pin->port, pin->pin);
}
TEST_F(Solver578BTest, Example1)
{
setInput("3 1 2 1 1 1");
Solver578B().run();
EXPECT_EQ("3", getOutput());
}
BOOL BuildGUI(char *screenname) {
Object **ar = Window_Objs;
struct Screen *screen;
BOOL OptionFrame = FALSE;
LONG indicatorwidth = 100;
Object *l1, *l2, *l3, *l4, *l5, *l6, *l7;
UpdateStrings();
if (ButtonBase == NULL) { /* force it open */
Printf((char *) msgTextNoOpen, "button.gadget", __classactversion);
Printf("\n");
return FALSE;
}
/* Dynamic */
unitlist = ChooserLabelsA( (STRPTR *) Units);
modelist = BrowserNodesA( (STRPTR *) Modes);
infolist = BrowserNodes2(infotexts, infoargs);
/* Static */
pagelist = ClickTabs( (char *) msgPageMode, (char *) msgPageAdvanced, NULL);
debuglist = ChooserLabels( (char *) msgDebugNone,
(char *) msgDebugLow,
(char *) msgDebugHigh,
(char *) msgDebugFull,
NULL);
echolist = ChooserLabels( (char *) msgEchoEnabled,
(char *) msgEchoFast,
(char *) msgEchoDisabled,
NULL);
surroundlist = ChooserLabels( (char *) msgSurroundEnabled,
(char *) msgSurroundDisabled,
NULL);
clipMVlist = ChooserLabels( (char *) msgMVNoClip,
(char *) msgMVClip,
NULL);
screen = LockPubScreen(screenname);
vi = GetVisualInfoA(screen, NULL);
Menu = CreateMenusA(NewMenus, NULL);
if(vi == NULL || Menu == NULL) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
if(!LayoutMenus(Menu, vi, GTMN_NewLookMenus, TRUE, TAG_DONE)) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
indicatorwidth = max(indicatorwidth, 16 * screen->RastPort.Font->tf_XSize);
if(screen->Height > 240) {
OptionFrame = TRUE;
}
ar[ACTID_PAGE] = PageObject,
PAGE_Current, 0,
/* PAGE 1 */
PAGE_Add, HLayoutObject,
LAYOUT_VertAlignment, LALIGN_CENTER,
LAYOUT_AddChild, VLayoutObject,
LAYOUT_AddChild, ar[ACTID_UNIT] = PopUpObject,
CHOOSER_Labels, unitlist,
CHOOSER_Active, state.UnitSelected,
ChooserEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, ar[ACTID_MODE] = ListBrowserObject,
LISTBROWSER_Labels, modelist,
LISTBROWSER_MakeVisible,state.ModeSelected,
LISTBROWSER_Selected, state.ModeSelected,
LISTBROWSER_ShowSelected,TRUE,
ListBrowserEnd,
LAYOUT_AddChild, ar[SHOWID_MODE] = ListBrowserObject,
LISTBROWSER_Labels, infolist,
LISTBROWSER_ColumnInfo, (ULONG)&ci,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_VertSeparators, FALSE,
GA_ReadOnly, TRUE,
ListBrowserEnd,
CHILD_MaxHeight, screen->RastPort.Font->tf_YSize * 6 + 6, // UHH!!
LayoutEnd,
LAYOUT_AddChild, HLayoutObject,
(OptionFrame ? LAYOUT_SpaceOuter : TAG_IGNORE), TRUE,
(OptionFrame ? LAYOUT_RightSpacing : TAG_IGNORE), 0,
(OptionFrame ? LAYOUT_BevelStyle : TAG_IGNORE), BVS_GROUP,
(OptionFrame ? LAYOUT_Label : TAG_IGNORE), (char *) msgOptions,
LAYOUT_AddChild, VLayoutObject,
LAYOUT_AddChild, l1 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_FREQ] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Frequencies,
SLIDER_Level, state.FreqSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptFrequency,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_FREQ] = ButtonObject,
GA_Text, getFreq(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l2 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_CHANNELS] = SliderObject,
SLIDER_Min, 1,
SLIDER_Max, state.Channels,
SLIDER_Level, state.ChannelsSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptChannels,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_CHANNELS] = ButtonObject,
GA_Text, getChannels(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l3 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_OUTVOL] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.OutVols,
SLIDER_Level, state.OutVolSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptVolume,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_OUTVOL] = ButtonObject,
GA_Text, getOutVol(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l4 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_MONVOL] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.MonVols,
SLIDER_Level, state.MonVolSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptMonitor,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_MONVOL] = ButtonObject,
GA_Text, getMonVol(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l5 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_GAIN] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Gains,
SLIDER_Level, state.GainSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptGain,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_GAIN] = ButtonObject,
GA_Text, getGain(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l6 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_INPUT] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Inputs,
SLIDER_Level, state.InputSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptInput,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_INPUT] = ButtonObject,
GA_Text, getInput(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LAYOUT_AddChild, l7 = HLayoutObject,
LAYOUT_AddChild, ar[ACTID_OUTPUT] = SliderObject,
SLIDER_Min, 0,
SLIDER_Max, state.Outputs,
SLIDER_Level, state.OutputSelected,
SLIDER_Orientation, SORIENT_HORIZ,
GA_UserData, &GadgetHook,
SliderEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgOptOutput,
LabelEnd,
LAYOUT_AddChild, ar[SHOWID_OUTPUT] = ButtonObject,
GA_Text, getOutput(),
GA_ReadOnly, TRUE,
BUTTON_BevelStyle, BVS_NONE,
BUTTON_Transparent, TRUE,
BUTTON_Justification, BCJ_LEFT,
ButtonEnd,
CHILD_MinWidth, indicatorwidth,
CHILD_MaxWidth, indicatorwidth,
LayoutEnd,
LayoutEnd,
LayoutEnd,
CHILD_WeightedHeight, 0,
LayoutEnd,
/* PAGE 2 */
PAGE_Add, HLayoutObject,
LAYOUT_VertAlignment, LALIGN_CENTER,
LAYOUT_HorizAlignment, LALIGN_CENTER,
LAYOUT_AddChild, VLayoutObject,
LAYOUT_SpaceOuter, TRUE,
LAYOUT_BevelStyle, BVS_GROUP,
LAYOUT_Label, (char *) msgGlobalOptions,
LAYOUT_VertAlignment, LALIGN_BOTTOM,
LAYOUT_AddChild, ar[ACTID_DEBUG] = PopUpObject,
CHOOSER_Labels, debuglist,
CHOOSER_Active, globalprefs.ahigp_DebugLevel,
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptDebugLevel,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_ECHO] = PopUpObject,
CHOOSER_Labels, echolist,
CHOOSER_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) |
(globalprefs.ahigp_FastEcho ? 1 : 0),
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptEcho,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_SURROUND] = PopUpObject,
CHOOSER_Labels, surroundlist,
CHOOSER_Active, globalprefs.ahigp_DisableSurround,
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptSurround,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_CLIPMV] = PopUpObject,
CHOOSER_Labels, clipMVlist,
CHOOSER_Active, globalprefs.ahigp_ClipMasterVolume,
ChooserEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptMasterVol,
LabelEnd,
LAYOUT_AddChild, ar[ACTID_CPULIMIT] = IntegerObject,
INTEGER_MaxChars, 3,
INTEGER_MinVisible, 3,
INTEGER_Minimum, 0,
INTEGER_Maximum, 100,
INTEGER_Number, (globalprefs.ahigp_MaxCPU * 100 + 32768) >> 16,
INTEGER_Arrows, TRUE,
IntegerEnd,
CHILD_Label, LabelObject,
LABEL_Text, (char *) msgGlobOptCPULimit,
LabelEnd,
LayoutEnd,
CHILD_WeightedHeight, 0,
CHILD_WeightedWidth, 0,
LayoutEnd,
PageEnd;
if(ar[ACTID_PAGE] != NULL) {
SetAttrs( l1, LAYOUT_AlignLabels, l2, TAG_DONE);
SetAttrs( l2, LAYOUT_AlignLabels, l3, TAG_DONE);
SetAttrs( l3, LAYOUT_AlignLabels, l4, TAG_DONE);
SetAttrs( l4, LAYOUT_AlignLabels, l5, TAG_DONE);
SetAttrs( l5, LAYOUT_AlignLabels, l6, TAG_DONE);
SetAttrs( l6, LAYOUT_AlignLabels, l7, TAG_DONE);
SetAttrs( l7, LAYOUT_AlignLabels, l1, TAG_DONE);
}
WO_Window = WindowObject,
WA_PubScreen, screen,
WA_Title, (char *) msgTextProgramName,
WA_CloseGadget, TRUE,
WA_DepthGadget, TRUE,
WA_DragBar, TRUE,
WA_Activate, TRUE,
WA_SizeGadget, TRUE,
WA_SizeBBottom, TRUE,
WA_NewLookMenus, TRUE,
WA_InnerWidth, 800,
WA_InnerHeight, 400,
WINDOW_MenuStrip, Menu,
WINDOW_Position, WPOS_CENTERSCREEN,
WINDOW_GadgetUserData, WGUD_HOOK,
WINDOW_IDCMPHook, &IDCMPhook,
WINDOW_IDCMPHookBits, IDCMP_RAWKEY,
WINDOW_Layout, VLayoutObject,
LAYOUT_SpaceOuter, TRUE,
LAYOUT_DeferLayout, TRUE,
/* TABS */
LAYOUT_AddChild, ar[LAYOUT_PAGE] = VLayoutObject,
LAYOUT_AddChild, ar[ACTID_TABS] = ClickTabObject,
CLICKTAB_Labels, pagelist,
CLICKTAB_Current, 0L,
ICA_TARGET, ar[ACTID_PAGE],
ICA_MAP, MapTab2Page,
ClickTabEnd,
LAYOUT_AddChild, ar[ACTID_PAGE],
LayoutEnd,
/* BUTTONS */
LAYOUT_AddChild, HLayoutObject,
LAYOUT_EvenSize, TRUE,
LAYOUT_AddChild, ar[ACTID_SAVE] = ButtonObject,
GA_Text, (char *) msgButtonSave,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, ar[ACTID_USE] = ButtonObject,
GA_Text, (char *) msgButtonUse,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, ar[ACTID_QUIT] = ButtonObject,
GA_Text, (char *) msgButtonCancel,
ButtonEnd,
CHILD_WeightedHeight, 0,
LayoutEnd,
CHILD_WeightedHeight, 0,
LayoutEnd,
WindowEnd;
if(WO_Window) {
int i;
for(i = 0; i < ACTID_COUNT; i++) {
if(Window_Objs[i] != NULL) {
SetAttrs(Window_Objs[i], GA_ID, i,
GA_RelVerify, TRUE,
TAG_END);
}
}
Window = (struct Window *) CA_OpenWindow(WO_Window);
}
if(screen) {
UnlockPubScreen(NULL, screen);
}
if(Window == NULL) {
Printf((char *) msgTextNoWindow);
Printf("\n");
return FALSE;
}
openreq = GetFileObject,
GETFILE_RejectIcons, TRUE,
GETFILE_Drawer, "SYS:Prefs/Presets",
EndObject;
savereq = GetFileObject,
GETFILE_RejectIcons, TRUE,
GETFILE_Drawer, "SYS:Prefs/Presets",
GETFILE_DoSaveMode, TRUE,
EndObject;
if((openreq == NULL) || (savereq == NULL)) {
Printf((char *) msgTextNoFileRequester);
Printf("\n");
return FALSE;
}
// Update the checkmark for "Create Icons?"
{
struct Menu *menu;
struct MenuItem *item;
menu = Menu;
ClearMenuStrip(Window);
item = FindMenuItem(ACTID_ICONS);
if(item) {
if(SaveIcons)
item->Flags |= CHECKED;
else
item->Flags &= ~CHECKED;
}
ResetMenuStrip(Window, menu);
}
GUINewUnit();
return TRUE;
}
TEST_F(Solver578BTest, Example2)
{
setInput("4 2 3 1 2 4 8");
Solver578B().run();
EXPECT_EQ("79", getOutput());
}
static void GUINewMode(void) {
int Max, Sel;
infoargs[0] = (char *) getAudioMode();
infoargs[1] = getRecord();
infoargs[2] = getAuthor();
infoargs[3] = getCopyright();
infoargs[4] = getDriver();
infoargs[5] = getVersion();
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_MODE], window, NULL,
INFO_TextFormat, (ULONG) "0x%08lx\n"
"%s\n"
"%s\n"
"%s\n"
"Devs:AHI/%s.audio\n"
"%s",
INFO_Args, (ULONG) &infoargs,
TAG_DONE );
Max = max(state.Frequencies -1, 0);
Sel = min(Max, state.FreqSelected);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_FREQ], window, NULL,
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Channels, 0);
Sel = min(Max, state.ChannelsSelected);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_CHANNELS], window, NULL,
SLIDER_Min, 1,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 1) || state.ChannelsDisabled,
TAG_DONE );
Max = max(state.OutVols -1, 0);
Sel = min(Max, state.OutVolSelected);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_OUTVOL], window, NULL,
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.MonVols -1, 0);
Sel = min(Max, state.MonVolSelected);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_MONVOL], window, NULL,
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Gains -1, 0);
Sel = min(Max, state.GainSelected);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_GAIN], window, NULL,
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Inputs -1, 0);
Sel = min(Max, state.InputSelected);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_INPUT], window, NULL,
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
Max = max(state.Outputs -1, 0);
Sel = min(Max, state.OutputSelected);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_OUTPUT], window, NULL,
SLIDER_Min, 0,
SLIDER_Max, Max,
SLIDER_Level, Sel,
GA_Disabled, (Max == 0),
TAG_DONE );
// Update indicators..
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_FREQ], window, NULL,
INFO_TextFormat, (ULONG) getFreq(), TAG_DONE );
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_CHANNELS], window, NULL,
INFO_TextFormat, (ULONG) getChannels(), TAG_DONE );
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_OUTVOL], window, NULL,
INFO_TextFormat, (ULONG) getOutVol(), TAG_DONE );
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_MONVOL], window, NULL,
INFO_TextFormat, (ULONG) getMonVol(), TAG_DONE );
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_GAIN], window, NULL,
INFO_TextFormat, (ULONG) getGain(), TAG_DONE );
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_INPUT], window, NULL,
INFO_TextFormat, (ULONG) getInput(), TAG_DONE );
SetGadgetAttrs((struct Gadget *) Window_Objs[SHOWID_OUTPUT], window, NULL,
INFO_TextFormat, (ULONG) getOutput(), TAG_DONE );
}
TEST_F(Solver578BTest, Example3)
{
setInput("1 10 8 1000000000");
Solver578B().run();
EXPECT_EQ("1073741824000000000", getOutput());
}
bool cs(int argc, char* argv[])
{
bool help = false;
bool helpLib = false;
std::list<char*> libraries;
std::map<char, bool> options;
options.emplace('u', false); // upgrade
for(int i = 0; i < argc; ++i)
{
if(::strncmp(argv[i], "-l", 2) == 0)
libraries.emplace_back(argv[i] + 2);
else if(::strcmp(argv[i], "-hl") == 0)
helpLib = true;
else if(::strcmp(argv[i], "-u") == 0 ||
::strcmp(argv[i], "-upgrade") == 0)
options['u'] = true;
else if(::strcmp(argv[i], "-h") == 0)
help = true;
else
{
getOutput() << "Unkown parameter : \"" << argv[i] << "\"" << std::endl;
help = true;
}
}
if(help)
{
getOutput() << "Help :" << std::endl;
getOutput() << " -h : Display this help" << std::endl;
getOutput() << " -hl : Display the list of libraries" << std::endl;
getOutput() << " -u -upgrade : Upgrade the current project with new addons" << std::endl;
getOutput() << " -l<name> : Add a library" << std::endl;
return true;
}
if(helpLib)
{
char path[strlen(appRoot) + strlen("_ppm\\cs_libs\\*") + 2];
sprintf(path, "%s\\_ppm\\cs_libs\\*", appRoot);
getOutput() << "List of libraries :" << std::endl;
listAllFiles(path, " * ");
return true;
}
projectCreatedRequired();
if(!options['u'])
{ // Add root files
if(!newProjectRequired())
return false;
getOutput() << "Adding root" << std::endl;
copyRootFolder("_ppm\\cs", ".");
std::ofstream projectStream("_project", std::ios::binary | std::ios::app);
projectStream << std::endl << "OUTPUT_NAME = " << prjName << std::endl;
projectStream.close();
}
char libPath[100] = "_ppm\\cs_libs\\";
char destLibPath[100] = ".\\src\\libs\\";
char* libPathSub = libPath + strlen(libPath);
char* destLibPathSub = destLibPath + strlen(destLibPath);
for(auto& lib : libraries)
{
getOutput() << "Adding library " << lib << std::endl;
sprintf(libPathSub, "%s", lib);
sprintf(destLibPathSub, "%s", lib);
copyRootFolder(libPath, destLibPath);
}
return true;
}
// Waits for input from the user, also printing new output when appropriate
void getInput(char* szInput, short nMaxLength)
{
time_t timeout;
char chKeyPressed;
short nPosition = 0;
static OutputData odMessage;
// Decrease nMaxLength by one, since this function later doesn't count the null zero
nMaxLength--;
if(szInput == NULL || nMaxLength < 1)
return;
timeout=time(NULL);
while (1)
{
// Check for lost carrier, time expired, etc. (Note that in the OpenDoors implementation, these functions
// are blank, since OpenDoors does this type of checking automatically)
checkCarrier();
checkTimeLeft();
inactiveCheck(timeout);
chKeyPressed = 0;
// While no input on screen, continue to display output for this node.
while ( nPosition == 0 && chKeyPressed == 0 )
{
checkCarrier();
checkTimeLeft();
inactiveCheck(timeout, 0);
// Check for inter-node messages in synchronet
if ( checkNodeMsg() )
fixStatline();
// Only respond to keyboard if there's a valid prompt on screen.
if ( isValidPrompt() )
chKeyPressed = inputKey();
else
Sleep(50);
// Display all output waiting in mailslot, if any.
if ( getOutput() )
fixStatline();
}
// If no key pressed this cycle, try getting the key again.
if ( chKeyPressed == 0 && isValidPrompt() )
chKeyPressed = inputKey();
// If a key was pressed
if ( chKeyPressed != 0 )
{
timeout=time(NULL);
// Fix CR/LF problem, and ignore otherwise invalid characters
if ( chKeyPressed == 10 || chKeyPressed < 0 )
continue;
// Enter key hit: Add ending \0 to string and return.
if(chKeyPressed == '\r' || chKeyPressed == '\n')
{
szInput[nPosition] = '\0';
newline();
bPromptOnScreen = false;
return;
}
// At this point, user has definitely hit a non-enter key. If this is the
// first key hit of a string, and there's no prompt on screen yet, display
// it first before displaying the keystroke.
if ( nPosition == 0 && !bPromptOnScreen )
fixStatline();
// Backspace key
if( chKeyPressed == 8 && nPosition > 0 )
{
backspace(1);
--nPosition;
continue;
}
// Any normal key
if(chKeyPressed >= 32 && nPosition < nMaxLength && (unsigned char)chKeyPressed <= 127)
{
// Display the key and add it to the input buffer.
printChar(chKeyPressed);
szInput[nPosition++] = chKeyPressed;
// If in hotkey mode, send the input immediately.
if ( !bCommandMode )
{
szInput[nPosition] = '\0';
newline();
bPromptOnScreen = false;
return;
}
}
}
}
}
