| // Copyright 2017 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "services/shape_detection/detection_utils_win.h" |
| |
| #include <windows.foundation.collections.h> |
| #include <windows.media.faceanalysis.h> |
| #include <windows.media.ocr.h> |
| #include <wrl/implements.h> |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/logging.h" |
| #include "base/numerics/checked_math.h" |
| #include "base/sequenced_task_runner.h" |
| #include "base/threading/sequenced_task_runner_handle.h" |
| #include "base/win/winrt_storage_util.h" |
| #include "third_party/skia/include/core/SkBitmap.h" |
| |
| namespace shape_detection { |
| |
| using ABI::Windows::Foundation::Collections::IVector; |
| using ABI::Windows::Foundation::IAsyncOperationCompletedHandler; |
| using ABI::Windows::Media::FaceAnalysis::DetectedFace; |
| using ABI::Windows::Media::Ocr::OcrResult; |
| using ABI::Windows::Media::FaceAnalysis::FaceDetector; |
| |
| template <typename RuntimeType> |
| HRESULT AsyncOperation<RuntimeType>::BeginAsyncOperation( |
| typename AsyncOperation<RuntimeType>::Callback callback, |
| typename AsyncOperation<RuntimeType>::IAsyncOperationPtr async_op_ptr) { |
| auto instance = |
| new AsyncOperation<RuntimeType>(std::move(callback), async_op_ptr); |
| |
| scoped_refptr<base::SequencedTaskRunner> task_runner = |
| base::SequencedTaskRunnerHandle::Get(); |
| |
| typedef WRL::Implements<WRL::RuntimeClassFlags<WRL::ClassicCom>, |
| IAsyncOperationCompletedHandler<RuntimeType*>, |
| WRL::FtmBase> |
| AsyncCallback; |
| auto async_callback = WRL::Callback<AsyncCallback>( |
| [instance, task_runner](IAsyncOperation<RuntimeType*>* async_op, |
| AsyncStatus status) { |
| // A reference to |async_op| is kept in |async_op_ptr_|, safe to pass |
| // outside. This is happening on an OS thread. |
| task_runner->PostTask( |
| FROM_HERE, base::BindOnce(&AsyncOperation::AsyncCallbackInternal, |
| base::Owned(instance), |
| base::Unretained(async_op), status)); |
| |
| return S_OK; |
| }); |
| |
| return async_op_ptr->put_Completed(async_callback.Get()); |
| } |
| |
| template HRESULT AsyncOperation<IVector<DetectedFace*>>::BeginAsyncOperation( |
| AsyncOperation<IVector<DetectedFace*>>::Callback callback, |
| AsyncOperation<IVector<DetectedFace*>>::IAsyncOperationPtr async_op_ptr); |
| |
| template HRESULT AsyncOperation<FaceDetector>::BeginAsyncOperation( |
| AsyncOperation<FaceDetector>::Callback callback, |
| AsyncOperation<FaceDetector>::IAsyncOperationPtr async_op_ptr); |
| |
| template HRESULT AsyncOperation<OcrResult>::BeginAsyncOperation( |
| AsyncOperation<OcrResult>::Callback callback, |
| AsyncOperation<OcrResult>::IAsyncOperationPtr async_op_ptr); |
| |
| template <typename RuntimeType> |
| void AsyncOperation<RuntimeType>::AsyncCallbackInternal( |
| IAsyncOperation<RuntimeType*>* async_op, |
| AsyncStatus status) { |
| DCHECK_EQ(async_op, async_op_ptr_.Get()); |
| |
| std::move(callback_).Run((async_op && status == AsyncStatus::Completed) |
| ? std::move(async_op_ptr_) |
| : nullptr); |
| } |
| |
| WRL::ComPtr<ISoftwareBitmap> CreateWinBitmapFromSkBitmap( |
| const SkBitmap& bitmap, |
| ISoftwareBitmapStatics* bitmap_factory) { |
| DCHECK(bitmap_factory); |
| DCHECK_EQ(bitmap.colorType(), kN32_SkColorType); |
| if (!base::CheckedNumeric<uint32_t>(bitmap.computeByteSize()).IsValid()) { |
| DLOG(ERROR) << "Data overflow."; |
| return nullptr; |
| } |
| |
| // Create IBuffer from bitmap data. |
| WRL::ComPtr<ABI::Windows::Storage::Streams::IBuffer> buffer; |
| HRESULT hr = base::win::CreateIBufferFromData( |
| static_cast<uint8_t*>(bitmap.getPixels()), |
| static_cast<UINT32>(bitmap.computeByteSize()), &buffer); |
| if (FAILED(hr)) { |
| DLOG(ERROR) << "Create IBuffer from bitmap data failed: " |
| << logging::SystemErrorCodeToString(hr); |
| return nullptr; |
| } |
| |
| WRL::ComPtr<ISoftwareBitmap> win_bitmap; |
| const BitmapPixelFormat pixelFormat = |
| (kN32_SkColorType == kRGBA_8888_SkColorType) |
| ? ABI::Windows::Graphics::Imaging::BitmapPixelFormat_Rgba8 |
| : ABI::Windows::Graphics::Imaging::BitmapPixelFormat_Bgra8; |
| // Create ISoftwareBitmap from SKBitmap that is kN32_SkColorType and copy the |
| // IBuffer into it. |
| hr = bitmap_factory->CreateCopyFromBuffer(buffer.Get(), pixelFormat, |
| bitmap.width(), bitmap.height(), |
| win_bitmap.GetAddressOf()); |
| if (FAILED(hr)) { |
| DLOG(ERROR) << "Create ISoftwareBitmap from buffer failed: " |
| << logging::SystemErrorCodeToString(hr); |
| return nullptr; |
| } |
| |
| return win_bitmap; |
| } |
| |
| WRL::ComPtr<ISoftwareBitmap> CreateWinBitmapWithPixelFormat( |
| const SkBitmap& bitmap, |
| ISoftwareBitmapStatics* bitmap_factory, |
| BitmapPixelFormat pixel_format) { |
| WRL::ComPtr<ISoftwareBitmap> win_bitmap = |
| CreateWinBitmapFromSkBitmap(bitmap, bitmap_factory); |
| |
| // Convert Rgba8/Bgra8 to Gray8/Nv12 SoftwareBitmap. |
| const HRESULT hr = bitmap_factory->Convert(win_bitmap.Get(), pixel_format, |
| win_bitmap.GetAddressOf()); |
| if (FAILED(hr)) { |
| DLOG(ERROR) << "Convert Rgba8/Bgra8 to Gray8/Nv12 failed: " |
| << logging::SystemErrorCodeToString(hr); |
| return nullptr; |
| } |
| |
| return win_bitmap; |
| } |
| |
| } // namespace shape_detection |