OGRErr OGRPCIDSKLayer::ICreateFeature( OGRFeature *poFeature ) { try { PCIDSK::ShapeId id = poVecSeg->CreateShape( (PCIDSK::ShapeId) poFeature->GetFID() ); poFeature->SetFID( (long) id ); return SetFeature( poFeature ); } /* -------------------------------------------------------------------- */ /* Trap exceptions and report as CPL errors. */ /* -------------------------------------------------------------------- */ catch( PCIDSK::PCIDSKException ex ) { CPLError( CE_Failure, CPLE_AppDefined, "%s", ex.what() ); return OGRERR_FAILURE; } catch(...) { CPLError( CE_Failure, CPLE_AppDefined, "Non-PCIDSK exception trapped." ); return OGRERR_FAILURE; } }
CacheStorageChild::CacheStorageChild(CacheStorage* aListener, Feature* aFeature) : mListener(aListener) , mNumChildActors(0) , mDelayedDestroy(false) { MOZ_COUNT_CTOR(cache::CacheStorageChild); MOZ_ASSERT(mListener); SetFeature(aFeature); }
CachePushStreamChild::CachePushStreamChild(Feature* aFeature, nsISupports* aParent, nsIAsyncInputStream* aStream) : mParent(aParent) , mStream(aStream) , mClosed(false) { MOZ_ASSERT(mParent); MOZ_ASSERT(mStream); MOZ_ASSERT_IF(!NS_IsMainThread(), aFeature); SetFeature(aFeature); }
void applyFilterbank( Filterbank *pFilterbank, Features * pFeats ) { assert(pFilterbank!=NULL); assert(pFeats!=NULL); int gabfeatsidx = 0; pFilterbank->m_pFeatures = CreateFeatures(pFeats->ncols, pFeats->nrows, pFeats->nfeats*NSCALES*NORIENTATIONS); assert(pFilterbank->m_pFeatures!=NULL); register int idx, s, k; for(idx=0; idx < pFeats->nfeats; idx++) { DImage* pImgfeats = GetFeature(pFeats, idx); Spectrum *pSpectrumImg = NULL; pSpectrumImg = DFFT2D(pImgfeats); assert(pSpectrumImg!=NULL); for( s = 0; s < NSCALES; s++ ) { for( k = 0; k < NORIENTATIONS; k++ ) { Spectrum * pSpectrumConv = MultSpectrum(pSpectrumImg, pFilterbank->m_pSpectralFilterBank[s*NORIENTATIONS+k]); DImage * pInvImg = DInvFFT2D(pSpectrumConv); DImage * pShiftedInvImg = DShift(pInvImg); SetFeature(pFilterbank->m_pFeatures, gabfeatsidx, pShiftedInvImg); gabfeatsidx++; DestroySpectrum(&(pSpectrumConv)); DestroyDImage(&(pInvImg)); DestroyDImage(&(pShiftedInvImg)); } } DestroyDImage(&(pImgfeats)); DestroySpectrum(&(pSpectrumImg)); } }
OGRErr OGRMemLayer::ICreateFeature( OGRFeature *poFeature ) { if (!bUpdatable) return OGRERR_FAILURE; if( poFeature->GetFID() != OGRNullFID && poFeature->GetFID() != iNextCreateFID ) bHasHoles = TRUE; if( poFeature->GetFID() != OGRNullFID && poFeature->GetFID() >= 0 && poFeature->GetFID() < nMaxFeatureCount ) { if( papoFeatures[poFeature->GetFID()] != NULL ) poFeature->SetFID( OGRNullFID ); } if( poFeature->GetFID() > 10000000 ) poFeature->SetFID( OGRNullFID ); return SetFeature( poFeature ); }
SurfFeature::SurfFeature(const Rect &_feature) { SetFeature(_feature); }
/********************************************************************** * IMapInfoFile::CreateFeature() * * Standard OGR CreateFeature implementation. This methode is used * to create a new feature in current dataset **********************************************************************/ OGRErr IMapInfoFile::CreateFeature(OGRFeature *poFeature) { TABFeature *poTABFeature; OGRGeometry *poGeom; OGRwkbGeometryType eGType; OGRErr eErr; /*----------------------------------------------------------------- * MITAB won't accept new features unless they are in a type derived * from TABFeature... so we have to do our best to map to the right * feature type based on the geometry type. *----------------------------------------------------------------*/ poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL ) eGType = poGeom->getGeometryType(); else eGType = wkbNone; switch (eGType) { /*------------------------------------------------------------- * POINT *------------------------------------------------------------*/ case wkbPoint: poTABFeature = new TABPoint(poFeature->GetDefnRef()); break; /*------------------------------------------------------------- * REGION *------------------------------------------------------------*/ case wkbPolygon: case wkbMultiPolygon: poTABFeature = new TABRegion(poFeature->GetDefnRef()); break; /*------------------------------------------------------------- * LINE/PLINE/MULTIPLINE *------------------------------------------------------------*/ case wkbLineString: case wkbMultiLineString: poTABFeature = new TABPolyline(poFeature->GetDefnRef()); break; /*------------------------------------------------------------- * Collection types that are not directly supported... convert * to multiple features in output file through recursive calls. *------------------------------------------------------------*/ case wkbGeometryCollection: case wkbMultiPoint: { OGRErr eStatus = OGRERR_NONE; int i; OGRGeometryCollection *poColl = (OGRGeometryCollection*)poGeom; OGRFeature *poTmpFeature = poFeature->Clone(); for (i=0; eStatus==OGRERR_NONE && i<poColl->getNumGeometries(); i++) { poTmpFeature->SetGeometry(poColl->getGeometryRef(i)); eStatus = CreateFeature(poTmpFeature); } delete poTmpFeature; return eStatus; } break; /*------------------------------------------------------------- * Unsupported type.... convert to MapInfo geometry NONE *------------------------------------------------------------*/ case wkbUnknown: default: poTABFeature = new TABFeature(poFeature->GetDefnRef()); break; } if( poGeom != NULL ) poTABFeature->SetGeometryDirectly(poGeom->clone()); for (int i=0; i< poFeature->GetDefnRef()->GetFieldCount();i++) { poTABFeature->SetField(i,poFeature->GetRawFieldRef( i )); } if (SetFeature(poTABFeature) > -1) eErr = OGRERR_NONE; else eErr = OGRERR_FAILURE; delete poTABFeature; return eErr; }
VOID EvtIoDeviceControl( _In_ WDFQUEUE Queue, _In_ WDFREQUEST Request, _In_ size_t OutputBufferLength, _In_ size_t InputBufferLength, _In_ ULONG IoControlCode ) /*++ Routine Description: This event callback function is called when the driver receives an (KMDF) IOCTL_HID_Xxx code when handlng IRP_MJ_INTERNAL_DEVICE_CONTROL (UMDF) IOCTL_HID_Xxx, IOCTL_UMDF_HID_Xxx when handling IRP_MJ_DEVICE_CONTROL Arguments: Queue - A handle to the queue object that is associated with the I/O request Request - A handle to a framework request object. OutputBufferLength - The length, in bytes, of the request's output buffer, if an output buffer is available. InputBufferLength - The length, in bytes, of the request's input buffer, if an input buffer is available. IoControlCode - The driver or system defined IOCTL associated with the request Return Value: NTSTATUS --*/ { NTSTATUS status; BOOLEAN completeRequest = TRUE; WDFDEVICE device = WdfIoQueueGetDevice(Queue); PDEVICE_CONTEXT deviceContext = NULL; PQUEUE_CONTEXT queueContext = GetQueueContext(Queue); UNREFERENCED_PARAMETER (OutputBufferLength); UNREFERENCED_PARAMETER (InputBufferLength); deviceContext = GetDeviceContext(device); switch (IoControlCode) { case IOCTL_HID_GET_DEVICE_DESCRIPTOR: // METHOD_NEITHER // // Retrieves the device's HID descriptor. // _Analysis_assume_(deviceContext->HidDescriptor.bLength != 0); status = RequestCopyFromBuffer(Request, &deviceContext->HidDescriptor, deviceContext->HidDescriptor.bLength); break; case IOCTL_HID_GET_DEVICE_ATTRIBUTES: // METHOD_NEITHER // //Retrieves a device's attributes in a HID_DEVICE_ATTRIBUTES structure. // status = RequestCopyFromBuffer(Request, &queueContext->DeviceContext->HidDeviceAttributes, sizeof(HID_DEVICE_ATTRIBUTES)); break; case IOCTL_HID_GET_REPORT_DESCRIPTOR: // METHOD_NEITHER // //Obtains the report descriptor for the HID device. // status = RequestCopyFromBuffer(Request, deviceContext->ReportDescriptor, deviceContext->HidDescriptor.DescriptorList[0].wReportLength); break; case IOCTL_HID_READ_REPORT: // METHOD_NEITHER // // Returns a report from the device into a class driver-supplied // buffer. // status = ReadReport(queueContext, Request, &completeRequest); break; case IOCTL_HID_WRITE_REPORT: // METHOD_NEITHER // // Transmits a class driver-supplied report to the device. // status = WriteReport(queueContext, Request); break; #ifdef _KERNEL_MODE case IOCTL_HID_GET_FEATURE: // METHOD_OUT_DIRECT status = GetFeature(queueContext, Request); break; case IOCTL_HID_SET_FEATURE: // METHOD_IN_DIRECT status = SetFeature(queueContext, Request); break; case IOCTL_HID_GET_INPUT_REPORT: // METHOD_OUT_DIRECT status = GetInputReport(queueContext, Request); break; case IOCTL_HID_SET_OUTPUT_REPORT: // METHOD_IN_DIRECT status = SetOutputReport(queueContext, Request); break; #else // UMDF specific // // HID minidriver IOCTL uses HID_XFER_PACKET which contains an embedded pointer. // // typedef struct _HID_XFER_PACKET { // PUCHAR reportBuffer; // ULONG reportBufferLen; // UCHAR reportId; // } HID_XFER_PACKET, *PHID_XFER_PACKET; // // UMDF cannot handle embedded pointers when marshalling buffers between processes. // Therefore a special driver mshidumdf.sys is introduced to convert such IRPs to // new IRPs (with new IOCTL name like IOCTL_UMDF_HID_Xxxx) where: // // reportBuffer - passed as one buffer inside the IRP // reportId - passed as a second buffer inside the IRP // // The new IRP is then passed to UMDF host and driver for further processing. // case IOCTL_UMDF_HID_GET_FEATURE: // METHOD_NEITHER status = GetFeature(queueContext, Request); break; case IOCTL_UMDF_HID_SET_FEATURE: // METHOD_NEITHER status = SetFeature(queueContext, Request); break; case IOCTL_UMDF_HID_GET_INPUT_REPORT: // METHOD_NEITHER status = GetInputReport(queueContext, Request); break; case IOCTL_UMDF_HID_SET_OUTPUT_REPORT: // METHOD_NEITHER status = SetOutputReport(queueContext, Request); break; #endif // _KERNEL_MODE case IOCTL_HID_GET_STRING: // METHOD_NEITHER status = GetString(Request); break; case IOCTL_HID_GET_INDEXED_STRING: // METHOD_OUT_DIRECT status = GetIndexedString(Request); break; case IOCTL_HID_SEND_IDLE_NOTIFICATION_REQUEST: // METHOD_NEITHER // // This has the USBSS Idle notification callback. If the lower driver // can handle it (e.g. USB stack can handle it) then pass it down // otherwise complete it here as not inplemented. For a virtual // device, idling is not needed. // // Not implemented. fall through... // case IOCTL_HID_ACTIVATE_DEVICE: // METHOD_NEITHER case IOCTL_HID_DEACTIVATE_DEVICE: // METHOD_NEITHER case IOCTL_GET_PHYSICAL_DESCRIPTOR: // METHOD_OUT_DIRECT // // We don't do anything for these IOCTLs but some minidrivers might. // // Not implemented. fall through... // default: status = STATUS_NOT_IMPLEMENTED; break; } // // Complete the request. Information value has already been set by request // handlers. // if (completeRequest) { WdfRequestComplete(Request, status); } }
/***************************************************************************//** * @brief Processes Standard Request (Chapter 9 Command) * @return Status of request (type @ref USB_Status_TypeDef) * @note This function takes no parameters, but it uses the setup command * stored in @ref myUsbDevice.setup. ******************************************************************************/ USB_Status_TypeDef USBDCH9_SetupCmd(void) { USB_Status_TypeDef status = USB_STATUS_OK; switch (myUsbDevice.setup.bRequest) { case GET_STATUS: status = GetStatus(); break; case CLEAR_FEATURE: status = ClearFeature(); break; case SET_FEATURE: status = SetFeature(); break; case SET_ADDRESS: status = SetAddress(); break; case GET_DESCRIPTOR: status = GetDescriptor(); break; case GET_CONFIGURATION: status = GetConfiguration(); break; case SET_CONFIGURATION: status = SetConfiguration(); break; case GET_INTERFACE: status = GetInterface(); break; case SET_INTERFACE: status = SetInterface(); break; // case GET_MS_DESCRIPTOR: // status = HandleMsRequest(); // break; default: status = USB_STATUS_REQ_ERR; break; } // Reset index to 0 in case one of the above commands modified it USB_SetIndex(0); // If the command resulted in an error, send a procedural stall if (status == USB_STATUS_REQ_ERR) { SendEp0Stall(); } return status; }
void ApplySPFilterBank(DImage* img, Filterbank* bank, int startingnfeat) { if(bank == NULL) { Error("Filterbank NULL", "ApplySPFilterBank"); } if(bank->m_pSpectralFilterBank == NULL) { Error("Filterbank->m_pSpectralFilterBank NULL", "ApplySPFilterBank"); } if(img->ncols != bank->m_pSpectralFilterBank[0]->ncols && img->nrows != bank->m_pSpectralFilterBank[0]->nrows) { Error("DImage and bank are of different sizes","ApplySPFilterBank"); } if(bank->m_pFeatures == NULL) { Error("m_pFeatures NULL","ApplySPFilterBank"); } int s, k; int scales = bank->scales; int orientations = bank->orientations; int featindex = startingnfeat; Spectrum* smoothedDImg; DImage* scaled = img; float Sx = 0.5, Sy = 0.5; for(s = 0; s < scales; s++) { /// Applying low-pass filter smoothedDImg = SmoothDImage(scaled); for(k = 0; k < orientations; k++) { /// Applying band-pass filter Spectrum* filteredSpec = ApplyFilter(smoothedDImg, bank->m_pSpectralFilterBank[s*orientations+k]); DImage* filtered = DInvFFT2D(filteredSpec); // char name[30]; // sprintf(name,"filtersp_%d_%d.pgm",s,k); // WriteImage(ViewMagnitude(FFTShift(bank->m_pSpectralFilterBank[s*orientations+k])),name); DImage* filteredscl = filtered; /** If scale is greater than 0, resample the image * to its original size **/ if(s > 0) { /// Returning image to original size filteredscl = DScale(filtered,1/(Sx+Sx),1/(Sy+Sy)); } /// Sets the rescaled image to the proper bank feature index SetFeature(bank->m_pFeatures,featindex++,filteredscl); /// Cleaning up if(filtered != filteredscl) { DestroyDImage(&filtered); } DestroyDImage(&filteredscl); DestroySpectrum(&filteredSpec); } DestroySpectrum(&smoothedDImg); if(scaled != img) DestroyDImage(&scaled); /// Downscaling image scaled = DScale(img,Sx,Sy); Sx = Sx/2; Sy = Sy/2; } if(scaled != img) DestroyDImage(&scaled); }
// This function is designed to be called once. A second call will not // reset all variables. bool Config::SetFromProperties() { char property_str[PROP_VALUE_MAX]; memset(property_str, 0, sizeof(property_str)); if (!__system_property_get("libc.debug.malloc.options", property_str)) { return false; } // Initialize a few default values. fill_alloc_value = PropertyParser::DEFAULT_FILL_ALLOC_VALUE; fill_free_value = PropertyParser::DEFAULT_FILL_FREE_VALUE; front_guard_value = PropertyParser::DEFAULT_FRONT_GUARD_VALUE; rear_guard_value = PropertyParser::DEFAULT_REAR_GUARD_VALUE; backtrace_signal = SIGRTMIN + 10; // Parse the options are of the format: // option_name or option_name=XX // Supported features: const Feature features[] = { Feature("guard", 32, 0, nullptr, nullptr, true), // Enable front guard. Value is the size of the guard. Feature("front_guard", 32, FRONT_GUARD, &this->front_guard_bytes, nullptr, true), // Enable end guard. Value is the size of the guard. Feature("rear_guard", 32, REAR_GUARD, &this->rear_guard_bytes, nullptr, true), // Enable logging the backtrace on allocation. Value is the total // number of frames to log. Feature("backtrace", 16, BACKTRACE | TRACK_ALLOCS, &this->backtrace_frames, &this->backtrace_enabled, false), // Enable gathering backtrace values on a signal. Feature("backtrace_enable_on_signal", 16, BACKTRACE | TRACK_ALLOCS, &this->backtrace_frames, &this->backtrace_enable_on_signal, false), Feature("fill", SIZE_MAX, 0, nullptr, nullptr, true), // Fill the allocation with an arbitrary pattern on allocation. // Value is the number of bytes of the allocation to fill // (default entire allocation). Feature("fill_on_alloc", SIZE_MAX, FILL_ON_ALLOC, &this->fill_on_alloc_bytes, nullptr, true), // Fill the allocation with an arbitrary pattern on free. // Value is the number of bytes of the allocation to fill // (default entire allocation). Feature("fill_on_free", SIZE_MAX, FILL_ON_FREE, &this->fill_on_free_bytes, nullptr, true), // Expand the size of every alloc by this number bytes. Value is // the total number of bytes to expand every allocation by. Feature ("expand_alloc", 16, EXPAND_ALLOC, &this->expand_alloc_bytes, nullptr, false), // Keep track of the freed allocations and verify at a later date // that they have not been used. Turning this on, also turns on // fill on free. Feature("free_track", 100, FREE_TRACK | FILL_ON_FREE, &this->free_track_allocations, nullptr, false), // Enable printing leaked allocations. Feature("leak_track", 0, LEAK_TRACK | TRACK_ALLOCS, nullptr, nullptr, false), }; // Process each property name we can find. std::string property; size_t value; bool value_set; PropertyParser parser(property_str); bool found = false; bool valid = true; while (valid && parser.Get(&property, &value, &value_set)) { for (size_t i = 0; i < sizeof(features)/sizeof(Feature); i++) { if (property == features[i].name) { if (features[i].option == 0 && features[i].combo_option) { i++; for (; i < sizeof(features)/sizeof(Feature) && features[i].combo_option; i++) { if (!SetFeature(features[i], value, value_set)) { valid = false; break; } options |= features[i].option; } if (!valid) { break; } } else { if (!SetFeature(features[i], value, value_set)) { valid = false; break; } options |= features[i].option; } found = true; break; } } if (valid && !found) { error_log("%s: unknown option %s", getprogname(), property.c_str()); valid = false; break; } } valid = valid && parser.Done(); if (valid) { // It's necessary to align the front guard to sizeof(uintptr_t) to // make sure that the header is aligned properly. if (options & FRONT_GUARD) { front_guard_bytes = BIONIC_ALIGN(front_guard_bytes, sizeof(uintptr_t)); } // This situation can occur if the free_track option is specified and // the fill_on_free option is not. In this case, indicate the whole // allocation should be filled. if ((options & FILL_ON_FREE) && fill_on_free_bytes == 0) { fill_on_free_bytes = SIZE_MAX; } } else { parser.LogUsage(); } return valid; }