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;
}
