diff options
Diffstat (limited to 'python/openvino/runtime/common/format_reader')
13 files changed, 792 insertions, 0 deletions
diff --git a/python/openvino/runtime/common/format_reader/CMakeLists.txt b/python/openvino/runtime/common/format_reader/CMakeLists.txt new file mode 100644 index 0000000..3daab96 --- /dev/null +++ b/python/openvino/runtime/common/format_reader/CMakeLists.txt @@ -0,0 +1,55 @@ +# Copyright (C) 2018-2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +set (TARGET_NAME "format_reader") + +file (GLOB MAIN_SRC ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) +file (GLOB LIBRARY_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/*.h) + +# Create named folders for the sources within the .vcproj +# Empty name lists them directly under the .vcproj +source_group("src" FILES ${LIBRARY_SRC}) +source_group("include" FILES ${LIBRARY_HEADERS}) + +# Create library file from sources. +add_library(${TARGET_NAME} SHARED ${MAIN_SRC} ${LIBRARY_HEADERS}) + +# Find OpenCV components if exist +find_package(OpenCV QUIET COMPONENTS core imgproc imgcodecs) +if(NOT OpenCV_FOUND) + message(WARNING "OpenCV is disabled or not found, ${TARGET_NAME} will be built without OpenCV support") +else() + target_link_libraries(${TARGET_NAME} PRIVATE ${OpenCV_LIBRARIES} ie_samples_utils) + if(UNIX AND NOT APPLE) + # Workaround issue that rpath-link is missing for PRIVATE dependencies + # Fixed in cmake 3.16.0 https://gitlab.kitware.com/cmake/cmake/issues/19556 + target_link_libraries(${TARGET_NAME} INTERFACE "-Wl,-rpath-link,${OpenCV_INSTALL_PATH}/lib") + endif() + # Make this definition public so that it's also seen by dla benchmark. As dla benchmark + # uses this macro to identify which image extensions are supported by the image reader + target_compile_definitions(${TARGET_NAME} PUBLIC USE_OPENCV) +endif() + +target_compile_definitions(${TARGET_NAME} PRIVATE IMPLEMENT_FORMAT_READER) + +target_include_directories(${TARGET_NAME} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_SOURCE_DIR}/..") + +set_target_properties(${TARGET_NAME} PROPERTIES COMPILE_PDB_NAME ${TARGET_NAME} + FOLDER cpp_samples) + +if(COMMAND add_clang_format_target) + add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME}) +endif() + +install( + TARGETS ${TARGET_NAME} + RUNTIME DESTINATION samples_bin/ COMPONENT samples_bin EXCLUDE_FROM_ALL + LIBRARY DESTINATION samples_bin/ COMPONENT samples_bin EXCLUDE_FROM_ALL +) + +install(TARGETS ${TARGET_NAME} + RUNTIME DESTINATION "dla/bin" COMPONENT EMUTEST + LIBRARY DESTINATION "dla/lib" COMPONENT EMUTEST + ARCHIVE DESTINATION "dla/lib" COMPONENT EMUTEST) diff --git a/python/openvino/runtime/common/format_reader/MnistUbyte.cpp b/python/openvino/runtime/common/format_reader/MnistUbyte.cpp new file mode 100644 index 0000000..182ef99 --- /dev/null +++ b/python/openvino/runtime/common/format_reader/MnistUbyte.cpp @@ -0,0 +1,66 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +// clang-format off +#include <fstream> +#include <iostream> +#include <string> + +#include "MnistUbyte.h" +// clang-format on + +using namespace FormatReader; + +int MnistUbyte::reverseInt(int i) { + unsigned char ch1, ch2, ch3, ch4; + ch1 = (unsigned char)(i & 255); + ch2 = (unsigned char)((i >> 8) & 255); + ch3 = (unsigned char)((i >> 16) & 255); + ch4 = (unsigned char)((i >> 24) & 255); + return (static_cast<int>(ch1) << 24) + (static_cast<int>(ch2) << 16) + (static_cast<int>(ch3) << 8) + ch4; +} + +MnistUbyte::MnistUbyte(const std::string& filename) { + std::ifstream file(filename, std::ios::binary); + if (!file.is_open()) { + return; + } + int magic_number = 0; + int number_of_images = 0; + int n_rows = 0; + int n_cols = 0; + file.read(reinterpret_cast<char*>(&magic_number), sizeof(magic_number)); + magic_number = reverseInt(magic_number); + if (magic_number != 2051) { + return; + } + file.read(reinterpret_cast<char*>(&number_of_images), sizeof(number_of_images)); + number_of_images = reverseInt(number_of_images); + file.read(reinterpret_cast<char*>(&n_rows), sizeof(n_rows)); + n_rows = reverseInt(n_rows); + _height = (size_t)n_rows; + file.read(reinterpret_cast<char*>(&n_cols), sizeof(n_cols)); + n_cols = reverseInt(n_cols); + _width = (size_t)n_cols; + if (number_of_images > 1) { + std::cout << "[MNIST] Warning: number_of_images in mnist file equals " << number_of_images + << ". Only a first image will be read." << std::endl; + } + + size_t size = _width * _height * 1; + + _data.reset(new unsigned char[size], std::default_delete<unsigned char[]>()); + size_t count = 0; + if (0 < number_of_images) { + for (int r = 0; r < n_rows; ++r) { + for (int c = 0; c < n_cols; ++c) { + unsigned char temp = 0; + file.read(reinterpret_cast<char*>(&temp), sizeof(temp)); + _data.get()[count++] = temp; + } + } + } + + file.close(); +} diff --git a/python/openvino/runtime/common/format_reader/MnistUbyte.h b/python/openvino/runtime/common/format_reader/MnistUbyte.h new file mode 100644 index 0000000..8991166 --- /dev/null +++ b/python/openvino/runtime/common/format_reader/MnistUbyte.h @@ -0,0 +1,58 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * \brief Mnist reader + * \file MnistUbyte.h + */ +#pragma once + +#include <memory> +#include <string> + +// clang-format off +#include "format_reader.h" +#include "register.h" +// clang-format on + +namespace FormatReader { +/** + * \class MnistUbyte + * \brief Reader for mnist db files + */ +class MnistUbyte : public Reader { +private: + int reverseInt(int i); + + static Register<MnistUbyte> reg; + +public: + /** + * \brief Constructor of Mnist reader + * @param filename - path to input data + * @return MnistUbyte reader object + */ + explicit MnistUbyte(const std::string& filename); + virtual ~MnistUbyte() {} + + /** + * \brief Get size + * @return size + */ + size_t size() const override { + return _width * _height * 1; + } + + // langsu: ResizeType is a added by us to support custom resizing functions (only in opencv_wrapper). + // format_reader is copied from openvino samples/cpp/common/format_reader/ + // this might need special care when doing a OV uplift + std::shared_ptr<unsigned char> getData(size_t width, size_t height, ResizeType resize_type) override { + if ((width * height != 0) && (_width * _height != width * height)) { + std::cout << "[ WARNING ] Image won't be resized! Please use OpenCV.\n"; + return nullptr; + } + return _data; + } +}; +} // namespace FormatReader diff --git a/python/openvino/runtime/common/format_reader/bmp.cpp b/python/openvino/runtime/common/format_reader/bmp.cpp new file mode 100644 index 0000000..240d13f --- /dev/null +++ b/python/openvino/runtime/common/format_reader/bmp.cpp @@ -0,0 +1,64 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +// clang-format off +#include <fstream> +#include <iostream> + +#include "bmp.h" +// clang-format on + +using namespace std; +using namespace FormatReader; + +BitMap::BitMap(const string& filename) { + BmpHeader header; + BmpInfoHeader infoHeader; + + ifstream input(filename, ios::binary); + if (!input) { + return; + } + + input.read(reinterpret_cast<char*>(&header.type), 2); + + if (header.type != 'M' * 256 + 'B') { + std::cerr << "[BMP] file is not bmp type\n"; + return; + } + + input.read(reinterpret_cast<char*>(&header.size), 4); + input.read(reinterpret_cast<char*>(&header.reserved), 4); + input.read(reinterpret_cast<char*>(&header.offset), 4); + + input.read(reinterpret_cast<char*>(&infoHeader), sizeof(BmpInfoHeader)); + + bool rowsReversed = infoHeader.height < 0; + _width = infoHeader.width; + _height = abs(infoHeader.height); + + if (infoHeader.bits != 24) { + cerr << "[BMP] 24bpp only supported. But input has:" << infoHeader.bits << "\n"; + return; + } + + if (infoHeader.compression != 0) { + cerr << "[BMP] compression not supported\n"; + } + + int padSize = _width & 3; + char pad[3]; + size_t size = _width * _height * 3; + + _data.reset(new unsigned char[size], std::default_delete<unsigned char[]>()); + + input.seekg(header.offset, ios::beg); + + // reading by rows in invert vertically + for (uint32_t i = 0; i < _height; i++) { + uint32_t storeAt = rowsReversed ? i : (uint32_t)_height - 1 - i; + input.read(reinterpret_cast<char*>(_data.get()) + _width * 3 * storeAt, _width * 3); + input.read(pad, padSize); + } +} diff --git a/python/openvino/runtime/common/format_reader/bmp.h b/python/openvino/runtime/common/format_reader/bmp.h new file mode 100644 index 0000000..ac3ff31 --- /dev/null +++ b/python/openvino/runtime/common/format_reader/bmp.h @@ -0,0 +1,75 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * \brief BMP reader + * \file bmp.h + */ +#pragma once + +#include <memory> +#include <string> + +// clang-format off +#include "format_reader.h" +#include "register.h" +// clang-format on + +namespace FormatReader { +/** + * \class BitMap + * \brief Reader for bmp files + */ +class BitMap : public Reader { +private: + static Register<BitMap> reg; + + typedef struct BmpHeaderType { + unsigned short type = 0u; /* Magic identifier */ + unsigned int size = 0u; /* File size in bytes */ + unsigned int reserved = 0u; + unsigned int offset = 0u; /* Offset to image data, bytes */ + } BmpHeader; + + typedef struct BmpInfoHeaderType { + unsigned int size = 0u; /* Header size in bytes */ + int width = 0, height = 0; /* Width and height of image */ + unsigned short planes = 0u; /* Number of colour planes */ + unsigned short bits = 0u; /* Bits per pixel */ + unsigned int compression = 0u; /* Compression type */ + unsigned int imagesize = 0u; /* Image size in bytes */ + int xresolution = 0, yresolution = 0; /* Pixels per meter */ + unsigned int ncolours = 0u; /* Number of colours */ + unsigned int importantcolours = 0u; /* Important colours */ + } BmpInfoHeader; + +public: + /** + * \brief Constructor of BMP reader + * @param filename - path to input data + * @return BitMap reader object + */ + explicit BitMap(const std::string& filename); + virtual ~BitMap() {} + + /** + * \brief Get size + * @return size + */ + size_t size() const override { + return _width * _height * 3; + } + + // langsu: ResizeType is a added by us to support custom resizing functions (only in opencv_wrapper). + // format_reader is copied from openvino samples/cpp/common/format_reader/ + // this might need special care when doing a OV uplift + std::shared_ptr<unsigned char> getData(size_t width, size_t height, ResizeType resize_type) override { + if ((width * height != 0) && (_width * _height != width * height)) { + std::cout << "[ WARNING ] Image won't be resized! Please use OpenCV.\n"; + return nullptr; + } + return _data; + } +}; +} // namespace FormatReader diff --git a/python/openvino/runtime/common/format_reader/format_reader.cpp b/python/openvino/runtime/common/format_reader/format_reader.cpp new file mode 100644 index 0000000..94a8441 --- /dev/null +++ b/python/openvino/runtime/common/format_reader/format_reader.cpp @@ -0,0 +1,44 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include <iostream> + +// clang-format off +#include "bmp.h" +#include "MnistUbyte.h" +#include "yuv_nv12.h" +#include "opencv_wrapper.h" +#include "format_reader.h" +// clang-format on + +using namespace FormatReader; + +std::vector<Registry::CreatorFunction> Registry::_data; + +Register<MnistUbyte> MnistUbyte::reg; +Register<YUV_NV12> YUV_NV12::reg; +#ifdef USE_OPENCV +Register<OCVReader> OCVReader::reg; +#else +Register<BitMap> BitMap::reg; +#endif + +Reader* Registry::CreateReader(const char* filename) { + for (const auto &maker : _data) { + Reader* ol = maker(filename); + if (ol != nullptr && ol->size() != 0) + return ol; + if (ol != nullptr) + delete ol; + } + return nullptr; +} + +void Registry::RegisterReader(CreatorFunction f) { + _data.push_back(f); +} + +FORMAT_READER_API(Reader*) CreateFormatReader(const char* filename) { + return Registry::CreateReader(filename); +} diff --git a/python/openvino/runtime/common/format_reader/format_reader.h b/python/openvino/runtime/common/format_reader/format_reader.h new file mode 100644 index 0000000..99fc573 --- /dev/null +++ b/python/openvino/runtime/common/format_reader/format_reader.h @@ -0,0 +1,95 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * \brief Format reader abstract class implementation + * \file format_reader.h + */ +#pragma once + +#include <iostream> +#include <memory> +#include <string> +#include <vector> + +#if defined(_WIN32) +# ifdef IMPLEMENT_FORMAT_READER +# define FORMAT_READER_API(type) extern "C" __declspec(dllexport) type +# else +# define FORMAT_READER_API(type) extern "C" type +# endif +#elif (__GNUC__ >= 4) +# ifdef IMPLEMENT_FORMAT_READER +# define FORMAT_READER_API(type) extern "C" __attribute__((visibility("default"))) type +# else +# define FORMAT_READER_API(type) extern "C" type +# endif +#else +# define FORMAT_READER_API(TYPE) extern "C" TYPE +#endif + +namespace FormatReader { +/** + * \class FormatReader + * \brief This is an abstract class for reading input data + */ +class Reader { +protected: + /// \brief height + size_t _height = 0; + /// \brief width + size_t _width = 0; + /// \brief data + std::shared_ptr<unsigned char> _data; + +public: + virtual ~Reader() = default; + + // langsu: ResizeType is a added by us to support custom resizing functions (only in opencv_wrapper). + // format_reader is copied from openvino samples/cpp/common/format_reader/ + // this might need special care when doing a OV uplift + enum ResizeType { + RESIZE, // resize the image to target (height, width) + PAD_RESIZE, // pad the image into a squared image and then resize the image to target (height, width) + }; + + /** + * \brief Get width + * @return width + */ + size_t width() const { + return _width; + } + + /** + * \brief Get height + * @return height + */ + size_t height() const { + return _height; + } + + /** + * \brief Get input data ptr + * @return shared pointer with input data + * @In case of using OpenCV, parameters width and height will be used for image resizing + */ + // langsu: ResizeType is a added by us to support custom resizing functions (only in opencv_wrapper). + // Needs special care when doing a OV uplift + virtual std::shared_ptr<unsigned char> getData(size_t width = 0, size_t height = 0, + ResizeType resize_type = ResizeType::RESIZE) = 0; + + /** + * \brief Get size + * @return size + */ + virtual size_t size() const = 0; +}; +} // namespace FormatReader + +/** + * \brief Function for create reader + * @return FormatReader pointer + */ +FORMAT_READER_API(FormatReader::Reader*) CreateFormatReader(const char* filename); diff --git a/python/openvino/runtime/common/format_reader/format_reader_ptr.h b/python/openvino/runtime/common/format_reader/format_reader_ptr.h new file mode 100644 index 0000000..eb9bf8e --- /dev/null +++ b/python/openvino/runtime/common/format_reader/format_reader_ptr.h @@ -0,0 +1,43 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * \brief Implementation of smart pointer for Reader class + * \file format_reader_ptr.h + */ +#pragma once + +#include <functional> +#include <memory> + +#include "format_reader.h" + +namespace FormatReader { +class ReaderPtr { +public: + explicit ReaderPtr(const char* imageName) : reader(CreateFormatReader(imageName)) {} + /** + * @brief dereference operator overload + * @return Reader + */ + Reader* operator->() const noexcept { + return reader.get(); + } + + /** + * @brief dereference operator overload + * @return Reader + */ + Reader* operator*() const noexcept { + return reader.get(); + } + + Reader* get() { + return reader.get(); + } + +protected: + std::unique_ptr<Reader> reader; +}; +} // namespace FormatReader diff --git a/python/openvino/runtime/common/format_reader/opencv_wrapper.cpp b/python/openvino/runtime/common/format_reader/opencv_wrapper.cpp new file mode 100644 index 0000000..b8ebeef --- /dev/null +++ b/python/openvino/runtime/common/format_reader/opencv_wrapper.cpp @@ -0,0 +1,83 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#ifdef USE_OPENCV +# include <fstream> +# include <iostream> + +// clang-format off +# include <opencv2/opencv.hpp> + +# include "samples/slog.hpp" +# include "opencv_wrapper.h" +// clang-format on + +using namespace std; +using namespace FormatReader; + +OCVReader::OCVReader(const string& filename) { + img = cv::imread(filename); + _size = 0; + + if (img.empty()) { + return; + } + + _size = img.size().width * img.size().height * img.channels(); + _width = img.size().width; + _height = img.size().height; +} + +// Set the maximum number of printed warnings; large image directories can otherwise be overwhelming +static size_t resize_warning_count = 0; +const size_t max_resize_warnings = 5; + +std::shared_ptr<unsigned char> OCVReader::getData(size_t width = 0, size_t height = 0, ResizeType resize_type = ResizeType::RESIZE) { + if (width == 0) + width = img.cols; + + if (height == 0) + height = img.rows; + + size_t size = width * height * img.channels(); + _data.reset(new unsigned char[size], std::default_delete<unsigned char[]>()); + + if (width != static_cast<size_t>(img.cols) || height != static_cast<size_t>(img.rows)) { + if (resize_warning_count < max_resize_warnings) { + slog::warn << "Image is resized from (" << img.cols << ", " << img.rows << ") to (" << width << ", " << height + << ")" << slog::endl; + resize_warning_count++; + } else if (resize_warning_count == max_resize_warnings) { + slog::warn << "Additional image resizing messages have been suppressed." << slog::endl; + resize_warning_count++; + } + } + + cv::Mat resized; + if (resize_type == ResizeType::RESIZE) { + resized = cv::Mat(cv::Size(width, height), img.type(), _data.get()); + // cv::resize() just copy data to output image if sizes are the same + cv::resize(img, resized, cv::Size(width, height)); + } else if (resize_type == ResizeType::PAD_RESIZE) + { + cv::Mat padded; + // Find the larger side out of width and height of the image + int max_dim = std::max(img.rows, img.cols); + // Calculate padding for shorter dimension + int top = (max_dim - img.rows) / 2; + int bottom = (max_dim - img.rows + 1) / 2; + int left = (max_dim - img.cols) / 2; + int right = (max_dim - img.cols + 1) / 2; + // Add padding (0, i.e., black) to make the image a square + cv::copyMakeBorder(img, padded, top, bottom, left, right, cv::BORDER_CONSTANT, cv::Scalar()); + cv::resize(padded, resized, cv::Size(width, height)); + std::memcpy(_data.get(), resized.data, resized.total() * resized.elemSize()); + } else { + slog::err << "Specified resize type is not implemented." << slog::endl; + std::exit(1); + } + + return _data; +} +#endif diff --git a/python/openvino/runtime/common/format_reader/opencv_wrapper.h b/python/openvino/runtime/common/format_reader/opencv_wrapper.h new file mode 100644 index 0000000..c402e8d --- /dev/null +++ b/python/openvino/runtime/common/format_reader/opencv_wrapper.h @@ -0,0 +1,58 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * \brief Image reader + * \file opencv_wrapper.h + */ +#pragma once + +#ifdef USE_OPENCV +# include <memory> +# include <string> + +// clang-format off +# include <opencv2/opencv.hpp> + +# include "format_reader.h" +# include "register.h" +// clang-format on + +namespace FormatReader { +/** + * \class OCVMAT + * \brief OpenCV Wrapper + */ +class OCVReader : public Reader { +private: + cv::Mat img; + size_t _size; + static Register<OCVReader> reg; + +public: + /** + * \brief Constructor of BMP reader + * @param filename - path to input data + * @return BitMap reader object + */ + explicit OCVReader(const std::string& filename); + virtual ~OCVReader() {} + + /** + * \brief Get size + * @return size + */ + size_t size() const override { + return _size; + } + + // langsu: ResizeType is a added by us to support custom resizing functions (only in opencv_wrapper). + // format_reader is copied from openvino samples/cpp/common/format_reader/ + // this might need special care when doing a OV uplift + std::shared_ptr<unsigned char> getData(size_t width, + size_t height, + ResizeType resize_type) override; +}; +} // namespace FormatReader +#endif diff --git a/python/openvino/runtime/common/format_reader/register.h b/python/openvino/runtime/common/format_reader/register.h new file mode 100644 index 0000000..781eca3 --- /dev/null +++ b/python/openvino/runtime/common/format_reader/register.h @@ -0,0 +1,58 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// +/** + * \brief Register for readers + * \file register.h + */ +#pragma once + +#include <functional> +#include <string> +#include <vector> + +#include "format_reader.h" + +namespace FormatReader { +/** + * \class Registry + * \brief Create reader from fabric + */ +class Registry { +private: + typedef std::function<Reader*(const std::string& filename)> CreatorFunction; + static std::vector<CreatorFunction> _data; + +public: + /** + * \brief Create reader + * @param filename - path to input data + * @return Reader for input data or nullptr + */ + static Reader* CreateReader(const char* filename); + + /** + * \brief Registers reader in fabric + * @param f - a creation function + */ + static void RegisterReader(CreatorFunction f); +}; + +/** + * \class Register + * \brief Registers reader in fabric + */ +template <typename To> +class Register { +public: + /** + * \brief Constructor creates creation function for fabric + * @return Register object + */ + Register() { + Registry::RegisterReader([](const std::string& filename) -> Reader* { + return new To(filename); + }); + } +}; +} // namespace FormatReader diff --git a/python/openvino/runtime/common/format_reader/yuv_nv12.cpp b/python/openvino/runtime/common/format_reader/yuv_nv12.cpp new file mode 100644 index 0000000..f25c5cb --- /dev/null +++ b/python/openvino/runtime/common/format_reader/yuv_nv12.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +// clang-format off +#include <fstream> +#include <iostream> +#include <string> + +#include "yuv_nv12.h" +// clang-format on + +using namespace FormatReader; + +YUV_NV12::YUV_NV12(const std::string& filename) { + auto pos = filename.rfind('.'); + if (pos == std::string::npos) + return; + if (filename.substr(pos + 1) != "yuv") + return; + + std::ifstream file(filename, std::ios::binary); + if (!file.is_open()) { + return; + } + + file.seekg(0, file.end); + _size = file.tellg(); + file.seekg(0, file.beg); + + _data.reset(new unsigned char[_size], std::default_delete<unsigned char[]>()); + + file.read(reinterpret_cast<char*>(_data.get()), _size); + + file.close(); +} diff --git a/python/openvino/runtime/common/format_reader/yuv_nv12.h b/python/openvino/runtime/common/format_reader/yuv_nv12.h new file mode 100644 index 0000000..dd74c7b --- /dev/null +++ b/python/openvino/runtime/common/format_reader/yuv_nv12.h @@ -0,0 +1,57 @@ +// Copyright (C) 2018-2022 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +/** + * \brief YUV NV12 reader + * \file yuv_nv12.h + */ +#pragma once + +#include <memory> +#include <string> + +// clang-format off +#include "format_reader.h" +#include "register.h" +// clang-format on + +namespace FormatReader { +/** + * \class YUV_NV12 + * \brief Reader for YUV NV12 files + */ +class YUV_NV12 : public Reader { +private: + static Register<YUV_NV12> reg; + size_t _size = 0; + +public: + /** + * \brief Constructor of YUV NV12 reader + * @param filename - path to input data + * @return YUV_NV12 reader object + */ + explicit YUV_NV12(const std::string& filename); + virtual ~YUV_NV12() {} + + /** + * \brief Get size + * @return size + */ + size_t size() const override { + return _size; + } + + // langsu: ResizeType is a added by us to support custom resizing functions (only in opencv_wrapper). + // format_reader is copied from openvino samples/cpp/common/format_reader/ + // this might need special care when doing a OV uplift + std::shared_ptr<unsigned char> getData(size_t width, size_t height, Reader::ResizeType resize_type) override { + if ((width * height * 3 / 2 != size())) { + std::cout << "Image dimensions not match with NV12 file size \n"; + return nullptr; + } + return _data; + } +}; +} // namespace FormatReader |