void CRplRootApp::CheckRIBForNotifications(){
for (int i = 0; i < MAX_RIB_TARGETS; ++i){
TRIBTarget *poRIBTarget = &g_oRplInstance.m_oRplRIB.m_oTargetTable[i];
if (IS_TG_EMPTY(poRIBTarget)){
continue;
}
uint32_t u32Now = time(NULL);
if(!poRIBTarget->m_u32LastUpdateNotifTime){
AddTopologyNotificationEncap(MgmtProtocol::CMgmtPMessage::EVENT_REGISTER, NULL,
poRIBTarget->m_oPrefix, GetDeviceType(&poRIBTarget->m_oPrefix.m_oIPv6Addr), GetFarId(), MgmtProtocol::TYPE_GR);
poRIBTarget->m_u32LastUpdateNotifTime = u32Now;
continue;
}
if (poRIBTarget->m_u32LastUpdateNotifTime + m_stCfg.m_nRIBUpdateNotifsInterval < u32Now ){
AddTopologyNotificationEncap(MgmtProtocol::CMgmtPMessage::EVENT_UPDATE, NULL,
poRIBTarget->m_oPrefix, GetDeviceType(&poRIBTarget->m_oPrefix.m_oIPv6Addr), GetFarId(), MgmtProtocol::TYPE_GR);
poRIBTarget->m_u32LastUpdateNotifTime = u32Now;
}
}
}
void CLEDSlidersDlg::OnClickedButtonSaveLighting()
{
#ifndef USE_LOGITECH_DLL_ONLY
LogiLedSaveCurrentLighting(GetDeviceType());
#else
g_lpfnDllSaveCurrentLighing(GetDeviceType());
#endif
}
void CLEDSlidersDlg::OnClickedButtonRestoreLighting()
{
#ifndef USE_LOGITECH_DLL_ONLY
LogiLedRestoreLighting(GetDeviceType());
#else
g_lpfnDllRestoreLighting(GetDeviceType());
#endif
}
PGuiElement WWLoadGui(const std::string& filename, bool addAsListener)
{
#ifdef AMJU_IOS
// Fall back to base version of file if the exact one we
// want is not there
static iOSDeviceType dt = GetDeviceType();
if (dt == AMJU_IPAD)
{
auto e = LoadGuiWithPrefix("ipad-", filename, addAsListener);
if (e)
{
return e;
}
// Try other iOS layout in preference to common?
// TODO
}
else if (dt == AMJU_IPHONE)
{
auto e = LoadGuiWithPrefix("iphone-", filename, addAsListener);
if (e)
{
return e;
}
}
#endif
return Amju::LoadGui(filename, addAsListener);
}
void StartUpAfterCreateWindow()
{
Texture::SetDefaultFilter(AmjuGL::AMJU_TEXTURE_NICE);
Texture::SetDefaultWrapMode(AmjuGL::AMJU_TEXTURE_WRAP);
Engine* engine = Engine::Instance();
// This is no good, screen size is not known yet!!!
// But the idea is that we get the device resolution so we can work on iphone, ipad, etc. etc.
#ifndef AMJU_IOS
// NOT on iphone etc
Screen::SetSize(WIDTH, HEIGHT);
engine->SetViewport(Screen::X(), Screen::Y());
#endif
#ifdef AMJU_IOS
const char* layoutfilename = "layout_iphone.txt";
if (GetDeviceType() == AMJU_IPAD)
{
layoutfilename = "layout_ipad.txt";
}
#endif
if (!LoadButtonLayout(layoutfilename))
{
ReportError(std::string("Failed to load button layout file ") + layoutfilename);
}
if (!engine->LoadFont())
{
ReportError("Failed to load fonts");
}
}
void ConnectPort(int i, int baud) {
if (Ports[i]->kind == 's') {
ConnectSerialPort((struct SPort*)Ports[i], baud);
} else {
ConnectUsbtinyPort((struct UPort*)Ports[i]);
}
if (Ports[i]->baud > 0) {
CurrentPort = i;
Ports[i]->character = GetDeviceType();
}
}
void autobots_toutiao::initialDevices()
{
for (size_t i = 0; i < 10; i++)
{
DeviceParam dev;
dev._uuid = GetUuid();
dev._did = GetDid();
dev._useragent = "Mozilla / 5.0 (iPhone; CPU iPhone OS 9_3_5 like Mac OS X) AppleWebKit / 601.1.46 (KHTML, like Gecko) Mobile / 13G36 NewsArticle / 5.8.3.2 JsSdk / 2.0 NetType / WIFI(News 5.8.3 9.300000)";
dev._device_type = GetDeviceType();
m_devices_list.push_back(dev);
}
}
MM::DeviceType
LoadedDeviceAdapter::GetAdvertisedDeviceType(const std::string& deviceName) const
{
int typeInt = MM::UnknownType;
bool ok = GetDeviceType(deviceName.c_str(), &typeInt);
if (!ok || typeInt == MM::UnknownType)
{
throw CMMError("Cannot get type of device " +
ToQuotedString(deviceName) + " of device adapter module " +
ToQuotedString(name_));
}
return static_cast<MM::DeviceType>(typeInt);
}
/**************************************************************************
Description : Sichern der ErrechneteKanaeleTemp Variablen in eine Datei
Parameter : (none)
Return-Value : (none)
Changes : Author, Date, Version, Reason
********************************************************
Dotterweich, 27.08.2007, 0.1, Created
**************************************************************************/
void ErrechneteKanaeleSichernTemp(void)
{
int i = 1;
int Zaehler = 1;
DWORD SNBuffer = 0;
char TypeBuffer[50] = {0};
char Pfad[100] = {0};
char DateiName[100] = {0};
char DateiBuffer[200] = {0};
FILE *Datei = NULL;
Tools_PathExtractPath(Pfad, ErrechneteKanaeleTempDateiName, sizeof(ErrechneteKanaeleTempDateiName)-1 );
Tools_PathExtractFile(DateiName, ErrechneteKanaeleTempDateiName, sizeof(ErrechneteKanaeleTempDateiName)-1 );
for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
{
GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);
sprintf(DateiBuffer, "%s/%3ld.%s", Pfad, SNBuffer, DateiName);
Datei = fopen(DateiBuffer, "w");
if (!Datei)
{
ausgabe(LOG, DEBUGMINI, "ErrechneteKanaele.TempVariablenDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
return;
}
else
{
ausgabe(LOG, DEBUGKRECH, "Sichern der ErrechneteKanaeleTemp Variablen in %s gestartet.\n", DateiName);
for(i = 1; i <= ERRECHNETEKANAELEMAX; i++)
{
fwrite(&ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1], sizeof(ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1]), 1, Datei);
fwrite(&ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1], sizeof(ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1]), 1, Datei);
ausgabe(LOG, DEBUGKRECH, "ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1] = %u\n", ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1]);
ausgabe(LOG, DEBUGKRECH, "ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1] = %f\n", ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1]);
if(i <= ErrechneteKanaeleAnzahl)
{ // Nur StatusDatein für Errechnete Kanäle erstellen
StatusDatei(SNBuffer, TypeBuffer, ErrechneteKanaeleName[i - 1], ErrechneteKanaeleWert[Zaehler - 1][i - 1]);
}
}
}
fclose(Datei);
}
}
void EngineSystem::InitAppEnv()
{
// 初始化窗口大小
if (_TYPED_IOS_DEVICE_IPHONE_ == GetDeviceType())
{
cocos2d::CCEGLView::sharedOpenGLView()->setFrameSize(_IOS_IPHONE_DEVICE_WIDTH_, _IOS_IPHONE_DEVICE_HEIGHT_);
}
else if (_TYPED_IOS_DEVICE_IPAD_ == GetDeviceType())
{
cocos2d::CCEGLView::sharedOpenGLView()->setFrameSize(_IOS_IPAD_DEVICE_WIDTH_, _IOS_IPAD_DEVICE_HEIGHT_);
}
else if (_TYPED_IOS_DEVICE_ANDROID_ == GetDeviceType())
{
cocos2d::CCEGLView::sharedOpenGLView()->setFrameSize(_ANDROID_800X480_DEVICE_WIDTH_, _ANDROID_800X480_DEVICE_WIDTH_);
}
// 创建游戏导演类
cocos2d::CCDirector* pDirector = cocos2d::CCDirector::sharedDirector();
pDirector->setOpenGLView(cocos2d::CCEGLView::sharedOpenGLView());
// 设置多分辨率相关的配置信息
if (_TYPED_IOS_DEVICE_IPHONE_ == GetDeviceType())
{
cocos2d::CCEGLView::sharedOpenGLView()->setDesignResolutionSize(_IOS_IPHONE_DEVICE_WIDTH_, _IOS_IPHONE_DEVICE_HEIGHT_, kResolutionShowAll);
}
else if (_TYPED_IOS_DEVICE_IPAD_ == GetDeviceType())
{
cocos2d::CCFileUtils::sharedFileUtils()->setResourceDirectory("ipad");
cocos2d::CCEGLView::sharedOpenGLView()->setDesignResolutionSize(_IOS_IPAD_DEVICE_WIDTH_, _IOS_IPAD_DEVICE_HEIGHT_, kResolutionShowAll);
}
else if (_TYPED_IOS_DEVICE_ANDROID_ == GetDeviceType())
{
// 设置多分辨率相关的配置信息
int iWidth = cocos2d::CCDirector::sharedDirector()->getWinSize().width;
int iHeight = cocos2d::CCDirector::sharedDirector()->getWinSize().height;
int temp = int(float(iWidth)*480.0f/iHeight);
if (abs(temp-720) <= abs(temp-800))
{
cocos2d::CCEGLView::sharedOpenGLView()->setDesignResolutionSize(_ANDROID_480X320_DEVICE_WIDTH_, _ANDROID_480X320_DEVICE_HEIGHT_, kResolutionShowAll);
}
else
{
cocos2d::CCFileUtils::sharedFileUtils()->setResourceDirectory("480X800/");
cocos2d::CCEGLView::sharedOpenGLView()->setDesignResolutionSize(_ANDROID_800X480_DEVICE_WIDTH_, _ANDROID_800X480_DEVICE_HEIGHT_, kResolutionShowAll);
}
}
}
void Config::Set(const std::unordered_map<std::string, std::string>& params) {
// generate seeds by seed.
if (GetInt(params, "seed", &seed)) {
Random rand(seed);
int int_max = std::numeric_limits<short>::max();
data_random_seed = static_cast<int>(rand.NextShort(0, int_max));
bagging_seed = static_cast<int>(rand.NextShort(0, int_max));
drop_seed = static_cast<int>(rand.NextShort(0, int_max));
feature_fraction_seed = static_cast<int>(rand.NextShort(0, int_max));
}
GetTaskType(params, &task);
GetBoostingType(params, &boosting);
GetMetricType(params, &metric);
GetObjectiveType(params, &objective);
GetDeviceType(params, &device_type);
GetTreeLearnerType(params, &tree_learner);
GetMembersFromString(params);
if (valid_data_initscores.size() == 0 && valid.size() > 0) {
valid_data_initscores = std::vector<std::string>(valid.size(), "");
}
CHECK(valid.size() == valid_data_initscores.size());
// check for conflicts
CheckParamConflict();
if (verbosity == 1) {
LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Info);
} else if (verbosity == 0) {
LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Warning);
} else if (verbosity >= 2) {
LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Debug);
} else {
LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Fatal);
}
}
int getDeviceType_1260(int identifier,int fd, int cmd, char *data, int vallen)
{
/*获得设备型号*/
DEBUG(DL_DEBUG, "Get Device Type\n");
char dtype[16] = {0};
unsigned char sdata[256] = {0};
int totallen = 0;
int cmdlen = sizeof(int);
int retlen = sizeof(int);
int ret = 0;
GetDeviceType(dtype);
vallen = strlen(dtype);
totallen = MSGINFOHEAD + cmdlen + vallen + retlen;
msgPacket(identifier,sdata, STRING_TYPE, totallen, cmd, ret);
memcpy(sdata + totallen - vallen, dtype, vallen);
DEBUG(DL_DEBUG, "GetDeviceType...cmd =0x%x\n", cmd);
send(fd, sdata, totallen, 0);
//DEBUG(DL_DEBUG,"dtype = %s\n", dtype);
//sprintf(dtype,"%d-%d-%d",op.HPV,op.TMDS,op.VsyncF);
DEBUG(DL_DEBUG, "dtype = %s\n", dtype);
return 0;
}
void DeviceSetupDialog::PopulateFields()
{
int i, k;
// Get the currently selected device type
long deviceType = GetDeviceType();
// TODO: This needs to have constants
DeviceCombo.ResetContent();
// Take care of the U3 and U6
DeviceCombo.AddString("U3");
if (deviceType == LJ_dtU3)
DeviceCombo.SetCurSel(U3_COMBOBOX_INDEX);
DeviceCombo.AddString("U6");
if (deviceType == LJ_dtU6)
DeviceCombo.SetCurSel(U6_COMBOBOX_INDEX);
// Handle the more complex UE9 and the ethernet control
DeviceCombo.AddString("UE9");
if (deviceType == LJ_dtUE9)
{
// Set the selection
DeviceCombo.SetCurSel(UE9_COMBOBOX_INDEX);
// Show the ethernet control and disable local id entry
ToggleControls(true, IsUsingEthernet());
}
else
ToggleControls(false, false);
// Fill timer combo boxes
for(i=0; i<7; i++)
for(k=0; k<14; k++)
timerCombos[i].AddString((LPCTSTR)(LJ_TIMER_MODES[k].GetDescription()));
UpdateData(FALSE);
}
//------------------------------------------------------------------------------
// PrinterServiceProvider::Initialize
// This function is called by Function Discovery (FD) when QueryService is
// called on an FD Function Instance specifying
// CLSID_SsysPrinterServiceProxy. This function creates a WSD or UPnP proxy
// object depending on what type of device the FD Function Instance
// represents.
//------------------------------------------------------------------------------
HRESULT CPrinterServiceProvider::Initialize(
IFunctionInstance* pFunInst,
REFIID riid,
void** ppv
)
{
DEVICE_PROTOCOL_TYPE deviceType = DEVICE_PROTOCOL_TYPE_WSD;
HRESULT hr = S_OK;
IPropertyStore* pPropStore = NULL;
if (NULL == ppv ||
NULL == pFunInst)
{
return E_INVALIDARG;
}
//
// Open the property store of the function instance
//
if (S_OK == hr)
{
wprintf(L"OpenPropertyStore on the FI...");
hr = pFunInst->OpenPropertyStore(STGM_READ, &pPropStore);
wprintf(L"0x%x\n", hr);
}
//
// See if this is a device type supported. This is done by checking
// the 'Type' property inside the FI's property store.
//
if (S_OK == hr)
{
wprintf(L"GetDeviceType...");
hr = GetDeviceType(pPropStore, &deviceType);
wprintf(L"0x%x\n", hr);
if (S_FALSE == hr)
{
wprintf(L"Device type unsupported!");
}
}
if (S_OK == hr)
{
wprintf(L"Device type: %s\n",
DEVICE_PROTOCOL_TYPE_WSD == deviceType ? L"WSD" : L"Unknown (UPNP?)");
}
//
// Create the appropriate proxy
//
if (S_OK == hr &&
DEVICE_PROTOCOL_TYPE_WSD == deviceType)
{
hr = CreateCPrinterServiceWsdProxy(
pPropStore,
reinterpret_cast<IPrinterService**>(ppv)
);
}
//
// Cleanup
//
if (NULL != pPropStore)
{
pPropStore->Release();
pPropStore = NULL;
}
return hr;
}// PrinterServiceProvider::Initialize
/**************************************************************************
Description : Erstellen der Log Dateien
Parameter : (none)
Return-Value : (none)
Changes : Author, Date, Version, Reason
********************************************************
Dotterweich, 01.09.2007, 0.1, Created
**************************************************************************/
void LogDatei(char *Pfad, char *OutputDatei, int Format)
{
int Zaehler = 1;
ausgabe(LOG, DEBUGALLES, "LogDatei gestartet!!!\n");
for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
{
BOOL NeueDatei = true;
char NameBuffer[50] = {0};
char TypeBuffer[50] = {0};
DWORD SNBuffer = 0;
char DatumBuffer[20] = {0};
char DateiBuffer[200] = {0};
FILE *Datei = NULL;
GetDeviceName(WRHandles[Zaehler - 1], NameBuffer, sizeof(NameBuffer)-1);
GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);
GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
GetDatum(DatumBuffer, sizeof(DatumBuffer)-1);
ausgabe(LOG, DEBUGALLES, "LogDatei für WR %3ld erstellen\n", SNBuffer);
sprintf(DateiBuffer, "%s/%s.%3ld.%s.%s", Pfad, DatumBuffer, SNBuffer, TypeBuffer, OutputDatei);
Datei = fopen(DateiBuffer, "r");
ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
if (Datei) // Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
{ // und es muss kein Dateikopf mehr erstellt werden.
ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
NeueDatei = false;
fclose(Datei);
}
Datei = fopen(DateiBuffer, "a");
if (!Datei)
{
ausgabe(LOG, DEBUGMINI, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
return;
}
else
{
int i = 0;
int j = 0;
int KanalAnzahl = 0;
DWORD KanalHandle;
TChanType KanalType = ALLCHANNELS;
char KanalName[50] = {0};
char WertText[50]={0};
char ZeitpunktBuffer[50] = {0};
ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
setbuf(Datei, 0); // Pufferung abschalten
// Ab hier Ausgaben in Datei
GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);
if(NeueDatei)
{
fprintf(Datei, "LogDatei für WR %3ld erstellt am %s von %s %s\r\n", SNBuffer, ZeitpunktBuffer, ProgrammName, ProgrammVersion);
fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
fprintf(Datei, "Zeitpunkt \t");
ausgabe(LOG, DEBUGALLES, "LogKanalAnzahl %i\n", LogKanalAnzahl);
for(i = 1; i <= LogKanalAnzahl; i++)
{
KanalHandle = FindChannelName(WRHandles[Zaehler - 1], LogKanal[i - 1]);
ausgabe(LOG, DEBUGALLES, "1. KanalHandle %i\n", KanalHandle);
if(KanalHandle == 0)
{ // Kanal nicht vom WR
// Die Errechneten Kanaele durchsuchen
for(j = 1; j <= ErrechneteKanaeleAnzahl; j++)
{
if(strncmp(LogKanal[i - 1], ErrechneteKanaeleName[j - 1], sizeof(LogKanal[i - 1])-1) == 0)
{
KanalHandle = j;
break;
}
}
if(KanalHandle == 0)
{ // Kanal nicht gefunden
fprintf(Datei, "???%9s???\t", LogKanal[i - 1]);
}
else
{ // Errechneter Kanal
fprintf(Datei, "%*s\t", ErrechneteKanaeleZeichen[KanalHandle - 1], ErrechneteKanaeleName[KanalHandle - 1]);
}
}
else
{ // Kanal vom WR
GetChannelName(KanalHandle, KanalName, sizeof(KanalName)-1);
fprintf(Datei, "%*s\t", KanalWertZeichenAnzahlMAX(KanalHandle), KanalName);
}
}
}
fprintf(Datei, "\r\n");
fprintf(Datei, "%s\t", ZeitpunktBuffer);
for(i = 1; i <= LogKanalAnzahl; i++)
{
KanalHandle = FindChannelName(WRHandles[Zaehler - 1], LogKanal[i - 1]);
if(KanalHandle == 0)
{ // Kanal nicht vom WR
// Die Errechneten Kanaele durchsuchen
for(j = 1; j <= ErrechneteKanaeleAnzahl; j++)
{
if(strncmp(LogKanal[i - 1], ErrechneteKanaeleName[j - 1], sizeof(LogKanal[i - 1])-1) == 0)
{
KanalHandle = j;
break;
}
}
if(KanalHandle == 0)
{ // Kanal nicht gefunden
fprintf(Datei, " \t");
}
else
{ // Errechneter Kanal
fprintf(Datei, "%s\t", ErrechneteKanaeleWert[Zaehler - 1][KanalHandle - 1]);
}
}
else
{ // Kanal vom WR
KanalAbfragen(KanalHandle, WRHandles[Zaehler - 1], WertText, sizeof(WertText)-1); // Abfragen eines Kanales
fprintf(Datei, "%s\t", WertText);
}
}
ausgabe(LOG, DEBUGALLES, "Ausgabe in Dateien ist beendet.\n");
}
fclose(Datei);
}
}
void CLEDSlidersDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
// TODO: Add your message handler code here and/or call default
int CurPos = pScrollBar->GetScrollPos();
// Determine the new position of scroll box.
switch (nSBCode)
{
case SB_LEFT: // Scroll to far left.
CurPos = 0;
break;
case SB_RIGHT: // Scroll to far right.
CurPos = 122;
break;
case SB_ENDSCROLL: // End scroll.
break;
case SB_LINELEFT: // Scroll left.
if (CurPos > 0)
CurPos--;
break;
case SB_LINERIGHT: // Scroll right.
if (CurPos < 122)
CurPos++;
break;
case SB_PAGELEFT: // Scroll one page left.
{
// Get the page size.
SCROLLINFO info;
pScrollBar->GetScrollInfo(&info, SIF_ALL);
if (CurPos > 0)
CurPos = max(0, CurPos - (int) info.nPage);
}
break;
case SB_PAGERIGHT: // Scroll one page right
{
// Get the page size.
SCROLLINFO info;
pScrollBar->GetScrollInfo(&info, SIF_ALL);
if (CurPos < 122)
CurPos = min(122, CurPos + (int) info.nPage);
}
break;
case SB_THUMBPOSITION: // Scroll to absolute position. nPos is the position
CurPos = nPos; // of the scroll box at the end of the drag operation.
break;
case SB_THUMBTRACK: // Drag scroll box to specified position. nPos is the
CurPos = nPos; // position that the scroll box has been dragged to.
break;
}
pScrollBar->SetScrollPos(CurPos);
int red = m_scrollBarMouseRed.GetScrollPos();
int green = m_scrollBarMouseGreen.GetScrollPos();
int blue = m_scrollBarMouseBlue.GetScrollPos();
if (pScrollBar == &m_scrollBarKbdRed)
{
red = CurPos;
}
else if (pScrollBar == &m_scrollBarKbdGreen)
{
green = CurPos;
}
else if (pScrollBar == &m_scrollBarKbdBlue)
{
blue = CurPos;
}
#ifndef USE_LOGITECH_DLL_ONLY
LogiLedSetLighting(GetDeviceType(), red, green, blue);
#else
g_lpfnDllSetLighting(GetDeviceType(), red, green, blue);
#endif
CDialogEx::OnHScroll(nSBCode, nPos, pScrollBar);
}
long LookupPartition(char *devSpec)
{
CICell partIH;
long partIndex, partType;
long deviceType;
// See if the devSpec has already been opened.
for (partIndex = 0; partIndex < kNumPartInfos; partIndex++) {
if (!strcmp(gParts[partIndex].partName, devSpec)) break;
}
// If it has not been opened, do so now.
if (partIndex == kNumPartInfos) {
// Find a free slot.
for (partIndex = 0; partIndex < kNumPartInfos; partIndex++) {
if (gParts[partIndex].partIH == 0) break;
}
// No free slots, so return error.
if (partIndex == kNumPartInfos) return -1;
deviceType = GetDeviceType(devSpec);
switch (deviceType) {
case kNetworkDeviceType :
partIH = NetInitPartition(devSpec);
if (partIH == 0) return -1;
partType = kPartNet;
break;
case kBlockDeviceType :
printf("Opening partition [%s]...\n", devSpec);
partIH = Open(devSpec);
if (partIH == 0) {
printf("Failed to open partition [%s].\n", devSpec);
return -1;
}
// Find out what kind of partition it is.
if (HFSInitPartition(partIH) != -1) partType = kPartHFS;
else if (UFSInitPartition(partIH) != -1) partType = kPartUFS;
else if (Ext2InitPartition(partIH) != -1) partType = kPartExt2;
else return -1;
break;
default :
return -1;
}
gParts[partIndex].partIH = partIH;
gParts[partIndex].partType = partType;
strcpy(gParts[partIndex].partName, devSpec);
switch (partType) {
case kPartNet:
gParts[partIndex].loadFile = NetLoadFile;
gParts[partIndex].readFile = NULL;
gParts[partIndex].getDirEntry = NetGetDirEntry;
gParts[partIndex].getUUID = NULL;
break;
case kPartHFS:
gParts[partIndex].loadFile = HFSLoadFile;
gParts[partIndex].readFile = HFSReadFile;
gParts[partIndex].getDirEntry = HFSGetDirEntry;
gParts[partIndex].getUUID = HFSGetUUID;
break;
case kPartUFS:
gParts[partIndex].loadFile = UFSLoadFile;
gParts[partIndex].readFile = UFSReadFile;
gParts[partIndex].getDirEntry = UFSGetDirEntry;
gParts[partIndex].getUUID = UFSGetUUID;
break;
case kPartExt2:
gParts[partIndex].loadFile = Ext2LoadFile;
gParts[partIndex].readFile = NULL;
gParts[partIndex].getDirEntry = Ext2GetDirEntry;
gParts[partIndex].getUUID = NULL;
// Ext2GetUUID exists, but there's no kernel support
break;
}
}
return partIndex;
}
cl_int GLCLDraw::InitContext(int platformnum, int processornum, int GLinterop)
{
cl_int ret;
size_t len;
char extension_data[1024];
size_t llen;
size_t extension_len;
int i;
properties = malloc(16 * sizeof(intptr_t));
ret = clGetPlatformIDs(8, platform_id, &ret_num_platforms);
if(ret != CL_SUCCESS) return ret;
if(ret_num_platforms <= 0) return CL_INVALID_PLATFORM;
platform_num = platformnum;
if(platform_num >= ret_num_platforms) platform_num = ret_num_platforms - 1;
if(platform_num <= 0) platform_num = 0;
ret = clGetDeviceIDs(platform_id[platform_num], CL_DEVICE_TYPE_ALL, 8, device_id,
&ret_num_devices);
if(ret != CL_SUCCESS) return ret;
if(ret_num_devices <= 0) {
XM7_DebugLog(XM7_LOG_DEBUG, "CL : Has no useful device(s).");
return ret;
}
if(ret_num_devices > 8) ret_num_devices = 8;
if(ret_num_devices <= 0) return CL_INVALID_DEVICE_TYPE;
XM7_DebugLog(XM7_LOG_DEBUG, "CL : Found %d processors.", ret_num_devices);
using_device = processornum;
if(using_device >= ret_num_devices) using_device = ret_num_devices - 1;
if(using_device <= 0) using_device = 0;
bCLEnableKhrGLShare = 0;
for(i = 0; i < ret_num_devices; i++ ){
extension_data[0] = '\0';
GetDeviceName(extension_data, sizeof(extension_data), i);
XM7_DebugLog(XM7_LOG_DEBUG, "CL : Processor #%d : Name = %s ", i, extension_data);
extension_data[0] = '\0';
clGetDeviceInfo(device_id[i], CL_DEVICE_TYPE,
sizeof(cl_ulong), &(device_type[i]), &llen);
clGetDeviceInfo(device_id[i], CL_DEVICE_LOCAL_MEM_SIZE,
sizeof(cl_ulong), &(local_memsize[i]), &llen);
GetDeviceType(extension_data, sizeof(extension_data), i);
XM7_DebugLog(XM7_LOG_DEBUG, "CL : Processor #%d : TYPE = %s / Local memory size = %d bytes", i, extension_data, local_memsize[i]);
extension_data[0] = '\0';
clGetDeviceInfo(device_id[i], CL_DEVICE_EXTENSIONS,
1024, extension_data, &extension_len);
XM7_DebugLog(XM7_LOG_DEBUG, "CL : Extension features(#%d):%s", i, extension_data);
if(i == using_device) {
if(strcasestr(extension_data, "cl_khr_gl_sharing") != NULL) {
if(GLinterop != 0) bCLEnableKhrGLShare = -1;
} else {
bCLEnableKhrGLShare = 0;
}
}
}
XM7_DebugLog(XM7_LOG_DEBUG, "CL : Using device #%d", using_device);
if(bCLEnableKhrGLShare != 0) { // This is only under X11. Must fix.
XM7_DebugLog(XM7_LOG_DEBUG, "CL : GL Interoperability enabled.");
properties[0] = CL_GL_CONTEXT_KHR;
properties[1] = (cl_context_properties)glXGetCurrentContext();
XM7_DebugLog(XM7_LOG_DEBUG, "CL : GL Context = %08x", glXGetCurrentContext());
properties[2] = CL_GLX_DISPLAY_KHR;
properties[3] = (cl_context_properties)glXGetCurrentDisplay();
XM7_DebugLog(XM7_LOG_DEBUG, "CL : GL Display = %08x", glXGetCurrentDisplay());
properties[4] = CL_CONTEXT_PLATFORM;
properties[5] = (cl_context_properties)platform_id[platform_num];
properties[6] = 0;
} else {
XM7_DebugLog(XM7_LOG_DEBUG, "CL : GL Interoperability disabled.");
properties[0] = CL_CONTEXT_PLATFORM;
properties[1] = (cl_context_properties)platform_id[platform_num];
properties[2] = 0;
}
// if(device_id == NULL) return -1;
context = clCreateContext(properties, 1, &device_id[using_device], cl_notify_log, NULL, &ret);
XM7_DebugLog(XM7_LOG_DEBUG, "CL : Created context : STS = %d", ret);
if(ret != CL_SUCCESS) return ret;
command_queue = clCreateCommandQueue(context, device_id[using_device],
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &ret);
XM7_DebugLog(XM7_LOG_DEBUG, "CL: Created command queue.");
return ret;
}
/**
* @brief Send commands.
* Send commands to system server.
* @param field [I ] command.
* @param *data [I ] pointer to data needed for command.
* @param len [I ] Data size.
* @return Function to excute command.
* @retval -1 Fail to send command.
*/
int ControlSystemData(unsigned int field, void *data, unsigned int len)
{
int ret = 0;
if(len == 0 || data == NULL)
return -1;
switch(field){
case SFIELD_GET_DHCPC_ENABLE:
ret = GetDhcpEn(data, len);
break;
case SFIELD_GET_HTTPPORT:
ret = GetHttpPort(data, len);
break;
case SFIELD_GET_SNTP_FQDN:
ret = GetSntpFqdn(data, len);
break;
case SFIELD_GET_DEVICE_TYPE:
ret = GetDeviceType(data, len);
break;
case SFIELD_GET_TITLE:
ret = GetTitle(data, len);
break;
case SFIELD_GET_REGUSR:
ret = GetRegUsr(data, len);
break;
case SFIELD_GET_OSDTEXT:
ret = GetOSDText(data, len);
break;
case SFIELD_GET_MAC:
ret = GetMAC(data, len);
break;
case SFIELD_GET_IP:
ret = GetIP(data, len);
break;
case SFIELD_GET_GATEWAY:
ret = GetGateway(data, len);
break;
case SFIELD_GET_NETMASK:
ret = GetNetmask(data, len);
break;
case SFIELD_GET_FTP_SERVER_IP:
ret = GetFtpServerIp(data, len);
break;
case SFIELD_GET_FTP_USERNAME:
ret = GetFtpUsername(data, len);
break;
case SFIELD_GET_FTP_PASSWORD:
ret = GetFtpPassword(data, len);
break;
case SFIELD_GET_FTP_FOLDNAME:
ret = GetFtpFoldername(data, len);
break;
case SFIELD_GET_FTP_IMAGEAMOUNT:
ret = GetFtpImageAmount(data, len);
break;
case SFIELD_GET_FTP_PID:
ret = GetFtpPid(data, len);
break;
case SFIELD_GET_FTP_PORT:
ret = GetSysFtpPort(data, len);
break;
case SFIELD_GET_SMTP_SERVER_IP:
ret = GetSmtpServerIp(data, len);
break;
case SFIELD_GET_SMTP_PORT:
ret = GetSmtpServerPort(data, len);
break;
case SFIELD_GET_SMTP_AUTHENTICATION:
ret = GetSmtpAuthentication(data, len);
break;
case SFIELD_GET_SMTP_USERNAME:
ret = GetsmtpUsername(data, len);
break;
case SFIELD_GET_SMTP_PASSWORD:
ret = GetSmtpPassword(data, len);
break;
case SFIELD_GET_SMTP_SENDER_EMAIL_ADDRESS:
ret = GetSmtpSenderEmail(data, len);
break;
case SFIELD_GET_SMTP_RECEIVER_EMAIL_ADDRESS:
ret = GetSmtpReceiverEmail(data, len);
break;
case SFIELD_GET_SMTP_CC:
ret = GetSmtpCC(data, len);
break;
case SFIELD_GET_SD_FILE_NAME:
ret = SysGetSdFileName(data, len);
break;
case SFIELD_GET_SMTP_SUBJECT:
ret = GetSmtpSubject(data, len);
break;
case SFIELD_GET_SMTP_TEXT:
ret = GetSmtpText(data, len);
break;
case SFIELD_GET_SMTP_ATTACHMENTS:
ret = GetSmtpAttachments(data, len);
break;
case SFIELD_GET_SMTP_VIEW:
ret = GetSmtpView(data, len);
break;
/*case SFIELD_GET_UPNP_PORT:
ret = GetSysUpnpPort(data, len);
break;*/
case SFIELD_SET_NETMASK:
ret = SetNetMask(data, len);
break;
case SFIELD_SET_TIMEFORMAT:
ret = SetSysTimeFormat(data, len);
break;
case SFIELD_SET_DAYLIGHT:
ret = SetSysDaylight(data, len);
break;
case SFIELD_SET_TIMEZONE:
ret = SetSysTimeZone(data, len);
break;
case SFIELD_SET_IP:
ret = SetIp(data, len);
break;
case SFIELD_SET_HTTPPORT:
ret = SetHttpPort(data, len);
break;
case SFIELD_SET_TITLE:
ret = SetTitle(data, len);
break;
case SFIELD_SET_REGUSR:
ret = SetRegUsr(data, len);
break;
case SFIELD_SET_OSDTEXT:
ret = SetOSDText(data, len);
break;
case SFIELD_SET_GATEWAY:
ret = SetGateway(data, len);
break;
case SFIELD_SET_DHCPC_ENABLE:
ret = SetDhcpEnable(data, len);
break;
case SFIELD_SET_FTP_SERVER_IP:
ret = SetSysFtpFqdn(data, len);
break;
case SFIELD_SET_FTP_USERNAME:
ret = SetFtpUsername(data, len);
break;
case SFIELD_SET_FTP_PASSWORD:
ret = SetFtpPassword(data, len);
break;
case SFIELD_SET_FTP_FOLDNAME:
ret = SetFtpFoldname(data, len);
break;
case SFIELD_SET_FTP_IMAGEAMOUNT:
ret = SetFtpImageacount(data, len);
break;
case SFIELD_SET_FTP_PID:
ret = SetFtpPid(data, len);
break;
case SFIELD_SET_FTP_PORT:
ret = SetSysFtpPort(data, len);
break;
case SFIELD_SET_SMTP_SERVER_IP:
ret = SetSmtpServerIp(data, len);
break;
case SFIELD_SET_SMTP_PORT:
ret = SetSmtpServerPort(data, len);
break;
case SFIELD_SET_SMTP_AUTHENTICATION:
ret = SetSmtpAuthentication(data, len);
break;
case SFIELD_SET_SMTP_USERNAME:
ret = SetSmtpUsername(data, len);
break;
case SFIELD_SET_SMTP_PASSWORD:
ret = SetSmtpPassword(data, len);
break;
case SFIELD_SET_SMTP_SENDER_EMAIL_ADDRESS:
ret = SetSmtpSenderEmail(data, len);
break;
case SFIELD_SET_SMTP_RECEIVER_EMAIL_ADDRESS:
ret = SetSmtpReceiverEmail(data, len);
break;
case SFIELD_SET_SMTP_CC:
ret = SetSmtpCC(data, len);
break;
case SFIELD_SET_SMTP_SUBJECT:
ret = SetSmtpSubject(data, len);
break;
case SFIELD_SET_SMTP_TEXT:
ret = SetSmtpText(data, len);
break;
case SFIELD_SET_SMTP_ATTACHMENTS:
ret = SetSmtpAttachments(data, len);
break;
case SFIELD_SET_SMTP_VIEW:
ret = SetSmtpView(data, len);
break;
case SFIELD_GET_DNS:
ret = GetDns(data, len);
break;
case SFIELD_SET_DNS:
ret = SetDns(data, len);
break;
case SFIELD_SET_SNTP_SERVER:
ret = SetSntpServer(data, len);
break;
case SFIELD_SET_DAY_NIGHT:
ret = SetSysDayNight(data, len);
break;
case SFIELD_SET_WHITE_BALANCE:
ret = SetSysWhiteBalance(data, len);
break;
case SFIELD_SET_BACKLIGHT:
ret = SetSysBacklight(data, len);
break;
case SFIELD_SET_BRIGHTNESS:
ret = SetSysBrightness(data, len);
break;
case SFIELD_SET_CONTRAST:
ret = SetSysContrast(data, len);
break;
case SFIELD_SET_SATURATION:
ret = SetSysSaturation(data, len);
break;
case SFIELD_SET_SHARPNESS:
ret = SetSysSharpness(data, len);
break;
case SFIELD_SET_VSTAB:
ret = SetSysCommon(data, len, SYS_MSG_SET_VSTAB);
break;
case SFIELD_SET_LDC:
ret = SetSysCommon(data, len, SYS_MSG_SET_LDC);
break;
case SFIELD_SET_SNF:
ret = SetSysCommon(data, len, SYS_MSG_SET_SNF);
break;
case SFIELD_SET_TNF:
ret = SetSysCommon(data, len, SYS_MSG_SET_TNF);
break;
case SFIELD_SET_MAXEXPOSURE:
ret = SetSysCommon(data, len, SYS_MSG_SET_MAXEXPOSURE);
break;
case SFIELD_SET_MAXGAIN:
ret = SetSysCommon(data, len, SYS_MSG_SET_MAXGAIN);
break;
case SFIELD_SET_EXPPRIORITY:
ret = SetSysCommon(data, len, SYS_MSG_SET_EXPPRIORITY);
break;
case SFIELD_SET_AUDIOMODE:
ret = SetSysCommon(data, len, SYS_MSG_SET_AUDIOMODE);
break;
case SFIELD_SET_AUDIO_ENCODE:
ret = SetSysCommon(data, len, SYS_MSG_SET_AUDIO_ENCODE);
break;
case SFIELD_SET_AUDIO_SAMPLERATE:
ret = SetSysCommon(data, len, SYS_MSG_SET_AUDIO_SAMPLERATE);
break;
case SFIELD_SET_AUDIO_BITRATE:
ret = SetSysCommon(data, len, SYS_MSG_SET_AUDIO_BITRATE);
break;
case SFIELD_SET_AUDIO_ALARMLEVEL:
ret = SetSysCommon(data, len, SYS_MSG_SET_AUDIO_ALARMLEVEL);
break;
case SFIELD_SET_AUDIOOUTVOLUME:
ret = SetSysCommon(data, len, SYS_MSG_SET_AUDIOOUTVOLUME);
break;
case SFIELD_SET_AUDIORECEIVERENABLE:
ret = SetSysAudioReceiverEnable(data, len);
break;
case SFIELD_SET_AUDIOSERVERIP:
ret = SetSysAudioServerIp(data, len);
break;
case SFIELD_SET_DEFAULT:
ret = SetSysCommon(data, len, SYS_MSG_SET_DEFAULT);
break;
case SFIELD_SET_CLEARSYSLOG:
ret = SetSysClearSysLog(data, len);
break;
case SFIELD_SET_CLEARACCESSLOG:
ret = SetSysClearAccessLog(data, len);
break;
case SFIELD_SET_JQUALITY:
ret = SetSysJpegQuality(data, len);
break;
case SFIELD_SET_FDETECT:
ret = SetSysfdetect(data, len);
break;
case SFIELD_SET_FDX:
ret = SetSysfdx(data, len);
break;
case SFIELD_SET_FDY:
ret = SetSysfdy(data, len);
break;
case SFIELD_SET_FDW:
ret = SetSysfdw(data, len);
break;
case SFIELD_SET_FDH:
ret = SetSysfdh(data, len);
break;
case SFIELD_SET_FDCONF_LEVEL:
ret = SetSysfdconf(data, len);
break;
case SFIELD_SET_FD_DIRECTION:
ret = SetSysfddir(data, len);
break;
case SFIELD_SET_FRECOGNITION:
ret = SetSysfrecog(data, len);
break;
case SFIELD_SET_FRCONF_LEVEL:
ret = SetSysfrconf(data, len);
break;
case SFIELD_SET_FR_DATABASE:
ret = SetSysfrdbase(data, len);
break;
case SFIELD_SET_PRIVACY_MASK:
ret = SetSyspmask(data, len);
break;
case SFIELD_SET_MASK_OPTIONS:
ret = SetSyspmaskopt(data, len);
break;
case SFIELD_SET_ADVMODE:
ret = SetSysAdvMode(data, len);
break;
case SFIELD_SET_MIRROR:
ret = SetSysMirror(data, len);
break;
case SFIELD_SET_DEMOCFG:
ret = SetSysDemoCfg(data, len);
break;
case SFIELD_SET_OSDWIN:
ret = SetSysOSDWin(data, len);
break;
case SFIELD_SET_HISTOGRAM:
ret = SetSysHistogram(data, len);
break;
case SFIELD_SET_DYNRANGE:
ret = SetSysDynRange(data, len);
break;
case SFIELD_SET_OSDWINNUM:
ret = SetSysOSDWinNum(data, len);
break;
case SFIELD_SET_OSDSTREAM:
ret = SetSysOSDStream(data, len);
break;
case SFIELD_SET_VIDEO_MODE:
ret = SetSysVideoMode(data, len);
break;
case SFIELD_SET_VIDEOCODECCOMBO:
ret = SetSysVideoCodecCombo(data, len);
break;
case SFIELD_SET_VIDEOCODECRES:
ret = SetSysVideoCodecRes(data, len);
break;
case SFIELD_SET_IMAGESOURCE:
ret = SetSysImageSource(data, len);
break;
case SFIELD_SET_SCHEDULE:
ret = SetSysSchedule(data, len);
break;
case SFIELD_SET_IMAGEFORMAT:
ret = SetSysIMGFormat(data, len);
break;
case SFIELD_SET_RESOLUTION:
ret = SetSysResolution(data, len);
break;
case SFIELD_SET_MPEG4_RES:
ret = SetSysMPEG4Res(data, len);
break;
case SFIELD_SET_MPEG42_RES:
ret = SetSysMPEG42Res(data, len);
break;
case SFIELD_SET_LOSTALARM:
ret = SetSysLostAlarm(data, len);
break;
case SFIELD_SET_SDAENABLE:
ret = SetSysSDAlarmEnable(data, len);
break;
case SFIELD_SET_AFTPENABLE:
ret = SetSysFtpAlarmEnable(data, len);
break;
case SFIELD_SET_ASMTPENABLE:
ret = SetSysSmtpAlarmEnable(data, len);
break;
case SFIELD_SET_ALARMDURATION:
ret = SetSysAlarmDuration(data, len);
break;
case SFIELD_SET_AVIDURATION:
ret = SetAVIDuration(data, len);
break;
case SFIELD_SET_AVIFORMAT:
ret = SetAVIFormat(data, len);
break;
case SFIELD_SET_FTPFILEFORMAT:
ret = SetFTPFileFormat(data, len);
break;
case SFIELD_SET_SDFILEFORMAT:
ret = SetSDFileFormat(data, len);
break;
case SFIELD_SET_ATTFILEFORMAT:
ret = SetAttFileFormat(data, len);
break;
case SFIELD_SET_AUDIOENABLE:
ret = SetAudioEnable(data, len);
break;
case SFIELD_SET_ASMTPATTACH:
ret = SetASmtpAttach(data, len);
break;
case SFIELD_SET_FTP_RFTPENABLE:
ret = SetRftpEnable(data, len);
break;
case SFIELD_SET_SD_SDRENABLE:
ret = SetSdReEnable(data, len);
break;
case SFIELD_SET_MOTIONENABLE:
ret = SetMotionEnable(data, len);
break;
case SFIELD_SET_MOTIONCENABLE:
ret = SetMotionCEnable(data, len);
break;
case SFIELD_SET_MOTIONLEVEL:
ret = SetMotionLevel(data, len);
break;
case SFIELD_SET_MOTIONCVALUE:
ret = SetMotionCValue(data, len);
break;
case SFIELD_SET_MOTIONBLOCK:
ret = SetMotionBlock(data, len);
break;
case SFIELD_GET_DHCP_CONFIG:
ret = GetSysDhcpConfig(data, len);
break;
case SFIELD_DEL_SCHEDULE:
ret = DelSysSchedule(data, len);
break;
case SFIELD_SET_IMAGE2A:
ret = SetSysImage2A(data, len);
break;
case SFIELD_SET_IMAGE2ATYPE:
ret = SetSysImage2AType(data, len);
break;
case SFIELD_SET_BINNING:
ret = SetSysBinning(data, len);
break;
case SFIELD_SET_BLC:
ret = SetSysBLC(data, len);
break;
case SFIELD_SET_MPEG41_BITRATE:
ret = SetMPEG41Bitrate(data, len);
break;
case SFIELD_SET_MPEG42_BITRATE:
ret = SetMPEG42Bitrate(data, len);
break;
case SFIELD_SET_CLICK_SNAP_FILENAME :
ret = SetSysClickSnapFilename(data, len);
break;
case SFIELD_SET_CLICK_SNAP_STORAGE :
ret = SetSysClickSnapStorage(data, len);
break;
case SFIELD_SET_RATE_CONTROL1:
ret = SetSysRateControl1(data, len);
break;
case SFIELD_SET_RATE_CONTROL2:
ret = SetSysRateControl2(data, len);
break;
case SFIELD_SET_DSTAMPENABLE1:
ret = SetSysDateStampEnable1(data, len);
break;
case SFIELD_SET_DSTAMPENABLE2:
ret = SetSysDateStampEnable2(data, len);
break;
case SFIELD_SET_DSTAMPENABLE3:
ret = SetSysDateStampEnable3(data, len);
break;
case SFIELD_SET_TSTAMPENABLE1:
ret = SetSysTimeStampEnable1(data, len);
break;
case SFIELD_SET_TSTAMPENABLE2:
ret = SetSysTimeStampEnable2(data, len);
break;
case SFIELD_SET_TSTAMPENABLE3:
ret = SetSysTimeStampEnable3(data, len);
break;
case SFIELD_SET_LOGOENABLE1:
ret = SetSysLogoEnable1(data, len);
break;
case SFIELD_SET_LOGOENABLE2:
ret = SetSysLogoEnable2(data, len);
break;
case SFIELD_SET_LOGOENABLE3:
ret = SetSysLogoEnable3(data, len);
break;
case SFIELD_SET_LOGO_POSITION1:
ret = SetSysLogoPosition1(data, len);
break;
case SFIELD_SET_LOGO_POSITION2:
ret = SetSysLogoPosition2(data, len);
break;
case SFIELD_SET_LOGO_POSITION3:
ret = SetSysLogoPosition3(data, len);
break;
case SFIELD_SET_TEXTENABLE1:
ret = SetSysTextEnable1(data, len);
break;
case SFIELD_SET_TEXTENABLE2:
ret = SetSysTextEnable2(data, len);
break;
case SFIELD_SET_TEXTENABLE3:
ret = SetSysTextEnable3(data, len);
break;
case SFIELD_SET_TEXT_POSITION1:
ret = SetSysTextPosition1(data, len);
break;
case SFIELD_SET_TEXT_POSITION2:
ret = SetSysTextPosition2(data, len);
break;
case SFIELD_SET_TEXT_POSITION3:
ret = SetSysTextPosition3(data, len);
break;
case SFIELD_SET_OVERLAY_TEXT1:
ret = SetSysOverlayText1(data, len);
break;
case SFIELD_SET_OVERLAY_TEXT2:
ret = SetSysOverlayText2(data, len);
break;
case SFIELD_SET_OVERLAY_TEXT3:
ret = SetSysOverlayText3(data, len);
break;
case SFIELD_SET_DETAIL_INFO1:
ret = SetSysCommon(data, len, SYS_MSG_SET_DETAIL_INFO1);
break;
case SFIELD_SET_DETAIL_INFO2:
ret = SetSysCommon(data, len, SYS_MSG_SET_DETAIL_INFO2);
break;
case SFIELD_SET_DETAIL_INFO3:
ret = SetSysCommon(data, len, SYS_MSG_SET_DETAIL_INFO3);
break;
case SFIELD_SET_ALARMLOCAL:
ret = SetSysCommon(data, len, SYS_MSG_SET_ALARMLOCAL);
break;
case SFIELD_SET_RECORDLOCAL:
ret = SetSysCommon(data, len, SYS_MSG_SET_RECORDLOCAL);
break;
case SFIELD_SET_ENCRYPT_VIDEO:
ret = SetSysEncryptVideo(data, len);
break;
case SFIELD_SET_LOCAL_DISPLAY:
ret = SetSysLocalDisplay(data, len);
break;
case SFIELD_SET_IPRATIO1:
ret = SetSysIpratio1(data, len);
break;
case SFIELD_SET_IPRATIO2:
ret = SetSysIpratio2(data, len);
break;
case SFIELD_SET_IPRATIO3:
ret = SetSysIpratio3(data, len);
break;
case SFIELD_SET_FORCE_IFRAME1:
ret = SetSysForceIframe1(data, len);
break;
case SFIELD_SET_FORCE_IFRAME2:
ret = SetSysForceIframe2(data, len);
break;
case SFIELD_SET_FORCE_IFRAME3:
ret = SetSysForceIframe3(data, len);
break;
case SFIELD_SET_QPINIT1:
ret = SetSysQPInit1(data, len);
break;
case SFIELD_SET_QPINIT2:
ret = SetSysQPInit2(data, len);
break;
case SFIELD_SET_QPINIT3:
ret = SetSysQPInit3(data, len);
break;
case SFIELD_SET_QPMIN1:
ret = SetSysQPMin1(data, len);
break;
case SFIELD_SET_QPMIN2:
ret = SetSysQPMin2(data, len);
break;
case SFIELD_SET_QPMIN3:
ret = SetSysQPMin3(data, len);
break;
case SFIELD_SET_QPMAX1:
ret = SetSysQPMax1(data, len);
break;
case SFIELD_SET_QPMAX2:
ret = SetSysQPMax2(data, len);
break;
case SFIELD_SET_QPMAX3:
ret = SetSysQPMax3(data, len);
break;
case SFIELD_SET_MECONFIG1:
ret = SetSysMEConfig1(data, len);
break;
case SFIELD_SET_MECONFIG2:
ret = SetSysMEConfig2(data, len);
break;
case SFIELD_SET_MECONFIG3:
ret = SetSysMEConfig3(data, len);
break;
case SFIELD_SET_PACKETSIZE1:
ret = SetSysPacketSize1(data, len);
break;
case SFIELD_SET_PACKETSIZE2:
ret = SetSysPacketSize2(data, len);
break;
case SFIELD_SET_PACKETSIZE3:
ret = SetSysPacketSize3(data, len);
break;
case SFIELD_SET_ROI_ENABLE1:
ret = SetSysROIEnable1(data, len);
break;
case SFIELD_SET_ROI_ENABLE2:
ret = SetSysROIEnable2(data, len);
break;
case SFIELD_SET_ROI_ENABLE3:
ret = SetSysROIEnable3(data, len);
break;
case SFIELD_SET_STR1X1:
ret = SetSysStr1X1(data, len);
break;
case SFIELD_SET_STR1Y1:
ret = SetSysStr1Y1(data, len);
break;
case SFIELD_SET_STR1W1:
ret = SetSysStr1W1(data, len);
break;
case SFIELD_SET_STR1H1:
ret = SetSysStr1H1(data, len);
break;
case SFIELD_SET_STR1X2:
ret = SetSysStr1X2(data, len);
break;
case SFIELD_SET_STR1Y2:
ret = SetSysStr1Y2(data, len);
break;
case SFIELD_SET_STR1W2:
ret = SetSysStr1W2(data, len);
break;
case SFIELD_SET_STR1H2:
ret = SetSysStr1H2(data, len);
break;
case SFIELD_SET_STR1X3:
ret = SetSysStr1X3(data, len);
break;
case SFIELD_SET_STR1Y3:
ret = SetSysStr1Y3(data, len);
break;
case SFIELD_SET_STR1W3:
ret = SetSysStr1W3(data, len);
break;
case SFIELD_SET_STR1H3:
ret = SetSysStr1H3(data, len);
break;
case SFIELD_SET_STR2X1:
ret = SetSysStr2X1(data, len);
break;
case SFIELD_SET_STR2Y1:
ret = SetSysStr2Y1(data, len);
break;
case SFIELD_SET_STR2W1:
ret = SetSysStr2W1(data, len);
break;
case SFIELD_SET_STR2H1:
ret = SetSysStr2H1(data, len);
break;
case SFIELD_SET_STR2X2:
ret = SetSysStr2X2(data, len);
break;
case SFIELD_SET_STR2Y2:
ret = SetSysStr2Y2(data, len);
break;
case SFIELD_SET_STR2W2:
ret = SetSysStr2W2(data, len);
break;
case SFIELD_SET_STR2H2:
ret = SetSysStr2H2(data, len);
break;
case SFIELD_SET_STR2X3:
ret = SetSysStr2X3(data, len);
break;
case SFIELD_SET_STR2Y3:
ret = SetSysStr2Y3(data, len);
break;
case SFIELD_SET_STR2W3:
ret = SetSysStr2W3(data, len);
break;
case SFIELD_SET_STR2H3:
ret = SetSysStr2H3(data, len);
break;
case SFIELD_SET_STR3X1:
ret = SetSysStr3X1(data, len);
break;
case SFIELD_SET_STR3Y1:
ret = SetSysStr3Y1(data, len);
break;
case SFIELD_SET_STR3W1:
ret = SetSysStr3W1(data, len);
break;
case SFIELD_SET_STR3H1:
ret = SetSysStr3H1(data, len);
break;
case SFIELD_SET_STR3X2:
ret = SetSysStr3X2(data, len);
break;
case SFIELD_SET_STR3Y2:
ret = SetSysStr3Y2(data, len);
break;
case SFIELD_SET_STR3W2:
ret = SetSysStr3W2(data, len);
break;
case SFIELD_SET_STR3H2:
ret = SetSysStr3H2(data, len);
break;
case SFIELD_SET_STR3X3:
ret = SetSysStr3X3(data, len);
break;
case SFIELD_SET_STR3Y3:
ret = SetSysStr3Y3(data, len);
break;
case SFIELD_SET_STR3W3:
ret = SetSysStr3W3(data, len);
break;
case SFIELD_SET_STR3H3:
ret = SetSysStr3H3(data, len);
break;
case SFIELD_SET_IMAGEDEFAULT:
ret = SetImageDefault(data, len);
break;
case SFIELD_DO_LOGIN:
ret = DoSysLogin(data, len);
break;
case SFIELD_GET_USER_AUTHORITY:
ret = GetSysUserAuthority(data, len);
break;
case SFIELD_ADD_USER:
ret = SysAddUser(data, len);
break;
case SFIELD_DEL_USER:
ret = SysDelUser(data, len);
break;
case SFIELD_IPNCPTZ:
ret = SetIpncPtz(data, len);
break;
case SFIELD_INIT_IPNCPTZ:
ret = InitIpncPtz(data, len);
break;
case SFIELD_SD_FORMAT:
ret = SysSdFormat(data, len);
break;
case SFIELD_SD_UNMOUNT:
ret = SysSdUnmount(data, len);
break;
case SFIELD_SET_GIOINENABLE:
ret = SetGIOInEnable(data, len);
break;
case SFIELD_SET_GIOINTYPE:
ret = SetGIOInType(data, len);
break;
case SFIELD_SET_GIOOUTENABLE:
ret = SetGIOOutEnable(data, len);
break;
case SFIELD_SET_GIOOUTTYPE:
ret = SetGIOOutType(data, len);
break;
case SFIELD_SET_TSTAMPENABLE:
ret = SetTStampEnable(data, len);
break;
case SFIELD_SET_DATEFORMAT:
ret = SetSysCommon(data, len, SYS_MSG_SET_DATEFORMAT);
break;
case SFIELD_SET_TSTAMPFORMAT:
ret = SetSysCommon(data, len, SYS_MSG_SET_TSTAMPFORMAT);
break;
case SFIELD_SET_DATEPPOS:
ret = SetSysCommon(data, len, SYS_MSG_SET_DATEPPOS);
break;
case SFIELD_SET_TIMEPOS:
ret = SetSysCommon(data, len, SYS_MSG_SET_TIMEPOS);
break;
case SFIELD_SET_AUDIOINVOLUME:
ret = SetAudioinVolume(data, len);
break;
case SFIELD_SET_RATE_CONTROL:
ret = SetSysRateControl(data, len);
break;
case SFIELD_SET_FRAMERATE1:
ret = SetSysFramerate1(data, len);
break;
case SFIELD_SET_FRAMERATE2:
ret = SetSysFramerate2(data, len);
break;
case SFIELD_SET_FRAMERATE3:
ret = SetSysFramerate3(data, len);
break;
case SFIELD_SCHEDULE_STOP:
ret = SysScheduleStop(data, len);
break;
case SFIELD_SCHEDULE_RESUME:
ret = SysScheduleResume(data, len);
break;
case SFIELD_SET_MULTICAST:
ret = SetSysMulticast(data, len);
break;
case SFIELD_SET_HTTPSPORT:
ret = SetSysCommon(data, len, SYS_MSG_SET_HTTPSPORT);
break;
case SFIELD_SET_RS485:
ret = SetSysCommon(data, len, SYS_MSG_SET_RS485);
break;
case SFIELD_SET_ALARM_ENABLE:
ret = SetSysCommon(data, len, SYS_MSG_SET_ALARM_ENABLE);
break;
case SFIELD_SET_EXT_ALARM:
ret = SetSysCommon(data, len, SYS_MSG_SET_EXT_ALARM);
break;
case SFIELD_SET_AUDIOALARM:
ret = SetSysCommon(data, len, SYS_MSG_SET_AUDIOALARM);
break;
case SFIELD_SET_ALARM_AUDIOPLAY:
ret = SetSysCommon(data, len, SYS_MSG_SET_ALARM_AUDIOPLAY);
break;
case SFIELD_SET_ALARM_AUDIOFILE:
ret = SetSysCommon(data, len, SYS_MSG_SET_ALARM_AUDIOFILE);
break;
case SFIELD_SET_SCHEDULE_REPEAT_ENABLE:
ret = SetSysCommon(data, len, SYS_MSG_SET_SCHEDULE_REPEAT_ENABLE);
break;
case SFIELD_SET_SCHEDULE_NUMWEEKS:
ret = SetSysCommon(data, len, SYS_MSG_SET_SCHEDULE_NUM_WEEKS);
break;
case SFIELD_SET_SCHEDULE_INFINITE_ENABLE:
ret = SetSysCommon(data, len, SYS_MSG_SET_SCHEDULE_INFINITE_ENABLE);
break;
case SFIELD_SET_LINEARWDR:
ret = SetSysLinearWdr(data, len);
break;
case SFIELD_SET_FLICKER_DETECT:
ret = SetSysFlickerDetect(data, len);
break;
default:
ret = -1;
break;
}
return ret;
}
/*
##############################################
##Int ModuleResize(Int argc, Char *argv[])
##############################################
*/
Int ModuleResize(Int argc, Char *argv[])
{
Uns initMask = 0;
Int status = EXIT_SUCCESS;
Rendezvous_Attrs rzvAttrs = Rendezvous_Attrs_DEFAULT;
Fifo_Attrs fAttrs = Fifo_Attrs_DEFAULT;
Rendezvous_Handle hRendezvousInit = NULL;
Rendezvous_Handle hRendezvousWriter = NULL;
Rendezvous_Handle hRendezvousCleanup = NULL;
Int numThreads = 0;
pthread_t id_listen[5] = {0};
Void *ret;
char devicebuf[16] = {0};
CaptureEnv captureEnv;
WriterEnv writerEnv;
WriterEnv writerLowRateEnv;
DetectEnv detectEnv;
VideoEnv videoEnv;
VideoEnv videoLowRateEnv;//dd
VideoEnv LowRateResize;
AudioEnv audioEnv;
CtrlEnv ctrlEnv;
char box_version[64] = {0};
OutputVideoInfo outputhandle;
textinfo *texthandle;
int DHCPVAL = 0, tmp = 0;
char gateway[255] = {0};
struct sched_param schedParam;
pthread_t captureThread;
pthread_t detectThread;
pthread_t writerThread;
pthread_t writerLowThread;
pthread_t videoThread;
pthread_t audioThread;
pthread_t videoLowThread;
pthread_t resizeLowThread;
#ifdef DSS_ENC_1100_1200
pthread_t webListenThread;
#endif
pthread_attr_t attr;
int index = 0;
int result = 0;
char ts_version[128] = {0};
/* Zero out the thread environments */
Dmai_clear(captureEnv);
Dmai_clear(writerEnv);
Dmai_clear(videoEnv);
Dmai_clear(audioEnv);
Dmai_clear(ctrlEnv);
mid_task_init();
trace_init();
open_gpio_port();
ts_build_get_version(ts_version, sizeof(ts_version));
strcpy(box_version, BOX_VER);
strcat(box_version, CODE_TYPE);
strcat(box_version, DEUBG);
printf("[%s] Module Encode Program %s V%s\n", CODE_COND, BOARD_TYPE, box_version);
printf("the build time is %s,the git vesion is %s.the ts version is %s\n\n", g_make_build_date, _VERSION, ts_version);
initMutexPthread();
InitgblCommonMutex();
InitSysParams();
initOutputVideoParam();
InitHVTable(&gHVTable);
// webgetDHCPFlag(tmp, &DHCPVAL);
// readDHCPValue(DHCPCONFIG_FILE, &DHCPVAL);
// setDHCPFlag(DHCPVAL);
gLogoinfo = initLogoMod();
initTextinfo();
ReadEncodeParamTable(CONFIG_NAME, &gSysParaT);
DHCPVAL = gSysParaT.sysPara.nTemp[0];
printf("----mic=%x:%x:%x:%x:%x:%x\n",gSysParaT.sysPara.szMacAddr[0],gSysParaT.sysPara.szMacAddr[1],gSysParaT.sysPara.szMacAddr[2],
gSysParaT.sysPara.szMacAddr[3],gSysParaT.sysPara.szMacAddr[4],gSysParaT.sysPara.szMacAddr[5]);
ReadLowbitParamTable(LOWBIT_PARAM, &gSysParaT);
memset(&outputhandle, 0, sizeof(OutputVideoInfo));
getOutputvideohandle(&outputhandle);
readOutputVideoParam(VIDEOENCODE_FILE, &outputhandle);
setOutputvideohandle(&outputhandle);
//sleep(10);
ReadLogoinfo(LOGOCONFIGNAME, gLogoinfo);
//setLogoInfoHandle(logoEnv);
//sleep(10);
texthandle = getTextInfoHandle();
readTextFromfile(ADDTEXT_FILE, texthandle);
// DEBUG(DL_DEBUG, "%d,%d,%d,%d,%d,%d,%s\n", DHCPVAL, texthandle->xpos, texthandle->ypos,
// texthandle->enable, texthandle->showtime, texthandle->alpha, texthandle->msgtext);
// sleep(10);
#ifdef DSS_ENC_1100_1200
ReadProtocolIni(PROTOCOL_NAME, &gProtocol);
#endif
ReadRemoteCtrlIndex(REMOTE_NAME, &index);
/*Read I frames Interval*/
ReadIframeInterval(IFRAMES_NAME);
/*green Save Module*/
app_init_green_adjust_module();
#ifdef CL4000_DVI
app_init_screen_adjust_module();
#endif
gblSetRemoteIndex(index);
ReadHVTable(&gHVTable, 0);
ReadHVTable(&gHVTable, 1);
#ifdef CL4000_DVI_SDI
ReadIPParamTable(IP_PARAM, &gSysParaT);
#endif
if(DHCPVAL) {
printf("i will set dhcp.\n");
#if 1
system("kill -1 `cat /var/run/dhcpcd-eth0.pid`");
system("/sbin/dhcpcd eth0");
system("ifconfig eth0");
#endif
gSysParaT.sysPara.dwNetMark = GetNetmask("eth0");
gSysParaT.sysPara.dwAddr = GetIPaddr("eth0");
get_gateway(gateway);
gSysParaT.sysPara.dwGateWay = get_gateway(gateway);
DEBUG(DL_DEBUG, "gateway =%s\n", gateway);
} else {
printf("i will set static ip.\n");
SetEthConfigIP(gSysParaT.sysPara.dwAddr, gSysParaT.sysPara.dwNetMark);
SetEthConfigGW(gSysParaT.sysPara.dwGateWay);
}
system("ifconfig");
strcpy(gSysParaT.sysPara.strVer, box_version);
initSetParam();
DEBUG(DL_DEBUG, "logo=%d text=%d ,texthandle->enable=%d,texthandle->showtime=%d\n", outputhandle.logo_show, outputhandle.text_show, texthandle->enable, texthandle->showtime);
#ifdef DSS_ENC_1100_1200
/*open lcd initial*/
OpenLCDCom(); //matchbox ++
gblLoadIDX(); //matchbox ++
if(-2 == ReadDeviceType(DTYPECONFIG_NAME, 1)) {
ReadDeviceType(DTYPECONFIG_NAME, 0);
}
GetDeviceType(devicebuf);
DEBUG(DL_DEBUG, "DTYPECONFIG_NAME gDeviceType = %s\n", devicebuf);
#endif
/*取消PIPE坏的信号*/
Signal(SIGPIPE, SIG_IGN);
/* Set the priority of this whole process to max (requires root) */
setpriority(PRIO_PROCESS, 0, -20);
/*初始化高码流视频编码库参数*/
InitVideoEncParams(&gSysParaT.videoPara[PORT_ONE]);
/*初始化低码流视频编码库参数*/
InitLowRateParams(&gSysParaT.videoPara[PORT_TWO]);
/*初始化音频编码库参数*/
InitAudioEncParams(&gSysParaT.audioPara[PORT_ONE]);
/* Initialize the mutex which protects the global data */
pthread_mutex_init(&gbl.mutex, NULL);
/* Initialize Codec Engine runtime */
CERuntime_init();
/* Initialize Davinci Multimedia Application Interface */
Dmai_init();
closeWatchDog();
mid_timer_init();
initWatchDog();
#ifdef CL4000_DVI_SDI
if(gblGetRemoteIndex() < MAX_FAR_CTRL_NUM) {
result = InitRemoteStruct(gblGetRemoteIndex());
}
gRemoteFD = CameraCtrlInit(PORT_COM2);
if(gRemoteFD <= 0) {
DEBUG(DL_ERROR, "Initial CameraCtrlInit() Error\n");
}
#else
#ifndef ENABLE_DEUBG
if(gblGetRemoteIndex() < MAX_FAR_CTRL_NUM) {
result = InitRemoteStruct(gblGetRemoteIndex());
}
gRemoteFD = CameraCtrlInit(PORT_COM1);
if(gRemoteFD <= 0) {
DEBUG(DL_ERROR, "Initial CameraCtrlInit() Error\n");
}
#endif
#endif
CreateTCPTask(id_listen);
/* Initialize the logs. Must be done after CERuntime_init() */
/* if(TraceUtil_start(engine->engineName) != TRACEUTIL_SUCCESS)
{
ERR("Failed to TraceUtil_start\n");
cleanup(EXIT_FAILURE);
} */
//initMask |= LOGSINITIALIZED;
app_set_logoshow_flag(outputhandle.logo_show);
app_set_textshow_flag(outputhandle.text_show) ;
//setShowLogoTextFlag(outputhandle->logotext);
addtextdisplay(texthandle);
/* Determine the number of threads needing synchronization */
numThreads = 1;
/*视频线程个数*/
numThreads += 7;
/*音频线程个数*/
numThreads += 1;
/* Create the objects which synchronizes the thread init and cleanup */
hRendezvousInit = Rendezvous_create(numThreads, &rzvAttrs);
hRendezvousCleanup = Rendezvous_create(numThreads, &rzvAttrs);
hRendezvousWriter = Rendezvous_create(3, &rzvAttrs);
if(hRendezvousInit == NULL ||
hRendezvousCleanup == NULL ||
hRendezvousWriter == NULL) {
ERR("Failed to create Rendezvous objects\n");
cleanup(EXIT_FAILURE);
}
/* Initialize the thread attributes */
if(pthread_attr_init(&attr)) {
ERR("Failed to initialize thread attrs\n");
cleanup(EXIT_FAILURE);
}
/* Force the thread to use custom scheduling attributes */
if(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED)) {
ERR("Failed to set schedule inheritance attribute\n");
cleanup(EXIT_FAILURE);
}
/* Set the thread to be fifo real time scheduled */
if(pthread_attr_setschedpolicy(&attr, SCHED_FIFO)) {
ERR("Failed to set FIFO scheduling policy\n");
cleanup(EXIT_FAILURE);
}
/* Create the capture fifos */
captureEnv.to_video_c = Fifo_create(&fAttrs);
captureEnv.from_video_c = Fifo_create(&fAttrs);
captureEnv.to_resize_c = Fifo_create(&fAttrs);
captureEnv.from_resize_c = Fifo_create(&fAttrs);
if(captureEnv.to_video_c == NULL || captureEnv.from_video_c == NULL ||
captureEnv.to_resize_c == NULL || captureEnv.from_resize_c == NULL) {
ERR("Failed to open display fifos\n");
cleanup(EXIT_FAILURE);
}
LowRateResize.to_videoresize_c = Fifo_create(&fAttrs);
LowRateResize.from_videoresize_c = Fifo_create(&fAttrs);
if(LowRateResize.to_videoresize_c == NULL || LowRateResize.from_videoresize_c == NULL) {
ERR("Failed to open Resize fifos\n");
cleanup(EXIT_FAILURE);
}
/* Set the capture thread priority */
schedParam.sched_priority = CAPTURE_THREAD_PRIORITY;
if(pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}
/* Create the capture thread */
captureEnv.hRendezvousInit = hRendezvousInit;
captureEnv.hRendezvousCleanup = hRendezvousCleanup;
DEBUG(DL_DEBUG, "captureThrFxn thread!!!!\n");
if(pthread_create(&captureThread, &attr, captureThrFxn, &captureEnv)) {
ERR("Failed to create capture thread\n");
cleanup(EXIT_FAILURE);
}
/* Create the writer fifos */
writerEnv.to_video_c = Fifo_create(&fAttrs);
writerEnv.from_video_c = Fifo_create(&fAttrs);
writerLowRateEnv.to_writelow_c = Fifo_create(&fAttrs);
writerLowRateEnv.from_writelow_c = Fifo_create(&fAttrs);
if(writerEnv.to_video_c == NULL || writerEnv.from_video_c == NULL ||
writerLowRateEnv.to_writelow_c == NULL || writerLowRateEnv.from_writelow_c == NULL) {
ERR("Failed to open display fifos\n");
cleanup(EXIT_FAILURE);
}
initMask |= CAPTURETHREADCREATED ;
/*detect thread*/
detectEnv.hRendezvousInit = hRendezvousInit;
detectEnv.hRendezvousCleanup = hRendezvousCleanup;
/* Set the video thread priority */
schedParam.sched_priority = DETECT_THREAD_PRIORITY;
if(pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}
if(pthread_create(&detectThread, &attr, detectThrFxn, &detectEnv)) {
ERR("Failed to create detect thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= DETECTTHREADCREATED ;
/* Set the video thread priority */
schedParam.sched_priority = VIDEO_THREAD_PRIORITY;
if(pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}
DEBUG(DL_DEBUG, "videoThrFxn thread!!!!\n");
/* Create the video thread */
videoEnv.hRendezvousInit = hRendezvousInit;
videoEnv.hRendezvousCleanup = hRendezvousCleanup;
videoEnv.hRendezvousWriter = hRendezvousWriter;
videoEnv.to_capture = captureEnv.from_video_c;
videoEnv.from_capture = captureEnv.to_video_c;
videoEnv.to_writer = writerEnv.from_video_c;
videoEnv.from_writer = writerEnv.to_video_c;
videoEnv.videoEncoder = engine->videoEncoders->codecName;
videoEnv.engineName = engine->engineName;
if(pthread_create(&videoThread, &attr, videoThrFxn, &videoEnv)) {
ERR("Failed to create video thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= VIDEOTHREADCREATED;
/* Create the videoResize thread */
videoLowRateEnv.hRendezvousInit = hRendezvousInit;
videoLowRateEnv.hRendezvousCleanup = hRendezvousCleanup;
videoLowRateEnv.hRendezvousWriter = hRendezvousWriter;
videoLowRateEnv.to_resize = LowRateResize.from_videoresize_c;
videoLowRateEnv.from_resize = LowRateResize.to_videoresize_c;
videoLowRateEnv.from_writer = writerLowRateEnv.to_writelow_c;
videoLowRateEnv.to_writer = writerLowRateEnv.from_writelow_c;
videoLowRateEnv.videoEncoder = engine->videoEncoders->codecName;
videoLowRateEnv.engineName = engine->engineName;
DEBUG(DL_DEBUG, "videoLowRateThrFxn thread!!!!\n");
if(pthread_create(&videoLowThread, &attr, videoLowRateThrFxn, &videoLowRateEnv)) {
ERR("Failed to create video thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= VIDEOLOWRATETHREAD;
/* Create the video thread */
LowRateResize.hRendezvousInit = hRendezvousInit;
LowRateResize.hRendezvousCleanup = hRendezvousCleanup;
LowRateResize.hRendezvousWriter = hRendezvousWriter;
LowRateResize.from_capture = captureEnv.to_resize_c;
LowRateResize.to_capture = captureEnv.from_resize_c;
LowRateResize.videoEncoder = engine->videoEncoders->codecName;
LowRateResize.engineName = engine->engineName;
/* Set the video thread priority */
schedParam.sched_priority = VIDEO_THREAD_PRIORITY;
if(pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}
DEBUG(DL_DEBUG, "ResizeLowThrFxn thread!!!!\n");
if(pthread_create(&resizeLowThread, &attr, ResizeLowThrFxn, &LowRateResize)) {
ERR("Failed to create video thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= RESIZELOWRATETHREAD;
Rendezvous_meet(hRendezvousWriter);
/* Set the writer thread priority */
schedParam.sched_priority = WRITER_THREAD_PRIORITY;
if(pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}
/* Create the writer thread */
writerEnv.hRendezvousInit = hRendezvousInit;
writerEnv.hRendezvousCleanup = hRendezvousCleanup;
writerEnv.outBufSize = videoEnv.outBufSize;
DEBUG(DL_DEBUG, "writerThrFxn thread!!!!\n");
if(pthread_create(&writerThread, &attr, writerThrFxn, &writerEnv)) {
ERR("Failed to create writer thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= WRITERTHREADCREATED;
/* Create the writer thread */
writerLowRateEnv.hRendezvousInit = hRendezvousInit;
writerLowRateEnv.hRendezvousCleanup = hRendezvousCleanup;
writerLowRateEnv.outBufSize = videoLowRateEnv.outBufSize;
DEBUG(DL_DEBUG, "writerLowThrFxn thread!!!!\n");
if(pthread_create(&writerLowThread, &attr, writerLowThrFxn, &writerLowRateEnv)) {
ERR("Failed to create writerResize thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= WRITELOWRATETHREAD;
/* Set the thread priority */
schedParam.sched_priority = AUDIO_THREAD_PRIORITY;
if(pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}
DEBUG(DL_DEBUG, "Audio thread Function!!!!\n");
/* Create the audio thread */
audioEnv.hRendezvousInit = hRendezvousInit;
audioEnv.hRendezvousCleanup = hRendezvousCleanup;
audioEnv.engineName = engine->engineName;
audioEnv.audioEncoder = engine->audioEncoders->codecName;
if(pthread_create(&audioThread, &attr, audioThrFxn, &audioEnv)) {
ERR("Failed to create speech thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= AUDIOTHREADCREATED;
#ifdef DSS_ENC_1100_1200
if(pthread_create(&webListenThread, &attr, weblistenThrFxn, NULL)) {
ERR("Failed to create web listen thread\n");
cleanup(EXIT_FAILURE);
}
initMask |= WEBLISTENCREATED;
#endif
/* Main thread becomes the control thread */
ctrlEnv.hRendezvousInit = hRendezvousInit;
ctrlEnv.hRendezvousCleanup = hRendezvousCleanup;
ctrlEnv.engineName = engine->engineName;
ret = ctrlThrFxn(&ctrlEnv);
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
DEBUG(DL_DEBUG, "Exit All Thread!!\n");
cleanup:
/* Make sure the other threads aren't waiting for init to complete */
if(hRendezvousWriter) {
Rendezvous_force(hRendezvousWriter);
}
if(hRendezvousInit) {
Rendezvous_force(hRendezvousInit);
}
DEBUG(DL_DEBUG, "EXIT Common Mutex!!!\n");
DestorygblCommonMutex();
DEBUG(DL_DEBUG, "EXIT pthread Mutex!!!\n");
DestroyMutexPthread();
if(initMask & AUDIOTHREADCREATED) {
if(pthread_join(audioThread, &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
DEBUG(DL_DEBUG, "EXIT audio pThread!!!\n");
if(initMask & VIDEOTHREADCREATED) {
if(pthread_join(videoThread, &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
DEBUG(DL_DEBUG, "EXIT video pThread!!!\n");
if(initMask & WRITERTHREADCREATED) {
if(pthread_join(writerThread, &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
DEBUG(DL_DEBUG, "EXIT write pThread!!!\n");
if(initMask & CAPTURETHREADCREATED) {
if(pthread_join(captureThread, &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
DEBUG(DL_DEBUG, "EXIT capture pThread!!!\n");
if(initMask & VIDEOLOWRATETHREAD) {
if(pthread_join(videoLowThread, &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
if(initMask & RESIZELOWRATETHREAD) {
if(pthread_join(resizeLowThread, &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
if(initMask & WRITELOWRATETHREAD) {
if(pthread_join(writerLowThread, &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
if(pthread_join(id_listen[PORT_ONE], &ret) == 0) {
if(ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
if(captureEnv.to_video_c) {
Fifo_delete(captureEnv.to_video_c);
}
if(captureEnv.from_video_c) {
Fifo_delete(captureEnv.from_video_c);
}
if(captureEnv.to_resize_c) {
Fifo_delete(captureEnv.to_resize_c);
}
if(captureEnv.from_resize_c) {
Fifo_delete(captureEnv.from_resize_c);
}
if(writerEnv.to_video_c) {
Fifo_delete(writerEnv.to_video_c);
}
if(writerEnv.from_video_c) {
Fifo_delete(writerEnv.from_video_c);
}
if(writerLowRateEnv.from_writelow_c) {
Fifo_delete(writerLowRateEnv.from_video_c);
}
if(writerLowRateEnv.to_writelow_c) {
Fifo_delete(writerLowRateEnv.to_writelow_c);
}
if(LowRateResize.to_videoresize_c) {
Fifo_delete(LowRateResize.to_videoresize_c);
}
if(LowRateResize.from_videoresize_c) {
Fifo_delete(LowRateResize.from_videoresize_c);
}
DEBUG(DL_DEBUG, "EXIT Rendezvous cleanup pThread!!!\n");
if(hRendezvousCleanup) {
Rendezvous_delete(hRendezvousCleanup);
}
DEBUG(DL_DEBUG, "EXIT Rendezvous init pThread!!!\n");
if(hRendezvousInit) {
Rendezvous_delete(hRendezvousInit);
}
DEBUG(DL_DEBUG, "EXIT Rendezvous cleanup pThread!!!\n");
/*
if (initMask & LOGSINITIALIZED) {
TraceUtil_stop();
} */
DEBUG(DL_DEBUG, "EXIT TraceUtil_stop !!!\n");
pthread_mutex_destroy(&gbl.mutex);
DEBUG(DL_DEBUG, "process EXIT!!!\n");
exit(1);
}
//*****************************************************************************
// execute callback for microrl library
// do what you want here, but don't write to argv!!! read only!!
int execute (int argc, const char * const * argv)
{
int i = 0;
// just iterate through argv word and compare it with your commands
while (i < argc) {
if (strcmp (argv[i], _CMD_HELP) == 0) {
print ("microrl v");
print (MICRORL_LIB_VER);
print (" library STM32 v");
print (Version);
print("\n\r");
print_help (); // print help
} else if (strcmp (argv[i], _CMD_CLEAR) == 0) {
print ("\033[2J"); // ESC seq for clear entire screen
print ("\033[H"); // ESC seq for move cursor at left-top corner
} else if (strcmp (argv[i], _CMD_STATUS) == 0) {
PrintStorageStatus();
return 0;
} else if (strcmp (argv[i], _CMD_STORAGE) == 0) {
PrintConentStorage();
return 0;
} else if (strcmp (argv[i], _CMD_ERASE) == 0) {
EraseStorage();
return 0;
} else if ( strcmp(argv[i], _CMD_SET_CARRIER_FREQ) == 0 ){
if ( ++i < argc) {
size_t freq = atoi(argv[i]);
SetCarrierFrequency(freq);
} else {
print("Not enough arguments\n\r");
return -1;
}
return 0;
} else if ( strcmp(argv[i], _CMD_SET_SND_TMT) == 0 ){
if ( ++i < argc) {
TimeoutSndPackets = atof(argv[i]) / PLC_TIMER_PERIOD;
} else {
print("Not enough arguments\n\r");
return -1;
}
return 0;
} else if ( strcmp(argv[i], _CMD_SET_IR_SND_TMT) == 0 ){
if ( ++i < argc) {
TimeoutSndIrCodes = atof(argv[i]) / PLC_TIMER_PERIOD;
} else {
print("Not enough arguments\n\r");
return -1;
}
return 0;
} else if ( strcmp(argv[i], _CMD_SET_CHANNEL_VALUE) == 0 ) {
if (++i < argc) {
unsigned char channel = atoi(argv[i]);
if (channel > MaxChannelNumber) {
print("Channel number out of range\n\r");
return -1;
}
if (++i < argc) {
unsigned char value = atoi(argv[i]);
if (value > 1) {
printf("Channel value out of range\n\r");
return -1;
}
SetOutValueToChannel(channel, value);
return 0;
}
}
print("Not enough arguments\n\r");
return -1;
} else if (strcmp (argv[i], _CMD_SHOW_PARAM) == 0) {
printf("Network address: %u\n\r", (unsigned int) GetDeviceAddress());
printf("Device type: %u\n\r", (unsigned int) GetDeviceType());
printf("Ir debug mode: %u\n\r", (unsigned int)DebugModeIr);
printf("Max length delta: %u\n\r", (unsigned int)LengthDelataMax);
printf("Max interval delta: %u\n\r", (unsigned int)IntervalDelataMax);
printf("Host snd timeout (in plc resolution): %u\n\r", (unsigned int) TimeoutSndPackets);
printf("Ir snd timeout (in plc resolution): %u\n\r", (unsigned int) TimeoutSndIrCodes);
return 0;
} else {
print ("command: '");
print ((char*)argv[i]);
print ("' Not found.\n\r");
}
i++;
}
return 0;
}
/**************************************************************************
Description : Erstellen der Log Gesamt Dateien
Parameter : (none)
Return-Value : (none)
Changes : Author, Date, Version, Reason
********************************************************
Dotterweich, 22.08.2007, 0.1, Created
**************************************************************************/
void LogGesamtDatei(char *Pfad, char *OutputDatei, int Format)
{
int Zaehler = 1;
ausgabe(LOG, DEBUGMINI, "LogGesamtDatei gestartet!!!\n");
for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
{
BOOL NeueDatei = true;
char NameBuffer[50] = {0};
char TypeBuffer[50] = {0};
DWORD SNBuffer = 0;
char DatumBuffer[20] = {0};
char DateiBuffer[200] = {0};
FILE *Datei = NULL;
GetDeviceName(WRHandles[Zaehler - 1], NameBuffer, sizeof(NameBuffer)-1);
GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);
GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
GetDatum(DatumBuffer, sizeof(DatumBuffer)-1);
ausgabe(LOG, DEBUGALLES, "LogGesamtDatei für WR %3ld erstellen\n", SNBuffer);
sprintf(DateiBuffer, "%s/%s.%3ld.%s.%s", Pfad, DatumBuffer, SNBuffer, TypeBuffer, OutputDatei);
Datei = fopen(DateiBuffer, "r");
ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
if (Datei) // Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
{ // und es muss kein Dateikopf mehr erstellt werden.
ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
NeueDatei = false;
fclose(Datei);
}
Datei = fopen(DateiBuffer, "a");
if (!Datei)
{
ausgabe(LOG, DEBUGMINI, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
return;
}
else
{
int i = 0;
int KanalAnzahl = 0;
DWORD KanalHandle[KANALMAX];
TChanType KanalType = ALLCHANNELS;
char KanalName[50] = {0};
char WertText[50]={0};
char ZeitpunktBuffer[50] = {0};
ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
setbuf(Datei, 0); // Pufferung abschalten
// Ab hier Ausgaben in Datei
KanalAnzahl = GetChannelHandlesEx(WRHandles[Zaehler - 1], KanalHandle, KANALMAX, KanalType);
GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);
if(NeueDatei)
{
fprintf(Datei, "LogDatei für WR %3ld erstellt am %s von %s %s\r\n", SNBuffer, ZeitpunktBuffer, ProgrammName, ProgrammVersion);
fprintf(Datei, "WR '%s' hat %d Kanäle:\r\n", NameBuffer, KanalAnzahl);
fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
fprintf(Datei, "Zeitpunkt \t");
// Kanäle der WR
for(i = 0; i < KanalAnzahl; i++)
{
GetChannelName(KanalHandle[i], KanalName, sizeof(KanalName)-1);
fprintf(Datei, "%*s\t", KanalWertZeichenAnzahlMAX(KanalHandle[i]), KanalName);
}
// Die Errechneten Kanaele
for(i = 0; i < ErrechneteKanaeleAnzahl; i++)
{
fprintf(Datei, "%*s\t", ErrechneteKanaeleZeichen[i], ErrechneteKanaeleName[i]);
}
}
fprintf(Datei, "\r\n");
fprintf(Datei, "%s\t", ZeitpunktBuffer);
// Kanäle der WR
for(i = 0; i < KanalAnzahl; i++)
{
KanalAbfragen(KanalHandle[i], WRHandles[Zaehler - 1], WertText, sizeof(WertText)-1); // Abfragen eines Kanales
fprintf(Datei, "%s\t", WertText);
}
// Die Errechneten Kanaele
for(i = 0; i < ErrechneteKanaeleAnzahl; i++)
{
fprintf(Datei, "%s\t", ErrechneteKanaeleWert[Zaehler - 1][i]);
}
ausgabe(LOG, DEBUGALLES, "Ausgabe in Dateien ist beendet.\n");
}
fclose(Datei);
}
}
int create_signal_cli_thread(int index, int sockfd, struct sockaddr_in *cli_addr)
{
char newipconnect[20] = {0};
//打印客户端ip//
inet_ntop(AF_INET, (void *) & (cli_addr->sin_addr), newipconnect, 16);
PRINTF("sockfd =%d ip =%s\n", sockfd, newipconnect);
int nPos = 0;
int nLen = 0;
int cli_num = 0;
char send_buf[256] = {0};
char user_id[8] = {0};
char dtype[16] = {0};
unsigned int cur_time = 0;
GetDeviceType(dtype);
nPos = GetNullClientData_new(index);
cli_num = read_client_num(index);
PRINTF("GetNullClientData_new[%d] = %d\n", index, nPos);
nLen = sizeof(struct sockaddr_in);
if(-1 == nPos || cli_num >= 6) {
//需要告警上报
package_head_msg(send_buf, 30087, dtype, "0", user_id);
tcp_send_data(sockfd, send_buf);
ERR_PRN("ERROR: max client error\n");
close(sockfd);
sockfd = -1;
} else {
int nSize = 0;
int result;
client_msg_arg_t *arg = malloc(sizeof(client_msg_arg_t));
/* set client used */
PRINTF("index : [%d]pos =%d,sockfd =%d\n", index, nPos, sockfd);
SETCLIUSED_NEW(index, nPos, TRUE);
SETCLILOGIN_NEW(index, nPos, TRUE);
SETSOCK_NEW(index, nPos, sockfd);
cur_time = getCurrentTime();
SETCONNECTTIME_NEW(index, nPos, cur_time);
nSize = 1;
if((setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&nSize,
sizeof(nSize))) == -1) {
perror("setsockopt failed");
}
nSize = 0;
nLen = sizeof(nLen);
result = getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &nSize , &nLen);
if(result) {
ERR_PRN("getsockopt() errno:%d socket:%d result:%d\n", errno, sockfd, result);
}
nSize = 1;
PRINTF("Clent:%s connected,nPos:%d socket:%d!\n", newipconnect, nPos, sockfd);
//Create ClientMsg task!
arg->pos = nPos;
arg->index = index;
result = pthread_create(&cli_pthread_id[index][nPos], NULL, (void *)recv_client_msg_thread, (void *)arg);
if(result) {
close(sockfd);
sockfd = -1;
ERR_PRN("creat pthread ClientMsg error = %d!\n" , errno);
return 0;
}
sem_wait(&g_new_tcp_lock[index]);
}
}
/*LCD show infomation*/
void LCDShowInfo(int fd)
{
char strTemp[200];
switch(dwShowFlag) {
case 0: //encode Name
SendOrder(fd, FLAG_CLR, 0);
memset(strTemp, 0, sizeof(strTemp));
ReadName(strTemp);
SendData(fd, strTemp, FLAG_CENTER);
ReadVerNo(strTemp);
SendData(fd, strTemp, FLAG_CENTER | FLAG_NEWLINE);
break;
case 1:
SendOrder(fd, FLAG_CLR, 0);
memset(strTemp, 0, sizeof(strTemp));
GetDeviceType(strTemp);
SendData(fd, strTemp, FLAG_CENTER);
ReadIPMaskaddr(strTemp, 0); //IP
SendData(fd, strTemp, FLAG_CENTER | FLAG_NEWLINE);
break;
case 2:
SendOrder(fd, FLAG_CLR, 0);
memset(strTemp, 0, sizeof(strTemp));
ReadIPMaskaddr(strTemp, 1); //NW
SendData(fd, strTemp, FLAG_CENTER);
ReadIPMaskaddr(strTemp, 2); //GW
SendData(fd, strTemp, FLAG_CENTER | FLAG_NEWLINE);
break;
case 3:
SendOrder(fd, FLAG_CLR, 0);
ReadVideoinfo(strTemp, 0, 1); // width
SendData(fd, strTemp, FLAG_CENTER);
ReadVideoinfo(strTemp, 0, 2); // height
SendData(fd, strTemp, FLAG_CENTER | FLAG_NEWLINE);
break;
case 4:
SendOrder(fd, FLAG_CLR, 0);
ReadVideoinfo(strTemp, 1, 1); //VBR or CBR
SendData(fd, strTemp, FLAG_CENTER);
ReadVideoinfo(strTemp, 1, 2); //quality or bitrate
SendData(fd, strTemp, FLAG_CENTER | FLAG_NEWLINE);
break;
case 5:
SendOrder(fd, FLAG_CLR, 0);
ReadVideoinfo(strTemp, 2, 1); //Audio samplerate
SendData(fd, strTemp, FLAG_CENTER);
ReadVideoinfo(strTemp, 2, 2); //Audio bitrate
SendData(fd, strTemp, FLAG_CENTER | FLAG_NEWLINE);
break;
}
dwShowFlag++;
if(dwShowFlag > 5) { //display
dwShowFlag = 0;
}
}
