2 * Copyright (C) 2016 Intel Corporation. All Rights Reserved.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 #include "i965_test_environment.h"
26 #include "i965_test_image_utils.h"
28 #include <cstring> // std::memset
46 YUVImage::Shared YUVImage::create(
47 const unsigned fourcc, size_t w, size_t h)
49 Shared t(new YUVImage);
52 t->width = w = w + (w & 1);
53 t->height = h = h + (h & 1);
58 t->widths = {w, w, w};
59 t->heights = {h, h, h};
60 t->format = VA_RT_FORMAT_YUV444;
65 t->widths = {w, w >> 1, w >> 1};
66 t->heights = {h, h >> 1, h >> 1};
67 t->format = VA_RT_FORMAT_YUV420;
71 t->widths = {w, w, 0};
72 t->heights = {h, h >> 1, 0};
73 t->format = VA_RT_FORMAT_YUV420;
78 t->widths = {w << 1, 0, 0};
79 t->heights = {h, 0, 0};
80 t->format = VA_RT_FORMAT_YUV422;
84 t->widths = {w, w >> 1, w >> 1};
85 t->heights = {h, h, h};
86 t->format = VA_RT_FORMAT_YUV422;
90 t->widths = {w, w, w};
91 t->heights = {h, h >> 1,h >> 1};
92 t->format = VA_RT_FORMAT_YUV422;
96 t->widths = {w, 0, 0};
97 t->heights = {h, 0, 0};
98 t->format = VA_RT_FORMAT_YUV400;
101 return Shared(); // fourcc is unsupported
104 t->sizes = t->widths * t->heights;
105 t->bytes = std::valarray<uint8_t>(t->sizes.sum());
107 for (size_t i(1); i < t->planes; ++i)
108 t->offsets[i] = t->sizes[i - 1] + t->offsets[i - 1];
117 t->slices[1] = std::slice{t->offsets[1], t->sizes[1], 1};
118 t->slices[2] = std::slice{t->offsets[2], t->sizes[2], 1};
121 t->slices[0] = std::slice{t->offsets[0], t->sizes[0], 1};
124 t->slices[0] = std::slice{t->offsets[0], t->sizes[0], 1};
125 t->slices[1] = std::slice{t->offsets[1], t->sizes[1]/2, 2};
126 t->slices[2] = std::slice{t->offsets[1] + 1, t->sizes[1]/2, 2};
129 t->slices[0] = std::slice{t->offsets[0] + 1, t->sizes[0]/2, 2};
130 t->slices[1] = std::slice{t->offsets[0], t->sizes[0]/4, 4};
131 t->slices[2] = std::slice{t->offsets[0] + 2, t->sizes[0]/4, 4};
134 t->slices[0] = std::slice{t->offsets[0], t->sizes[0]/2, 2};
135 t->slices[1] = std::slice{t->offsets[0] + 1, t->sizes[0]/4, 4};
136 t->slices[2] = std::slice{t->offsets[0] + 3, t->sizes[0]/4, 4};
139 return Shared(); // fourcc is unsupported
145 YUVImage::Shared YUVImage::create(const VAImage& image)
147 I965TestEnvironment& env = *I965TestEnvironment::instance();
149 Shared result = create(image.format.fourcc, image.width, image.height);
150 EXPECT_PTR(result.get());
152 if (::testing::Test::HasFailure())
155 EXPECT_EQ(result->fourcc, image.format.fourcc);
156 EXPECT_EQ(result->planes, image.num_planes);
157 EXPECT_EQ(result->width, image.width);
158 EXPECT_EQ(result->height, image.height);
159 EXPECT_GE(image.data_size, result->bytes.size());
161 if (::testing::Test::HasFailure())
164 uint8_t* data = NULL;
165 EXPECT_STATUS(i965_MapBuffer(env, image.buf, (void**)&data));
167 if (::testing::Test::HasFailure())
170 auto it(std::begin(result->bytes));
171 for (size_t i(0); i < image.num_planes; ++i) {
172 const size_t pitch(image.pitches[i]);
173 const size_t width(result->widths[i]);
174 const size_t height(result->heights[i]);
175 const uint8_t *source = data + image.offsets[i];
177 EXPECT_GE(pitch, width);
178 if (::testing::Test::HasFailure())
181 for (size_t j(0); j < height; ++j) {
182 std::copy(source, source + width, it);
188 EXPECT_STATUS(i965_UnmapBuffer(env, image.buf));
190 if (::testing::Test::HasFailure())
196 YUVImage::Shared YUVImage::create(const VASurfaceID surface)
198 I965TestEnvironment& env = *I965TestEnvironment::instance();
201 EXPECT_STATUS(i965_DeriveImage(env, surface, &image));
203 if (::testing::Test::HasFailure())
206 Shared result = YUVImage::create(image);
208 EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
213 void YUVImage::toSurface(VASurfaceID surface) const
215 I965TestEnvironment& env = *I965TestEnvironment::instance();
218 ASSERT_STATUS(i965_DeriveImage(env, surface, &image));
220 EXPECT_ID(image.image_id);
221 EXPECT_EQ(fourcc, image.format.fourcc);
222 EXPECT_EQ(planes, image.num_planes);
223 EXPECT_EQ(width, image.width);
224 EXPECT_EQ(height, image.height);
225 EXPECT_GE(image.data_size, bytes.size());
227 if (::testing::Test::HasFailure()) {
228 EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
232 uint8_t* data = NULL;
233 EXPECT_STATUS(i965_MapBuffer(env, image.buf, (void**)&data));
236 if (::testing::Test::HasFailure()) {
237 EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
241 std::memset(data, 0, image.data_size);
243 auto it(std::begin(bytes));
244 for (size_t i(0); i < image.num_planes; ++i) {
245 const size_t pitch(image.pitches[i]);
246 const size_t w(widths[i]);
247 const size_t h(heights[i]);
248 uint8_t *dest = data + image.offsets[i];
251 if (::testing::Test::HasFailure())
254 for (size_t j(0); j < h; ++j) {
255 std::copy(it, it + w, dest);
261 EXPECT_STATUS(i965_UnmapBuffer(env, image.buf));
262 EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
265 TEST(YUVImageTest, 444P)
267 std::valarray<uint8_t> data = {
268 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99
271 YUVImage::Shared image = YUVImage::create(VA_FOURCC_444P, 2, 2);
272 ASSERT_PTR(image.get());
274 EXPECT_EQ(data.size(), image->bytes.size());
275 EXPECT_EQ(2u, image->width);
276 EXPECT_EQ(2u, image->height);
277 EXPECT_EQ(3u, image->planes);
278 EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->widths).min() );
279 EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->heights).min() );
280 EXPECT_TRUE( (std::valarray<size_t>{4,4,4} == image->sizes).min() );
281 EXPECT_TRUE( (std::valarray<size_t>{0,4,8} == image->offsets).min() );
285 std::valarray<uint8_t> y = image->y();
286 std::valarray<uint8_t> u = image->u();
287 std::valarray<uint8_t> v = image->v();
289 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() );
290 EXPECT_TRUE( (std::valarray<uint8_t>{0x00,0x73,0x54,0xcc} == u).min() );
291 EXPECT_TRUE( (std::valarray<uint8_t>{0xca,0x6b,0x12,0x99} == v).min() );
293 image->bytes = uint8_t(0);
295 EXPECT_FALSE( (image->bytes == data).min() );
301 EXPECT_TRUE( (image->bytes == data).min() );
304 TEST(YUVImageTest, IMC3)
306 std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73};
308 YUVImage::Shared image = YUVImage::create(VA_FOURCC_IMC3, 2, 2);
309 ASSERT_PTR(image.get());
311 EXPECT_EQ(data.size(), image->bytes.size());
312 EXPECT_EQ(2u, image->width);
313 EXPECT_EQ(2u, image->height);
314 EXPECT_EQ(3u, image->planes);
315 EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->widths).min() );
316 EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->heights).min() );
317 EXPECT_TRUE( (std::valarray<size_t>{4,1,1} == image->sizes).min() );
318 EXPECT_TRUE( (std::valarray<size_t>{0,4,5} == image->offsets).min() );
322 std::valarray<uint8_t> y = image->y();
323 std::valarray<uint8_t> u = image->u();
324 std::valarray<uint8_t> v = image->v();
326 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() );
327 EXPECT_TRUE( (std::valarray<uint8_t>{0x00} == u).min() );
328 EXPECT_TRUE( (std::valarray<uint8_t>{0x73} == v).min() );
330 image->bytes = uint8_t(0);
332 EXPECT_FALSE( (image->bytes == data).min() );
338 EXPECT_TRUE( (image->bytes == data).min() );
341 TEST(YUVImageTest, I420)
343 std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73};
345 YUVImage::Shared image = YUVImage::create(VA_FOURCC_I420, 2, 2);
346 ASSERT_PTR(image.get());
348 EXPECT_EQ(data.size(), image->bytes.size());
349 EXPECT_EQ(2u, image->width);
350 EXPECT_EQ(2u, image->height);
351 EXPECT_EQ(3u, image->planes);
352 EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->widths).min() );
353 EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->heights).min() );
354 EXPECT_TRUE( (std::valarray<size_t>{4,1,1} == image->sizes).min() );
355 EXPECT_TRUE( (std::valarray<size_t>{0,4,5} == image->offsets).min() );
359 std::valarray<uint8_t> y = image->y();
360 std::valarray<uint8_t> u = image->u();
361 std::valarray<uint8_t> v = image->v();
363 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() );
364 EXPECT_TRUE( (std::valarray<uint8_t>{0x00} == u).min() );
365 EXPECT_TRUE( (std::valarray<uint8_t>{0x73} == v).min() );
367 image->bytes = uint8_t(0);
369 EXPECT_FALSE( (image->bytes == data).min() );
375 EXPECT_TRUE( (image->bytes == data).min() );
378 TEST(YUVImageTest, NV12)
380 std::valarray<uint8_t> data = {
381 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99};
383 YUVImage::Shared image = YUVImage::create(VA_FOURCC_NV12, 2, 4);
384 ASSERT_PTR(image.get());
386 EXPECT_EQ(data.size(), image->bytes.size());
387 EXPECT_EQ(2u, image->width);
388 EXPECT_EQ(4u, image->height);
389 EXPECT_EQ(2u, image->planes);
390 EXPECT_TRUE( (std::valarray<size_t>{2,2,0} == image->widths).min() );
391 EXPECT_TRUE( (std::valarray<size_t>{4,2,0} == image->heights).min() );
392 EXPECT_TRUE( (std::valarray<size_t>{8,4,0} == image->sizes).min() );
393 EXPECT_TRUE( (std::valarray<size_t>{0,8,0} == image->offsets).min() );
397 std::valarray<uint8_t> y = image->y();
398 std::valarray<uint8_t> u = image->u();
399 std::valarray<uint8_t> v = image->v();
401 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc} == y).min() );
402 EXPECT_TRUE( (std::valarray<uint8_t>{0xca,0x12} == u).min() );
403 EXPECT_TRUE( (std::valarray<uint8_t>{0x6b,0x99} == v).min() );
405 image->bytes = uint8_t(0);
407 EXPECT_FALSE( (image->bytes == data).min() );
413 EXPECT_TRUE( (image->bytes == data).min() );
416 TEST(YUVImageTest, UYVY)
418 std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
420 YUVImage::Shared image = YUVImage::create(VA_FOURCC_UYVY, 2, 2);
421 ASSERT_PTR(image.get());
423 EXPECT_EQ(data.size(), image->bytes.size());
424 EXPECT_EQ(2u, image->width);
425 EXPECT_EQ(2u, image->height);
426 EXPECT_EQ(1u, image->planes);
427 EXPECT_TRUE( (std::valarray<size_t>{4,0,0} == image->widths).min() );
428 EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->heights).min() );
429 EXPECT_TRUE( (std::valarray<size_t>{8,0,0} == image->sizes).min() );
430 EXPECT_TRUE( (std::valarray<size_t>{0,0,0} == image->offsets).min() );
434 std::valarray<uint8_t> y = image->y();
435 std::valarray<uint8_t> u = image->u();
436 std::valarray<uint8_t> v = image->v();
438 EXPECT_TRUE( (std::valarray<uint8_t>{0xaf,0xff,0x73,0xcc} == y).min() );
439 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0x00} == u).min() );
440 EXPECT_TRUE( (std::valarray<uint8_t>{0x23,0x54} == v).min() );
442 image->bytes = uint8_t(0);
444 EXPECT_FALSE( (image->bytes == data).min() );
450 EXPECT_TRUE( (image->bytes == data).min() );
453 TEST(YUVImageTest, YUY2)
455 std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
457 YUVImage::Shared image = YUVImage::create(VA_FOURCC_YUY2, 2, 2);
458 ASSERT_PTR(image.get());
460 EXPECT_EQ(data.size(), image->bytes.size());
461 EXPECT_EQ(2u, image->width);
462 EXPECT_EQ(2u, image->height);
463 EXPECT_EQ(1u, image->planes);
464 EXPECT_TRUE( (std::valarray<size_t>{4,0,0} == image->widths).min() );
465 EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->heights).min() );
466 EXPECT_TRUE( (std::valarray<size_t>{8,0,0} == image->sizes).min() );
467 EXPECT_TRUE( (std::valarray<size_t>{0,0,0} == image->offsets).min() );
471 std::valarray<uint8_t> y = image->y();
472 std::valarray<uint8_t> u = image->u();
473 std::valarray<uint8_t> v = image->v();
475 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0x23,0x00,0x54} == y).min() );
476 EXPECT_TRUE( (std::valarray<uint8_t>{0xaf,0x73} == u).min() );
477 EXPECT_TRUE( (std::valarray<uint8_t>{0xff,0xcc} == v).min() );
479 image->bytes = uint8_t(0);
481 EXPECT_FALSE( (image->bytes == data).min() );
487 EXPECT_TRUE( (image->bytes == data).min() );
490 TEST(YUVImageTest, 422H)
492 std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
494 YUVImage::Shared image = YUVImage::create(VA_FOURCC_422H, 2, 2);
495 ASSERT_PTR(image.get());
497 EXPECT_EQ(data.size(), image->bytes.size());
498 EXPECT_EQ(2u, image->width);
499 EXPECT_EQ(2u, image->height);
500 EXPECT_EQ(3u, image->planes);
501 EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->widths).min() );
502 EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->heights).min() );
503 EXPECT_TRUE( (std::valarray<size_t>{4,2,2} == image->sizes).min() );
504 EXPECT_TRUE( (std::valarray<size_t>{0,4,6} == image->offsets).min() );
508 std::valarray<uint8_t> y = image->y();
509 std::valarray<uint8_t> u = image->u();
510 std::valarray<uint8_t> v = image->v();
512 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() );
513 EXPECT_TRUE( (std::valarray<uint8_t>{0x00,0x73} == u).min() );
514 EXPECT_TRUE( (std::valarray<uint8_t>{0x54,0xcc} == v).min() );
516 image->bytes = uint8_t(0);
518 EXPECT_FALSE( (image->bytes == data).min() );
524 EXPECT_TRUE( (image->bytes == data).min() );
527 TEST(YUVImageTest, 422V)
529 std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
531 YUVImage::Shared image = YUVImage::create(VA_FOURCC_422V, 2, 2);
532 ASSERT_PTR(image.get());
534 EXPECT_EQ(data.size(), image->bytes.size());
535 EXPECT_EQ(2u, image->width);
536 EXPECT_EQ(2u, image->height);
537 EXPECT_EQ(3u, image->planes);
538 EXPECT_TRUE( (std::valarray<size_t>{2,2,2} == image->widths).min() );
539 EXPECT_TRUE( (std::valarray<size_t>{2,1,1} == image->heights).min() );
540 EXPECT_TRUE( (std::valarray<size_t>{4,2,2} == image->sizes).min() );
541 EXPECT_TRUE( (std::valarray<size_t>{0,4,6} == image->offsets).min() );
545 std::valarray<uint8_t> y = image->y();
546 std::valarray<uint8_t> u = image->u();
547 std::valarray<uint8_t> v = image->v();
549 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() );
550 EXPECT_TRUE( (std::valarray<uint8_t>{0x00,0x73} == u).min() );
551 EXPECT_TRUE( (std::valarray<uint8_t>{0x54,0xcc} == v).min() );
553 image->bytes = uint8_t(0);
555 EXPECT_FALSE( (image->bytes == data).min() );
561 EXPECT_TRUE( (image->bytes == data).min() );
564 TEST(YUVImageTest, Y800)
566 std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff};
568 YUVImage::Shared image = YUVImage::create(VA_FOURCC_Y800, 2, 2);
569 ASSERT_PTR(image.get());
571 EXPECT_EQ(data.size(), image->bytes.size());
572 EXPECT_EQ(2u, image->width);
573 EXPECT_EQ(2u, image->height);
574 EXPECT_EQ(1u, image->planes);
575 EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->widths).min() );
576 EXPECT_TRUE( (std::valarray<size_t>{2,0,0} == image->heights).min() );
577 EXPECT_TRUE( (std::valarray<size_t>{4,0,0} == image->sizes).min() );
578 EXPECT_TRUE( (std::valarray<size_t>{0,0,0} == image->offsets).min() );
582 std::valarray<uint8_t> y = image->y();
584 EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() );
586 image->bytes = uint8_t(0);
588 EXPECT_FALSE( (image->bytes == data).min() );
592 EXPECT_TRUE( (image->bytes == data).min() );
595 TEST(YUVImageTest, Invalid)
597 YUVImage::Shared image = YUVImage::create(VA_FOURCC('B','E','E','F'), 2, 2);
598 EXPECT_PTR_NULL(image.get());
601 TEST(YUVImageTest, I420toNV12)
603 std::valarray<uint8_t> data1 = {
604 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99};
605 std::valarray<uint8_t> data2 = {
606 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x12,0x6b,0x99};
608 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_I420, 2, 4);
609 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_NV12, 2, 4);
610 ASSERT_PTR(image1.get());
611 ASSERT_PTR(image2.get());
613 image1->bytes = data1;
614 image2->y() = image1->y();
615 image2->u() = image1->u();
616 image2->v() = image1->v();
618 EXPECT_TRUE( (image2->bytes == data2).min() );
621 TEST(YUVImageTest, NV12toI420)
623 std::valarray<uint8_t> data1 = {
624 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99};
625 std::valarray<uint8_t> data2 = {
626 0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x12,0x6b,0x99};
628 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_NV12, 2, 4);
629 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_I420, 2, 4);
630 ASSERT_PTR(image1.get());
631 ASSERT_PTR(image2.get());
633 image1->bytes = data1;
634 image2->y() = image1->y();
635 image2->u() = image1->u();
636 image2->v() = image1->v();
638 EXPECT_TRUE( (image2->bytes == data2).min() );
641 TEST(YUVImageTest, UYVYtoYUY2)
643 std::valarray<uint8_t> data1 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
644 std::valarray<uint8_t> data2 = {0xaf,0x11,0xff,0x23,0x73,0x00,0xcc,0x54};
646 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_UYVY, 2, 2);
647 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_YUY2, 2, 2);
648 ASSERT_PTR(image1.get());
649 ASSERT_PTR(image2.get());
651 image1->bytes = data1;
652 image2->y() = image1->y();
653 image2->u() = image1->u();
654 image2->v() = image1->v();
656 EXPECT_TRUE( (image2->bytes == data2).min() );
659 TEST(YUVImageTest, YUY2toUYVY)
661 std::valarray<uint8_t> data1 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
662 std::valarray<uint8_t> data2 = {0xaf,0x11,0xff,0x23,0x73,0x00,0xcc,0x54};
664 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_YUY2, 2, 2);
665 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_UYVY, 2, 2);
666 ASSERT_PTR(image1.get());
667 ASSERT_PTR(image2.get());
669 image1->bytes = data1;
670 image2->y() = image1->y();
671 image2->u() = image1->u();
672 image2->v() = image1->v();
674 EXPECT_TRUE( (image2->bytes == data2).min() );
677 TEST(YUVImageTest, UYVYto422H)
679 std::valarray<uint8_t> data1 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
680 std::valarray<uint8_t> data2 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54};
682 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_UYVY, 2, 2);
683 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_422H, 2, 2);
684 ASSERT_PTR(image1.get());
685 ASSERT_PTR(image2.get());
687 image1->bytes = data1;
688 image2->y() = image1->y();
689 image2->u() = image1->u();
690 image2->v() = image1->v();
692 EXPECT_TRUE( (image2->bytes == data2).min() );
695 TEST(YUVImageTest, 422HtoUYVY)
697 std::valarray<uint8_t> data1 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54};
698 std::valarray<uint8_t> data2 = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
700 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_422H, 2, 2);
701 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_UYVY, 2, 2);
702 ASSERT_PTR(image1.get());
703 ASSERT_PTR(image2.get());
705 image1->bytes = data1;
706 image2->y() = image1->y();
707 image2->u() = image1->u();
708 image2->v() = image1->v();
710 EXPECT_TRUE( (image2->bytes == data2).min() );
713 TEST(YUVImageTest, YUY2to422H)
715 std::valarray<uint8_t> data1 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54};
716 std::valarray<uint8_t> data2 = {0xaf,0x73,0x11,0x23,0xff,0x00,0xcc,0x54};
718 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_YUY2, 2, 2);
719 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_422H, 2, 2);
720 ASSERT_PTR(image1.get());
721 ASSERT_PTR(image2.get());
723 image1->bytes = data1;
724 image2->y() = image1->y();
725 image2->u() = image1->u();
726 image2->v() = image1->v();
728 EXPECT_TRUE( (image2->bytes == data2).min() );
731 TEST(YUVImageTest, 422HtoYUY2)
733 std::valarray<uint8_t> data1 = {0xaf,0x73,0x11,0x23,0xff,0x00,0xcc,0x54};
734 std::valarray<uint8_t> data2 = {0xaf,0xff,0x73,0xcc,0x11,0x00,0x23,0x54};
736 YUVImage::Shared image1 = YUVImage::create(VA_FOURCC_422H, 2, 2);
737 YUVImage::Shared image2 = YUVImage::create(VA_FOURCC_YUY2, 2, 2);
738 ASSERT_PTR(image1.get());
739 ASSERT_PTR(image2.get());
741 image1->bytes = data1;
742 image2->y() = image1->y();
743 image2->u() = image1->u();
744 image2->v() = image1->v();
746 EXPECT_TRUE( (image2->bytes == data2).min() );