diff options
Diffstat (limited to 'test/i965_test_image_utils.cpp')
-rw-r--r-- | test/i965_test_image_utils.cpp | 747 |
1 files changed, 747 insertions, 0 deletions
diff --git a/test/i965_test_image_utils.cpp b/test/i965_test_image_utils.cpp new file mode 100644 index 0000000..bdfcbf3 --- /dev/null +++ b/test/i965_test_image_utils.cpp @@ -0,0 +1,747 @@ +/* + * Copyright (C) 2016 Intel Corporation. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "i965_test_environment.h" +#include "i965_test_image_utils.h" + +#include <cstring> // std::memset + +YUVImage::YUVImage() + : bytes() + , width(0) + , height(0) + , fourcc(0) + , format(0) + , planes(0) + , widths{0,0,0} + , heights{0,0,0} + , offsets{0,0,0} + , sizes{0,0,0} + , slices() +{ + return; +} + +YUVImage::Shared YUVImage::create( + const unsigned fourcc, size_t w, size_t h) +{ + Shared t(new YUVImage); + + t->fourcc = fourcc; + t->width = w = w + (w & 1); + t->height = h = h + (h & 1); + + switch(fourcc) { + case VA_FOURCC_444P: + t->planes = 3; + t->widths = {w, w, w}; + t->heights = {h, h, h}; + t->format = VA_RT_FORMAT_YUV444; + break; + case VA_FOURCC_IMC3: + case VA_FOURCC_I420: + t->planes = 3; + t->widths = {w, w >> 1, w >> 1}; + t->heights = {h, h >> 1, h >> 1}; + t->format = VA_RT_FORMAT_YUV420; + break; + case VA_FOURCC_NV12: + t->planes = 2; + t->widths = {w, w, 0}; + t->heights = {h, h >> 1, 0}; + t->format = VA_RT_FORMAT_YUV420; + break; + case VA_FOURCC_UYVY: + case VA_FOURCC_YUY2: + t->planes = 1; + t->widths = {w << 1, 0, 0}; + t->heights = {h, 0, 0}; + t->format = VA_RT_FORMAT_YUV422; + break; + case VA_FOURCC_422H: + t->planes = 3; + t->widths = {w, w >> 1, w >> 1}; + t->heights = {h, h, h}; + t->format = VA_RT_FORMAT_YUV422; + break; + case VA_FOURCC_422V: + t->planes = 3; + t->widths = {w, w, w}; + t->heights = {h, h >> 1,h >> 1}; + t->format = VA_RT_FORMAT_YUV422; + break; + case VA_FOURCC_Y800: + t->planes = 1; + t->widths = {w, 0, 0}; + t->heights = {h, 0, 0}; + t->format = VA_RT_FORMAT_YUV400; + break; + default: + return Shared(); // fourcc is unsupported + } + + t->sizes = t->widths * t->heights; + t->bytes = std::valarray<uint8_t>(t->sizes.sum()); + + for (size_t i(1); i < t->planes; ++i) + t->offsets[i] = t->sizes[i - 1] + t->offsets[i - 1]; + + // Initialize slices + switch(fourcc) { + case VA_FOURCC_444P: + case VA_FOURCC_IMC3: + case VA_FOURCC_I420: + case VA_FOURCC_422H: + case VA_FOURCC_422V: + t->slices[1] = std::slice{t->offsets[1], t->sizes[1], 1}; + t->slices[2] = std::slice{t->offsets[2], t->sizes[2], 1}; + /* fall-through */ + case VA_FOURCC_Y800: + t->slices[0] = std::slice{t->offsets[0], t->sizes[0], 1}; + break; + case VA_FOURCC_NV12: + t->slices[0] = std::slice{t->offsets[0], t->sizes[0], 1}; + t->slices[1] = std::slice{t->offsets[1], t->sizes[1]/2, 2}; + t->slices[2] = std::slice{t->offsets[1] + 1, t->sizes[1]/2, 2}; + break; + case VA_FOURCC_UYVY: + t->slices[0] = std::slice{t->offsets[0] + 1, t->sizes[0]/2, 2}; + t->slices[1] = std::slice{t->offsets[0], t->sizes[0]/4, 4}; + t->slices[2] = std::slice{t->offsets[0] + 2, t->sizes[0]/4, 4}; + break; + case VA_FOURCC_YUY2: + t->slices[0] = std::slice{t->offsets[0], t->sizes[0]/2, 2}; + t->slices[1] = std::slice{t->offsets[0] + 1, t->sizes[0]/4, 4}; + t->slices[2] = std::slice{t->offsets[0] + 3, t->sizes[0]/4, 4}; + break; + default: + return Shared(); // fourcc is unsupported + } + + return t; +} + +YUVImage::Shared YUVImage::create(const VAImage& image) +{ + I965TestEnvironment& env = *I965TestEnvironment::instance(); + + Shared result = create(image.format.fourcc, image.width, image.height); + EXPECT_PTR(result.get()); + + if (::testing::Test::HasFailure()) + return Shared(); + + EXPECT_EQ(result->fourcc, image.format.fourcc); + EXPECT_EQ(result->planes, image.num_planes); + EXPECT_EQ(result->width, image.width); + EXPECT_EQ(result->height, image.height); + EXPECT_GE(image.data_size, result->bytes.size()); + + if (::testing::Test::HasFailure()) + return Shared(); + + uint8_t* data = NULL; + EXPECT_STATUS(i965_MapBuffer(env, image.buf, (void**)&data)); + + if (::testing::Test::HasFailure()) + return Shared(); + + auto it(std::begin(result->bytes)); + for (size_t i(0); i < image.num_planes; ++i) { + const size_t pitch(image.pitches[i]); + const size_t width(result->widths[i]); + const size_t height(result->heights[i]); + const uint8_t *source = data + image.offsets[i]; + + EXPECT_GE(pitch, width); + if (::testing::Test::HasFailure()) + break; + + for (size_t j(0); j < height; ++j) { + std::copy(source, source + width, it); + source += pitch; + it += width; + } + } + + EXPECT_STATUS(i965_UnmapBuffer(env, image.buf)); + + if (::testing::Test::HasFailure()) + return Shared(); + + return result; +} + +YUVImage::Shared YUVImage::create(const VASurfaceID surface) +{ + I965TestEnvironment& env = *I965TestEnvironment::instance(); + VAImage image; + + EXPECT_STATUS(i965_DeriveImage(env, surface, &image)); + + if (::testing::Test::HasFailure()) + return Shared(); + + Shared result = YUVImage::create(image); + + EXPECT_STATUS(i965_DestroyImage(env, image.image_id)); + + return result; +} + +void YUVImage::toSurface(VASurfaceID surface) const +{ + I965TestEnvironment& env = *I965TestEnvironment::instance(); + VAImage image; + + ASSERT_STATUS(i965_DeriveImage(env, surface, &image)); + + EXPECT_ID(image.image_id); + EXPECT_EQ(fourcc, image.format.fourcc); + EXPECT_EQ(planes, image.num_planes); + EXPECT_EQ(width, image.width); + EXPECT_EQ(height, image.height); + EXPECT_GE(image.data_size, bytes.size()); + + if (::testing::Test::HasFailure()) { + EXPECT_STATUS(i965_DestroyImage(env, image.image_id)); + return; + } + + uint8_t* data = NULL; + EXPECT_STATUS(i965_MapBuffer(env, image.buf, (void**)&data)); + EXPECT_PTR(data); + + if (::testing::Test::HasFailure()) { + EXPECT_STATUS(i965_DestroyImage(env, image.image_id)); + return; + } + + std::memset(data, 0, image.data_size); + + auto it(std::begin(bytes)); + for (size_t i(0); i < image.num_planes; ++i) { + const size_t pitch(image.pitches[i]); + const size_t w(widths[i]); + const size_t h(heights[i]); + uint8_t *dest = data + image.offsets[i]; + + EXPECT_GE(pitch, w); + if (::testing::Test::HasFailure()) + break; + + for (size_t j(0); j < h; ++j) { + std::copy(it, it + w, dest); + dest += pitch; + it += w; + } + } + + EXPECT_STATUS(i965_UnmapBuffer(env, image.buf)); + EXPECT_STATUS(i965_DestroyImage(env, image.image_id)); +} + +TEST(YUVImageTest, 444P) +{ + std::valarray<uint8_t> data = { + 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99 + }; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_444P, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(3u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{4,4,4} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,4,8} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x00,0x73,0x54,0xcc} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0xca,0x6b,0x12,0x99} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, IMC3) +{ + std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_IMC3, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(3u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{4,1,1} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,4,5} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x00} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x73} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, I420) +{ + std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_I420, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(3u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{4,1,1} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,4,5} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x00} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x73} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, NV12) +{ + std::valarray<uint8_t> data = { + 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_NV12, 2, 4); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(4u, image->height); + EXPECT_EQ(2u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{2,2,0} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{4,2,0} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{8,4,0} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,8,0} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0xca,0x12} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x6b,0x99} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, UYVY) +{ + std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_UYVY, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(1u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{4,0,0} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{8,0,0} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,0,0} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0xaf,0xff,0x73,0xcc} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0x00} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x23,0x54} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, YUY2) +{ + std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_YUY2, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(1u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{4,0,0} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{8,0,0} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,0,0} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0x23,0x00,0x54} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0xaf,0x73} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0xff,0xcc} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, 422H) +{ + std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_422H, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(3u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{4,2,2} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,4,6} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x00,0x73} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x54,0xcc} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, 422V) +{ + std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_422V, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(3u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{4,2,2} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,4,6} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + std::valarray<uint8_t> u = image->u(); + std::valarray<uint8_t> v = image->v(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x00,0x73} == u).min() ); + EXPECT_TRUE( (std::valarray<uint8_t>{0x54,0xcc} == v).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + image->u() = u; + image->v() = v; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, Y800) +{ + std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff}; + + YUVImage::Shared image = YUVImage::create(VA_FOURCC_Y800, 2, 2); + ASSERT_PTR(image.get()); + + EXPECT_EQ(data.size(), image->bytes.size()); + EXPECT_EQ(2u, image->width); + EXPECT_EQ(2u, image->height); + EXPECT_EQ(1u, image->planes); + EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->widths).min() ); + EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->heights).min() ); + EXPECT_TRUE( (std::valarray<size_t>{4,0,0} == image->sizes).min() ); + EXPECT_TRUE( (std::valarray<size_t>{0,0,0} == image->offsets).min() ); + + image->bytes = data; + + std::valarray<uint8_t> y = image->y(); + + EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() ); + + image->bytes = uint8_t(0); + + EXPECT_FALSE( (image->bytes == data).min() ); + + image->y() = y; + + EXPECT_TRUE( (image->bytes == data).min() ); +} + +TEST(YUVImageTest, Invalid) +{ + YUVImage::Shared image = YUVImage::create(VA_FOURCC('B','E','E','F'), 2, 2); + EXPECT_PTR_NULL(image.get()); +} + +TEST(YUVImageTest, I420toNV12) +{ + std::valarray<uint8_t> data1 = { + 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99}; + std::valarray<uint8_t> data2 = { + 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x12,0x6b,0x99}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_I420, 2, 4); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_NV12, 2, 4); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} + +TEST(YUVImageTest, NV12toI420) +{ + std::valarray<uint8_t> data1 = { + 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99}; + std::valarray<uint8_t> data2 = { + 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x12,0x6b,0x99}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_NV12, 2, 4); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_I420, 2, 4); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} + +TEST(YUVImageTest, UYVYtoYUY2) +{ + std::valarray<uint8_t> data1 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + std::valarray<uint8_t> data2 = {0xaf,0x11,0xff,0x23,0x73,0x00,0xcc,0x54}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_UYVY, 2, 2); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_YUY2, 2, 2); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} + +TEST(YUVImageTest, YUY2toUYVY) +{ + std::valarray<uint8_t> data1 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + std::valarray<uint8_t> data2 = {0xaf,0x11,0xff,0x23,0x73,0x00,0xcc,0x54}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_YUY2, 2, 2); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_UYVY, 2, 2); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} + +TEST(YUVImageTest, UYVYto422H) +{ + std::valarray<uint8_t> data1 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + std::valarray<uint8_t> data2 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_UYVY, 2, 2); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_422H, 2, 2); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} + +TEST(YUVImageTest, 422HtoUYVY) +{ + std::valarray<uint8_t> data1 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54}; + std::valarray<uint8_t> data2 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_422H, 2, 2); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_UYVY, 2, 2); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} + +TEST(YUVImageTest, YUY2to422H) +{ + std::valarray<uint8_t> data1 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54}; + std::valarray<uint8_t> data2 = {0xaf,0x73,0x11,0x23,0xff,0x00,0xcc,0x54}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_YUY2, 2, 2); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_422H, 2, 2); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} + +TEST(YUVImageTest, 422HtoYUY2) +{ + std::valarray<uint8_t> data1 = {0xaf,0x73,0x11,0x23,0xff,0x00,0xcc,0x54}; + std::valarray<uint8_t> data2 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54}; + + YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_422H, 2, 2); + YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_YUY2, 2, 2); + ASSERT_PTR(image1.get()); + ASSERT_PTR(image2.get()); + + image1->bytes = data1; + image2->y() = image1->y(); + image2->u() = image1->u(); + image2->v() = image1->v(); + + EXPECT_TRUE( (image2->bytes == data2).min() ); +} |