bool CoreRP::addBlockDevProps()
{
if (!m_impl->info->device()) {
return true;
}
std::vector<unsigned char> contents;
m_impl->cpio->contents("default.prop", &contents);
std::vector<std::string> lines = StringUtils::splitData(contents, '\n');
for (auto it = lines.begin(); it != lines.end();) {
if (StringUtils::starts_with(*it, "ro.patcher.blockdevs.")) {
it = lines.erase(it);
} else {
++it;
}
}
Device *device = m_impl->info->device();
std::string encoded;
encoded = "ro.patcher.blockdevs.base=";
encoded += encode_list(device->blockDevBaseDirs());
lines.push_back(encoded);
encoded = "ro.patcher.blockdevs.system=";
encoded += encode_list(device->systemBlockDevs());
lines.push_back(encoded);
encoded = "ro.patcher.blockdevs.cache=";
encoded += encode_list(device->cacheBlockDevs());
lines.push_back(encoded);
encoded = "ro.patcher.blockdevs.data=";
encoded += encode_list(device->dataBlockDevs());
lines.push_back(encoded);
encoded = "ro.patcher.blockdevs.recovery=";
encoded += encode_list(device->recoveryBlockDevs());
lines.push_back(encoded);
encoded = "ro.patcher.blockdevs.extra=";
encoded += encode_list(device->extraBlockDevs());
lines.push_back(encoded);
contents = StringUtils::joinData(lines, '\n');
m_impl->cpio->setContents("default.prop", std::move(contents));
return true;
}
int closeOpenNIDevice(Device &device , VideoStream &color , VideoStream &depth , VideoStream &ir)
{
fprintf(stderr,"Stopping depth and color streams\n");
depth.stop();
color.stop();
#if MOD_IR
ir.stop();
ir.destroy();
#endif // MOD_IR
depth.destroy();
color.destroy();
device.close();
return 1;
}
/// \fn ParticleSystem::create()
/// \brief Creates and initializes the particle system components neccessary for rendering.
bool ParticleSystem::create(Device& device)
{
mpTexture = device.getContentManager().loadContent<Graphics::Texture>(UTEXT("images/particle"));
if ( mpTexture == NULL )
{
return false;
}
emittime = 0.0f;
updatetime = 0.0f;
active = 0;
maxActive = 2000;
mParticles.initialize(maxActive);
return true;
}
void Correlator::gatherCorrelationUnits(size_t tileTypeIndex,
const Design& design, const Device& device, CfgExtractor& cfgExtractor)
{
// gather correlation units from XDL
m_tileUnits.clear();
m_tileIndices.clear();
XDLExtractor xdlExtractor(design, device);
xdlExtractor.getTileTypeUnits(m_tileUnits, m_tileIndices, tileTypeIndex);
// loop over gathered units
size_t unitIndex = 0;
size_t tileIndicesIndex = 0;
const Tiles& tiles = device.tiles();
while (unitIndex < (m_tileUnits.size()))
{
// get current unit
CorrelationUnit& unit = m_tileUnits[unitIndex];
// get corresponding tile and its position
size_t tileIndex = m_tileIndices[tileIndicesIndex++];
const Tile& tile = tiles.at(tileIndex);
unsigned tileRow = tile.row();
unsigned tileColumn = tile.column();
// get configuration data size of this tile
size_t dataWordCount = cfgExtractor.getDataWordCount(tileRow, tileColumn);
// if there is no data for it, delete current unit (this happens when
// the configuration extractor does not know where to find the data and
// returns zero)
if (0 != dataWordCount) ++unitIndex;
else
{
m_tileUnits.erase(m_tileUnits.begin() + unitIndex);
continue;
}
// enlarge buffer to hold this data
if (m_buffer.size() < dataWordCount) m_buffer.resize(dataWordCount);
// copy configuration data into buffer
cfgExtractor.getDataWords(tileRow, tileColumn, &(m_buffer[0]), dataWordCount);
// set unit's configuration bits accordingly
unit.appendCfgBits(&(m_buffer[0]), dataWordCount);
}
// clear temporary data
m_buffer.clear();
m_tileIndices.clear();
}
PseudoAddressSpace::PseudoAddressSpace( Device& userclient, UserObjectHandle inKernAddrSpaceRef,
void* inBuffer, UInt32 inBufferSize, void* inBackingStore, void* inRefCon)
: IOFireWireIUnknown( reinterpret_cast<const IUnknownVTbl &>( sInterface ) ),
mNotifyIsOn(false),
mWriter( nil ),
mReader( nil ),
mSkippedPacketHandler( nil ),
mUserClient(userclient),
mKernAddrSpaceRef(inKernAddrSpaceRef),
mBuffer((char*)inBuffer),
mBufferSize(inBufferSize),
mBackingStore(inBackingStore),
mRefCon(inRefCon)
{
userclient.AddRef() ;
mPendingLocks = ::CFDictionaryCreateMutable( kCFAllocatorDefault, 0, NULL, NULL ) ;
if (!mPendingLocks)
throw kIOReturnNoMemory ;
AddressSpaceInfo info ;
IOReturn error ;
uint32_t outputCnt = 0;
size_t outputStructSize = sizeof( info ) ;
const uint64_t inputs[1]={(const uint64_t)mKernAddrSpaceRef};
error = IOConnectCallMethod(mUserClient.GetUserClientConnection(),
kPseudoAddrSpace_GetFWAddrInfo,
inputs,1,
NULL,0,
NULL,&outputCnt,
&info,&outputStructSize);
if (error)
{
throw error ;
}
#ifndef __LP64__
ROSETTA_ONLY(
{
info.address.nodeID = OSSwapInt16( info.address.nodeID );
info.address.addressHi = OSSwapInt16( info.address.addressHi );
info.address.addressLo = OSSwapInt32( info.address.addressLo );
}
);
//--------------------------------------------------------------------------------------
void ParticleShader::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
device->SetShaderParameter(m_hMatViewPorject, engine.GetCamera()->GetViewProj());
device->SetShaderParameter(m_hCameraPos, engine.GetCamera()->GetPosition());
Texture* tex = (Texture*)m_pMaterial->Attribute( Material::ATT_TEX_DIFFUSE );
if( NULL != tex )
{
device->SetShaderParameter(m_Texture, *tex );
}
device->SetShaderParameter(m_hWind, *((vector3f*)m_pMaterial->Attribute( IAttributeNode::ATT_USER_0 )));
device->SetShaderParameter(m_hAcceleration, *((float*)m_pMaterial->Attribute( IAttributeNode::ATT_USER_1 )));
device->SetShaderParameter(m_hTime, (float)(*((int*)m_pMaterial->Attribute( IAttributeNode::ATT_USER_2 ))));
}
int main()
{
std::map<time_t,int>::iterator it;
Device device = Device();
//device.print();
time_t rawtime;
time(&rawtime);
for(int i = 0; i < 15; i++) {
device.add_reading(rawtime-i, i);
}
//device.print(10);
for(int i = 1; i < 6; i++)
device.rm_reading(rawtime-i);
//device.print(10);
device.rm_reading(0);
device.rm_reading(0);
//device.print();
device.save_readings();
pugi::xml_document doc;
device.xml(doc);
//doc.print(std::cout);
doc.save_file("xml_output.xml");
device.clear_readings();
//device.print();
pugi::xml_document new_doc;
pugi::xml_parse_result result = new_doc.load_file("xml_output.xml");
if(result)
device.process_msg(new_doc);
//new_doc.print(std::cout);
}
//--------------------------------------------------------------------------------------
void PrePixelLight::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, camera->GetViewProj());
device->SetShaderParameter(m_hLightDirectionLoc, -env->GetCurrentLight().GetWorldDirection());//phong光是像素到光源的方向，所以这里反向
device->SetShaderParameter(m_hCameraPositionLoc, camera->GetPosition() );
device->SetShaderParameter(m_hAmbientLoc, env->GetAmbient());
device->SetShaderParameter(m_hLightLoc, env->GetCurrentLight().GetColor());
}
void *handler_device(void *device_pointer) {
Device *device = (Device *)device_pointer;
if (device->connect() < 0) {
fprintf(stderr, "Could not connect to %s\n", device->name);
return 0;
}
device->setFileModeTCP();
device->startRecording();
device->ping(60);
device->stopRecording();
device->updateTimeDiff();
return 0;
}
void DeviceCfgDbFiller::initDeviceDb(DeviceCfgDb& deviceDb,
const Device& device)
{
// clear device database
deviceDb.clear();
// get tile types from device
const TileTypes& tileTypes = device.tileTypes();
size_t tileTypeCount = tileTypes.size();
// create one tile type database for every tile type
TileTypeCfgDbs& tileTypeDbs = deviceDb.tileTypeDbs();
tileTypeDbs.resize(tileTypeCount);
// loop over all tile type databases and fill them
for (size_t i = 0; i < tileTypeCount; ++i)
initTileTypeDb(tileTypeDbs[i], tileTypes[i], i);
}
/**
* @details The list of available packet devices is loaded from the system and
* matched against the command-line supplied device name. Packets are
* captured and hosts extracted.
*/
int IPForensics::load_from_device() {
// load packet capture device list from system
try {
load_devices();
} catch (std::exception const &e) {
std::cout << ipf::kProgramName << ": ";
std::cout << "Could not query system for packet capture devices: ";
std::cout << e.what() << std::endl;
}
// select device to use
Device device = Device(this);
for (Device d : devices_) {
if (device_ == d.name()) {
device = d;
}
}
// exit if invalid device specified
if (!device_.empty() && device_ != device.name()) {
std::cout << ipf::kProgramName << ": ";
std::cout << "Invalid packet capture device \'" << device_ << "\'. ";
std::cout << "Valid device(s):\n";
for (size_t i = 0; i < devices_.size(); ++i) {
std::cout << i+1 << ". " << devices_[i] << '\n';
}
std::cout << std::endl;
return -1;
}
// display run-time parameters
if (verbose_) {
std::cout << "Using \'" << device.name() << "\' with network address ";
std::cout << device.net() << " and network mask " << device.mask();
std::cout << " to capture " << packet_count_ << " packet(s).";
std::cout << std::endl;
}
// capture packets
int packet_count = device.capture(packet_count_);
// display packets captured
if (verbose_) {
for (Packet p : device.packets()) {
std::cout << p << std::endl;
}
}
// extract hosts
load_hosts(device);
return packet_count;
}
int HardReset(int /*argc*/, const char* /*argv*/[])
{
printf("Resetting device...");
Status nRetVal = g_device.invoke(PS_COMMAND_POWER_RESET, NULL, 0);
printf("\n");
if (nRetVal == STATUS_OK)
{
printf("Successfully executed Hard Reset.\n\n");
printf("**********************************************\n");
printf("Warning: console must be restarted!\n");
printf("**********************************************\n\n");
}
else
{
printf("Failed to execute hard reset: %s\n\n", OpenNI::getExtendedError());
}
return nRetVal;
}
void DeviceSettings::RestoreFromDictionary(Device& device, const CFDictionaryRef dictionary, const ControlInfo* controlsToRestore, UInt32 numberControlsToRestore)
{
if (dictionary != NULL)
{
// Take and hold the device's state guard while we do this to prevent notifications from Interupting the full completion of this routine.
CAMutex::Locker deviceStateMutex(device.GetStateMutex());
CACFDictionary settings(dictionary, false);
// Restore the device settings
DeviceSettings_RestoreDeviceSettings(device, settings, kCMIODevicePropertyScopeInput, controlsToRestore, numberControlsToRestore);
DeviceSettings_RestoreDeviceSettings(device, settings, kCMIODevicePropertyScopeOutput, controlsToRestore, numberControlsToRestore);
// Restore the stream settings
DeviceSettings_RestoreStreamSettings(device, settings, kCMIODevicePropertyScopeInput, controlsToRestore, numberControlsToRestore);
DeviceSettings_RestoreStreamSettings(device, settings, kCMIODevicePropertyScopeOutput, controlsToRestore, numberControlsToRestore);
}
}
void
PartitionPage::onNewPartitionTableClicked()
{
QModelIndex index = m_core->deviceModel()->index( m_ui->deviceComboBox->currentIndex(), 0 );
Q_ASSERT( index.isValid() );
Device* device = m_core->deviceModel()->deviceForIndex( index );
QPointer<QDialog> dlg = new QDialog( this );
Ui_CreatePartitionTableDialog ui;
ui.setupUi( dlg.data() );
QString areYouSure = tr( "Are you sure you want to create a new partition table on %1?" ).arg( device->name() );
ui.areYouSureLabel->setText( areYouSure );
if ( dlg->exec() == QDialog::Accepted )
{
PartitionTable::TableType type = ui.mbrRadioButton->isChecked() ? PartitionTable::msdos : PartitionTable::gpt;
m_core->createPartitionTable( device, type );
}
delete dlg;
}
/** Inserts unallocated children for a Device's PartitionTable with the given parent.
This method inserts unallocated Partitions for a parent, usually the Device this
PartitionTable is on. It will also insert unallocated Partitions in any extended
Partitions it finds.
@warning This method assumes that no unallocated Partitions exist when it is called.
@param d the Device this PartitionTable and @p p are on
@param p the parent PartitionNode (may be this or an extended Partition)
@param start the first sector to begin looking for free space
*/
void PartitionTable::insertUnallocated(const Device& d, PartitionNode* p, qint64 start)
{
Q_ASSERT(p);
qint64 lastEnd = start;
if (d.type() == Device::LVM_Device && !p->children().isEmpty()) {
// rearranging the sectors of all partitions to keep unallocated space at the end
lastEnd = 0;
qSort(children().begin(), children().end(), [](const Partition* p1, const Partition* p2) { return p1->deviceNode() < p2->deviceNode(); });
for (const auto &child : children()) {
qint64 totalSectors = child->length();
child->setFirstSector(lastEnd);
child->setLastSector(lastEnd + totalSectors - 1);
lastEnd += totalSectors;
}
} else {
const auto pChildren = p->children();
for (const auto &child : pChildren) {
p->insert(createUnallocated(d, *p, lastEnd, child->firstSector() - 1));
if (child->roles().has(PartitionRole::Extended))
insertUnallocated(d, child, child->firstSector());
lastEnd = child->lastSector() + 1;
}
}
// Take care of the free space between the end of the last child and the end
// of the device or the extended partition.
qint64 parentEnd = lastUsable();
if (!p->isRoot()) {
Partition* extended = dynamic_cast<Partition*>(p);
parentEnd = extended ? extended->lastSector() : -1;
Q_ASSERT(extended);
}
if (parentEnd >= firstUsable() && parentEnd >= lastEnd)
p->insert(createUnallocated(d, *p, lastEnd, parentEnd));
}
bool CreateSprite()
{
auto_interface<ID3D10Device> pNativeDevice(_device.GetNativeDevice());
HRESULT hRet = D3DX10CreateSprite(pNativeDevice, 128, &_pSprite);
if (FAILED(hRet))
{
return false;
}
D3DXMATRIX m;
//D3DXVECTOR3 vEye(0.0f, 0.0f, 3.0f); // 視点(カメラの位置)
D3DXVECTOR3 vEye(0.0f, 0.0f, -3.0f); // 視点(カメラの位置)
D3DXVECTOR3 vAt(0.0f, 0.0f, 0.0f); // 注視点
D3DXVECTOR3 vUp(0.0f, 1.0f, 0.0f); // カメラの上方向
D3DXMatrixLookAtLH(&m, &vEye, &vAt, &vUp);
_pSprite->SetViewTransform(&m);
return true;
}
int Dir(int /*argc*/, const char* /*argv*/[])
{
XnFwFileEntry files[50];
XnCommandGetFileList args;
args.count = sizeof(files) / sizeof(files[0]);
args.files = files;
Status nRetVal = g_device.invoke(PS_COMMAND_GET_FILE_LIST, args);
if (nRetVal != STATUS_OK)
{
printf("Failed to get file list: %s\n\n", OpenNI::getExtendedError());
return nRetVal;
}
else
{
// print list
printf("\n");
printf("%-4s %-32s %-8s %-10s %-6s %-6s %-15s\n", "ZONE", "NAME", "VERSION", "ADDRESS", "SIZE", "CRC", "FLAGS");
printf("%-4s %-32s %-8s %-10s %-6s %-6s %-15s\n", "====", "====", "=======", "=======", "====", "===", "=====");
for (XnUInt32 i = 0; i < args.count; ++i)
{
XnFwFileEntry& file = files[i];
printf("%-4u %-32s %01u.%01u.%01u.%02u 0x%08x %6u 0x%04x ",
file.zone, file.name,
file.version.major, file.version.minor, file.version.maintenance, file.version.build,
file.address, file.size, file.crc);
// flags
if ((file.flags & XN_FILE_FLAG_BAD_CRC) != 0)
{
printf("CORRUPT");
}
printf("\n");
}
printf("\n");
}
return 0;
}
int PrintBootStatus(int /*argc*/, const char* /*argv*/[])
{
XnBootStatus bootStatus;
Status nRetVal = g_device.getProperty(LINK_PROP_BOOT_STATUS, &bootStatus);
if (nRetVal != STATUS_OK)
{
printf("Failed to get boot status: %s\n\n", OpenNI::getExtendedError());
return nRetVal;
}
else
{
enum{MAX_STR_LEN = 256};
char bootZoneStr[MAX_STR_LEN], bootZoneErr[MAX_STR_LEN];
//Helper macro to write enum names
#define CASE_ENUM_TOSTRING(enumValue, enumStr, targetStr) \
case enumValue: sprintf(targetStr, "%s", enumStr); break;
//Get XnLinkBootZone string
switch(bootStatus.zone){
CASE_ENUM_TOSTRING(XN_ZONE_FACTORY, "FACTORY_ZONE", bootZoneStr)
CASE_ENUM_TOSTRING(XN_ZONE_UPDATE, "UPDATE_ZONE", bootZoneStr)
default:
sprintf(bootZoneStr, "Unexpected - %d",bootStatus.zone);
}
//Get XnLinkBootErrorCode string
switch(bootStatus.errorCode){
CASE_ENUM_TOSTRING(XN_BOOT_OK, "BOOT_OK", bootZoneErr)
CASE_ENUM_TOSTRING(XN_BOOT_BAD_CRC, "BAD_CRC", bootZoneErr)
CASE_ENUM_TOSTRING(XN_BOOT_UPLOAD_IN_PROGRESS, "UPLOAD_IN_PROGRESS", bootZoneErr)
CASE_ENUM_TOSTRING(XN_BOOT_FW_LOAD_FAILED, "FW_LOAD_FAILED", bootZoneErr)
default:
sprintf(bootZoneErr, "Unexpected - %d",bootStatus.errorCode);
}
printf("Zone: %s\nError code: %s\n\n", bootZoneStr, bootZoneErr);
return nRetVal;
}
}
bool
DebugReplayNMEA::Next()
{
last_basic = basic;
last_calculated = calculated;
const char *line;
while ((line = reader->read()) != NULL) {
if (basic.time_available)
basic.clock = basic.time;
if (device == NULL || !device->ParseNMEA(line, basic))
parser.ParseLine(line, basic);
if (basic.location_available != last_basic.location_available) {
Compute();
return true;
}
}
return false;
}
int Emitter(int argc, const char* argv[])
{
if ((argc < 2) ||
((xnOSStrCaseCmp(argv[1], "on") != 0) && (xnOSStrCaseCmp(argv[1], "off") != 0)))
{
printf("Usage: %s <on|off>\n\n", argv[0]);
return -1;
}
const XnChar* strEmitterActive = argv[1];
XnBool bEmitterActive = (xnOSStrCaseCmp(strEmitterActive, "on") == 0);
Status nRetVal = g_device.setProperty(LINK_PROP_EMITTER_ACTIVE, bEmitterActive);
if (nRetVal == STATUS_OK)
{
printf("Emitter is now %s.\n\n", strEmitterActive);
}
else
{
printf("Failed to set emitter %s: %s\n\n", strEmitterActive, OpenNI::getExtendedError());
}
return nRetVal;
}
// write multiple characters
// virtual
std::streamsize DeviceOutBuffer::xsputn(const char* s, std::streamsize num){
//we can safely put BUFF_FLUSH into the buffer
int towrite = BUFF_CP - BUFF_FLUSH;
if(towrite > static_cast<int>(num)) towrite = static_cast<int>(num);
memcpy(bpos, s, towrite);
bpos += towrite;
if((bpos - bbeg) > BUFF_FLUSH && !flush()){
cassert(0);
return -1;
}
if(num == towrite) return num;
num -= towrite;
s += towrite;
if(num >= BUFF_FLUSH){
std::streamsize retv = pd->write(s, static_cast<uint32>(num));
cassert(retv != num);
return retv;
}
memcpy(bpos, s, static_cast<size_t>(num));
bpos += num;
return num;
}
int StopStream(int argc, const char* argv[])
{
if (argc < 2)
{
printf("Usage: %s <StreamID>\n\n", argv[0]);
return -1;
}
XnCommandStopStream args;
args.id = MyAtoi(argv[1]);
Status nRetVal = g_device.invoke(LINK_COMMAND_STOP_FW_STREAM, args);
if (nRetVal == STATUS_OK)
{
printf("Successfully stopped stream %u\n\n", args.id);
}
else
{
printf("Failed to stop stream %u: %s\n\n", args.id, OpenNI::getExtendedError());
}
return nRetVal;
}
int Download(int argc, const char* argv[])
{
if (argc < 4)
{
printf("Usage: %s <zone> <firmware file name> <host target file>\n", argv[0]);
printf("Note: filename can not contain any spaces.\n\n");
return -1;
}
XnCommandDownloadFile args;
args.zone = (uint16_t)MyAtoi(argv[1]);
args.firmwareFileName = argv[2];
args.targetPath = argv[3];
Status nRetVal = g_device.invoke(PS_COMMAND_DOWNLOAD_FILE, args);
if (nRetVal != STATUS_OK)
{
printf("Failed to download file '%s' from zone %u: %s\n\n", args.firmwareFileName, args.zone, OpenNI::getExtendedError());
}
return nRetVal;
}
int FormatZone(int argc, const char* argv[])
{
if (argc < 2)
{
printf("Usage: %s <Zone>\n", argv[0]);
printf("Note - each parameter may be in hex, indicated by an '0x' prefix.\n\n");
return -1;
}
XnUInt32 nZone = MyAtoi(argv[1]);
Status nRetVal = g_device.invoke(PS_COMMAND_FORMAT_ZONE, nZone);
if (nRetVal == STATUS_OK)
{
printf("Successfully formatZone.\n\n");
}
else
{
printf("Failed to format Zone value: %s\n\n", OpenNI::getExtendedError());
}
return nRetVal;
}
//--------------------------------------------------------------------------------------
void ModelDepth::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
ICamera* camera = engine.GetCamera();
Matrix44f& mat = *(Matrix44f*)(m_pMaterial->Attribute( IAttributeNode::ATT_WORLDTRANSFORM ));
device->SetShaderParameter(m_hWorldTransform, mat );
if ( m_pMaterial->Attribute( IAttributeNode::ATT_USER_0 ) )
{
device->SetShaderParameter(m_hCameraLineDepthParam, camera->LineDepthParamBais() );
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, mat * camera->GetViewProjBias() );
}
else
{
device->SetShaderParameter(m_hCameraLineDepthParam, camera->LineDepthParam() );
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, mat * camera->GetViewProj() );
}
device->SetShaderParameter(m_hLightPositionLoc, engine.GetEnvironment()->GetCurrentLight().GetWorldPosition() );
}
static void
TestFlyNet()
{
NullPort null;
Device *device = flynet_driver.CreateOnPort(dummy_config, null);
ok1(device != NULL);
NMEAInfo nmea_info;
nmea_info.Reset();
nmea_info.clock = fixed(1);
ok1(device->ParseNMEA("_PRS 00017CBA", nmea_info));
ok1(nmea_info.static_pressure_available);
ok1(equals(nmea_info.static_pressure.GetPascal(), 97466));
nmea_info.Reset();
nmea_info.clock = fixed(1);
ok1(device->ParseNMEA("_PRS 00018BCD", nmea_info));
ok1(nmea_info.static_pressure_available);
ok1(equals(nmea_info.static_pressure.GetPascal(), 101325));
nmea_info.Reset();
nmea_info.clock = fixed(1);
ok1(device->ParseNMEA("_BAT 0", nmea_info));
ok1(nmea_info.battery_level_available);
ok1(equals(nmea_info.battery_level, 0));
nmea_info.Reset();
nmea_info.clock = fixed(1);
ok1(device->ParseNMEA("_BAT 7", nmea_info));
ok1(nmea_info.battery_level_available);
ok1(equals(nmea_info.battery_level, 70));
nmea_info.Reset();
nmea_info.clock = fixed(1);
ok1(device->ParseNMEA("_BAT A", nmea_info));
ok1(nmea_info.battery_level_available);
ok1(equals(nmea_info.battery_level, 100));
delete device;
}
bool Stream::setup(Device &device, SensorType sensorType)
{
if (!device.isOpen()) {
return false;
}
m_Kinect2Timestamp = 0;
m_OpenGLTimestamp = 0;
m_Frame.sensorType = sensorType;
m_Frame.mode.fps = 0;
m_Frame.frameIndex = 0;
m_Frame.stride = 0;
m_Frame.data = nullptr;
m_Frame.dataSize = 0;
m_IsFrameNew = false;
m_IsTextureNeedUpdate = false;
device.m_Streams.push_back(this);
this->m_Device = &device;
setMirror(false);
return true;
}
int DestroyStream(int argc, const char* argv[])
{
if (argc < 2)
{
printf("Usage: %s <streamID>\n", argv[0]);
printf("Destroys a stream, where stream ID is an ID returned from the Create command.\n");
return -1;
}
XnCommandDestroyStream args;
args.id = MyAtoi(argv[1]);
Status nRetVal = g_device.invoke(LINK_COMMAND_DESTROY_FW_STREAM, args);
if (nRetVal == STATUS_OK)
{
printf("Successfully destroyed stream %u\n\n", args.id);
}
else
{
printf("Failed to destroy stream: %s\n\n", OpenNI::getExtendedError());
}
return nRetVal;
}
// ウィンドウリサイズ。
LRESULT OnWindowSizeMessage(HWND /*hWnd*/, UINT /*msg*/, WPARAM wParam, LPARAM lParam)
{
WindowSizeMessageParameters params(wParam, lParam);
SIZE sz;
sz.cx = params.GetClientWidth();
sz.cy = params.GetClientHeight();
if (params.GetType() == SIZE_MINIMIZED)
{
return 0;
}
// なんか↓の処理しなくても上手くできてるように見えるんですけど…。
if (failed(_device.ResizeBackBuffer(sz)))
{
Exit(0);
return 0;
}
// 射影トランスフォームをリセット。
ResetProjectionTransform(sz);
return 0;
}
xnl::Array<XnFwLogMask>& GetLogMaskList()
{
static xnl::Array<XnFwLogMask> s_masks;
if (s_masks.GetSize() == 0)
{
XnFwLogMask masks[20];
XnCommandGetLogMaskList args;
args.masks = masks;
args.count = sizeof(masks)/sizeof(masks[0]);
if (STATUS_OK != g_device.invoke(PS_COMMAND_GET_LOG_MASK_LIST, args))
{
printf("Failed getting masks list: %s\n\n", OpenNI::getExtendedError());
}
else
{
s_masks.SetData(args.masks, args.count);
}
}
return s_masks;
}