void OpenCVExample::MainPage::UpdateImage(const cv::Mat& image) { // Create the WriteableBitmap WriteableBitmap^ bitmap = ref new WriteableBitmap(image.cols, image.rows); // Get access to the pixels IBuffer^ buffer = bitmap->PixelBuffer; unsigned char* dstPixels = nullptr; // Obtain IBufferByteAccess ComPtr<IBufferByteAccess> pBufferByteAccess; ComPtr<IInspectable> pBuffer((IInspectable*)buffer); pBuffer.As(&pBufferByteAccess); // Get pointer to pixel bytes HRESULT get_bytes = pBufferByteAccess->Buffer(&dstPixels); if (get_bytes == S_OK) { memcpy(dstPixels, image.data, image.step.buf[1] * image.cols*image.rows); // Set the bitmap to the Image element storedImage->Source = bitmap; } else { printf("Error loading image into buffer\n"); } }
ComPtr<IBuffer> createIBufferFromData(const char *data, qint32 size) { static ComPtr<IBufferFactory> bufferFactory; HRESULT hr; if (!bufferFactory) { hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Storage_Streams_Buffer).Get(), IID_PPV_ARGS(&bufferFactory)); Q_ASSERT_SUCCEEDED(hr); } ComPtr<IBuffer> buffer; const UINT32 length = size; hr = bufferFactory->Create(length, &buffer); Q_ASSERT_SUCCEEDED(hr); hr = buffer->put_Length(length); Q_ASSERT_SUCCEEDED(hr); ComPtr<Windows::Storage::Streams::IBufferByteAccess> byteArrayAccess; hr = buffer.As(&byteArrayAccess); Q_ASSERT_SUCCEEDED(hr); byte *bytes; hr = byteArrayAccess->Buffer(&bytes); Q_ASSERT_SUCCEEDED(hr); memcpy(bytes, data, length); return buffer; }
static QByteArray doCrypt(QSslKeyPrivate::Cipher cipher, QByteArray data, const QByteArray &key, const QByteArray &iv, bool encrypt) { HRESULT hr; ISymmetricKeyAlgorithmProvider *keyProvider = g->keyProviders[cipher].Get(); Q_ASSERT(keyProvider); ComPtr<IBuffer> keyBuffer; hr = g->bufferFactory->CreateFromByteArray(key.length(), (BYTE *)key.data(), &keyBuffer); Q_ASSERT_SUCCEEDED(hr); ComPtr<ICryptographicKey> cryptographicKey; hr = keyProvider->CreateSymmetricKey(keyBuffer.Get(), &cryptographicKey); Q_ASSERT_SUCCEEDED(hr); UINT32 blockLength; hr = keyProvider->get_BlockLength(&blockLength); Q_ASSERT_SUCCEEDED(hr); if (encrypt) { // Add padding const char padding = blockLength - data.length() % blockLength; data += QByteArray(padding, padding); } ComPtr<IBuffer> dataBuffer; hr = g->bufferFactory->CreateFromByteArray(data.length(), (BYTE *)data.data(), &dataBuffer); Q_ASSERT_SUCCEEDED(hr); ComPtr<IBuffer> ivBuffer; hr = g->bufferFactory->CreateFromByteArray(iv.length(), (BYTE *)iv.data(), &ivBuffer); Q_ASSERT_SUCCEEDED(hr); ComPtr<IBuffer> resultBuffer; hr = encrypt ? g->engine->Encrypt(cryptographicKey.Get(), dataBuffer.Get(), ivBuffer.Get(), &resultBuffer) : g->engine->Decrypt(cryptographicKey.Get(), dataBuffer.Get(), ivBuffer.Get(), &resultBuffer); Q_ASSERT_SUCCEEDED(hr); UINT32 resultLength; hr = resultBuffer->get_Length(&resultLength); Q_ASSERT_SUCCEEDED(hr); ComPtr<Windows::Storage::Streams::IBufferByteAccess> bufferAccess; hr = resultBuffer.As(&bufferAccess); Q_ASSERT_SUCCEEDED(hr); byte *resultData; hr = bufferAccess->Buffer(&resultData); Q_ASSERT_SUCCEEDED(hr); if (!encrypt) { // Remove padding const uchar padding = resultData[resultLength - 1]; if (padding > 0 && padding <= blockLength) resultLength -= padding; else qCWarning(lcSsl, "Invalid padding length of %u; decryption likely failed.", padding); } return QByteArray(reinterpret_cast<const char *>(resultData), resultLength); }
static qint64 writeIOStream(ComPtr<IOutputStream> stream, const char *data, qint64 len) { ComPtr<IBuffer> buffer; HRESULT hr = g->bufferFactory->Create(len, &buffer); Q_ASSERT_SUCCEEDED(hr); hr = buffer->put_Length(len); Q_ASSERT_SUCCEEDED(hr); ComPtr<Windows::Storage::Streams::IBufferByteAccess> byteArrayAccess; hr = buffer.As(&byteArrayAccess); Q_ASSERT_SUCCEEDED(hr); byte *bytes; hr = byteArrayAccess->Buffer(&bytes); Q_ASSERT_SUCCEEDED(hr); memcpy(bytes, data, len); ComPtr<IAsyncOperationWithProgress<UINT32, UINT32>> op; hr = stream->WriteAsync(buffer.Get(), &op); RETURN_IF_FAILED("Failed to write to stream", return -1); UINT32 bytesWritten; hr = QWinRTFunctions::await(op, &bytesWritten); RETURN_IF_FAILED("Failed to write to stream", return -1); return bytesWritten; }
void ed25519_create_seed(unsigned char *seed) { #if TORRENT_USE_CRYPTOGRAPHIC_BUFFER IBuffer^ seedBuffer = CryptographicBuffer::GenerateRandom(32); ComPtr<IBufferByteAccess> bufferByteAccess; reinterpret_cast<IInspectable*>(seedBuffer)->QueryInterface(IID_PPV_ARGS(&bufferByteAccess)); bufferByteAccess->Buffer(&seed); #elif defined _WIN32 HCRYPTPROV prov; if (!CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { throw boost::system::system_error(boost::system::error_code(GetLastError() , boost::system::system_category())); } if (!CryptGenRandom(prov, 32, seed)) { CryptReleaseContext(prov, 0); throw boost::system::system_error(boost::system::error_code(GetLastError() , boost::system::system_category())); } CryptReleaseContext(prov, 0); #else FILE *f = fopen("/dev/urandom", "rb"); if (f == NULL) { throw boost::system::system_error(boost::system::error_code(errno, boost::system::generic_category())); } int read = fread(seed, 1, 32, f); if (read != 32) { fclose(f); throw boost::system::system_error(boost::system::error_code(errno, boost::system::generic_category())); } fclose(f); #endif }
#include <wrl.h> using namespace Microsoft::WRL; using namespace Platform; using namespace Windows::Storage::Streams; inline void ThrowIfFailed(HRESULT hr) { if (FAILED(hr)) { throw Exception::CreateException(hr); } } // Retrieves the raw pixel data from the provided IBuffer object. byte* GetPointerToPixelData(IBuffer^ buffer) { // Cast to Object^, then to its underlying IInspectable interface. Object^ obj = buffer; ComPtr<IInspectable> insp(reinterpret_cast<IInspectable*>(obj)); // Query the IBufferByteAccess interface. ComPtr<IBufferByteAccess> bufferByteAccess; ThrowIfFailed(insp.As(&bufferByteAccess)); // Retrieve the buffer data. byte* pixels = nullptr; ThrowIfFailed(bufferByteAccess->Buffer(&pixels)); return pixels; }
HRESULT QNativeSocketEnginePrivate::handleReadyRead(IAsyncBufferOperation *asyncInfo, AsyncStatus status) { Q_Q(QNativeSocketEngine); if (wasDeleted || isDeletingChildren) return S_OK; if (status == Error || status == Canceled) return S_OK; ComPtr<IBuffer> buffer; HRESULT hr = asyncInfo->GetResults(&buffer); RETURN_OK_IF_FAILED("Failed to get read results buffer"); UINT32 bufferLength; hr = buffer->get_Length(&bufferLength); Q_ASSERT_SUCCEEDED(hr); if (!bufferLength) { if (q->isReadNotificationEnabled()) emit q->readReady(); return S_OK; } ComPtr<Windows::Storage::Streams::IBufferByteAccess> byteArrayAccess; hr = buffer.As(&byteArrayAccess); Q_ASSERT_SUCCEEDED(hr); byte *data; hr = byteArrayAccess->Buffer(&data); Q_ASSERT_SUCCEEDED(hr); readMutex.lock(); if (readBytes.atEnd()) // Everything has been read; the buffer is safe to reset readBytes.close(); if (!readBytes.isOpen()) readBytes.open(QBuffer::ReadWrite|QBuffer::Truncate); qint64 readPos = readBytes.pos(); readBytes.seek(readBytes.size()); Q_ASSERT(readBytes.atEnd()); readBytes.write(reinterpret_cast<const char*>(data), qint64(bufferLength)); readBytes.seek(readPos); readMutex.unlock(); if (q->isReadNotificationEnabled()) emit q->readReady(); ComPtr<IInputStream> stream; hr = tcpSocket()->get_InputStream(&stream); Q_ASSERT_SUCCEEDED(hr); // Reuse the stream buffer hr = buffer->get_Capacity(&bufferLength); Q_ASSERT_SUCCEEDED(hr); hr = buffer->put_Length(0); Q_ASSERT_SUCCEEDED(hr); ComPtr<IAsyncBufferOperation> op; hr = stream->ReadAsync(buffer.Get(), bufferLength, InputStreamOptions_Partial, &op); if (FAILED(hr)) { qErrnoWarning(hr, "Could not read into socket stream buffer."); return S_OK; } hr = op->put_Completed(Callback<SocketReadCompletedHandler>(this, &QNativeSocketEnginePrivate::handleReadyRead).Get()); if (FAILED(hr)) { qErrnoWarning(hr, "Failed to set socket read callback."); return S_OK; } return S_OK; }