test/i965_test_image_utils.cpp

   1 /*
   2  * Copyright (C) 2016 Intel Corporation. All Rights Reserved.
   3  *
   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:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  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.
  23  */
  24
  25 #include "i965_test_environment.h"
  26 #include "i965_test_image_utils.h"
  27
  28 #include <cstring> // std::memset
  29
  30 YUVImage::YUVImage()
  31     : bytes()
  32     , width(0)
  33     , height(0)
  34     , fourcc(0)
  35     , format(0)
  36     , planes(0)
  37     , widths{0,0,0}
  38     , heights{0,0,0}
  39     , offsets{0,0,0}
  40     , sizes{0,0,0}
  41     , slices()
  42 {
  43     return;
  44 }
  45
  46 YUVImage::Shared YUVImage::create(
  47     const unsigned fourcc, size_t w, size_t h)
  48 {
  49     Shared t(new YUVImage);
  50
  51     t->fourcc = fourcc;
  52     t->width = w = w + (w & 1);
  53     t->height = h = h + (h & 1);
  54
  55     switch(fourcc) {
  56     case VA_FOURCC_444P:
  57         t->planes = 3;
  58         t->widths = {w, w, w};
  59         t->heights = {h, h, h};
  60         t->format = VA_RT_FORMAT_YUV444;
  61         break;
  62     case VA_FOURCC_IMC3:
  63     case VA_FOURCC_I420:
  64         t->planes = 3;
  65         t->widths = {w, w >> 1, w >> 1};
  66         t->heights = {h, h >> 1, h >> 1};
  67         t->format = VA_RT_FORMAT_YUV420;
  68         break;
  69     case VA_FOURCC_NV12:
  70         t->planes = 2;
  71         t->widths = {w, w, 0};
  72         t->heights = {h, h >> 1, 0};
  73         t->format = VA_RT_FORMAT_YUV420;
  74         break;
  75     case VA_FOURCC_UYVY:
  76     case VA_FOURCC_YUY2:
  77         t->planes = 1;
  78         t->widths = {w << 1, 0, 0};
  79         t->heights = {h, 0, 0};
  80         t->format = VA_RT_FORMAT_YUV422;
  81         break;
  82     case VA_FOURCC_422H:
  83         t->planes = 3;
  84         t->widths = {w, w >> 1, w >> 1};
  85         t->heights = {h, h, h};
  86         t->format = VA_RT_FORMAT_YUV422;
  87         break;
  88     case VA_FOURCC_422V:
  89         t->planes = 3;
  90         t->widths = {w, w, w};
  91         t->heights = {h, h >> 1,h >> 1};
  92         t->format = VA_RT_FORMAT_YUV422;
  93         break;
  94     case VA_FOURCC_Y800:
  95         t->planes = 1;
  96         t->widths = {w, 0, 0};
  97         t->heights = {h, 0, 0};
  98         t->format = VA_RT_FORMAT_YUV400;
  99         break;
 100     default:
 101         return Shared(); // fourcc is unsupported
 102     }
 103
 104     t->sizes = t->widths * t->heights;
 105     t->bytes = std::valarray<uint8_t>(t->sizes.sum());
 106
 107     for (size_t i(1); i < t->planes; ++i)
 108         t->offsets[i] = t->sizes[i - 1] + t->offsets[i - 1];
 109
 110     // Initialize slices
 111     switch(fourcc) {
 112     case VA_FOURCC_444P:
 113     case VA_FOURCC_IMC3:
 114     case VA_FOURCC_I420:
 115     case VA_FOURCC_422H:
 116     case VA_FOURCC_422V:
 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};
 119         /* fall-through */
 120     case VA_FOURCC_Y800:
 121         t->slices[0] = std::slice{t->offsets[0], t->sizes[0], 1};
 122         break;
 123     case VA_FOURCC_NV12:
 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};
 127         break;
 128     case VA_FOURCC_UYVY:
 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};
 132         break;
 133     case VA_FOURCC_YUY2:
 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};
 137         break;
 138     default:
 139         return Shared(); // fourcc is unsupported
 140     }
 141
 142     return t;
 143 }
 144
 145 YUVImage::Shared YUVImage::create(const VAImage& image)
 146 {
 147     I965TestEnvironment& env = *I965TestEnvironment::instance();
 148
 149     Shared result = create(image.format.fourcc, image.width, image.height);
 150     EXPECT_PTR(result.get());
 151
 152     if (::testing::Test::HasFailure())
 153         return Shared();
 154
 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());
 160
 161     if (::testing::Test::HasFailure())
 162         return Shared();
 163
 164     uint8_t* data = NULL;
 165     EXPECT_STATUS(i965_MapBuffer(env, image.buf, (void**)&data));
 166
 167     if (::testing::Test::HasFailure())
 168         return Shared();
 169
 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];
 176
 177         EXPECT_GE(pitch, width);
 178         if (::testing::Test::HasFailure())
 179             break;
 180
 181         for (size_t j(0); j < height; ++j) {
 182             std::copy(source, source + width, it);
 183             source += pitch;
 184             it += width;
 185         }
 186     }
 187
 188     EXPECT_STATUS(i965_UnmapBuffer(env, image.buf));
 189
 190     if (::testing::Test::HasFailure())
 191         return Shared();
 192
 193     return result;
 194 }
 195
 196 YUVImage::Shared YUVImage::create(const VASurfaceID surface)
 197 {
 198     I965TestEnvironment& env = *I965TestEnvironment::instance();
 199     VAImage image{.image_id = VA_INVALID_ID};
 200
 201     EXPECT_STATUS(i965_DeriveImage(env, surface, &image));
 202
 203     if (::testing::Test::HasFailure())
 204         return Shared();
 205
 206     Shared result = YUVImage::create(image);
 207
 208     EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
 209
 210     return result;
 211 }
 212
 213 void YUVImage::toSurface(VASurfaceID surface) const
 214 {
 215     I965TestEnvironment& env = *I965TestEnvironment::instance();
 216     VAImage image{.image_id = VA_INVALID_ID};
 217
 218     ASSERT_STATUS(i965_DeriveImage(env, surface, &image));
 219
 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());
 226
 227     if (::testing::Test::HasFailure()) {
 228         EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
 229         return;
 230     }
 231
 232     uint8_t* data = NULL;
 233     EXPECT_STATUS(i965_MapBuffer(env, image.buf, (void**)&data));
 234     EXPECT_PTR(data);
 235
 236     if (::testing::Test::HasFailure()) {
 237         EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
 238         return;
 239     }
 240
 241     std::memset(data, 0, image.data_size);
 242
 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];
 249
 250         EXPECT_GE(pitch, w);
 251         if (::testing::Test::HasFailure())
 252             break;
 253
 254         for (size_t j(0); j < h; ++j) {
 255             std::copy(it, it + w, dest);
 256             dest += pitch;
 257             it += w;
 258         }
 259     }
 260
 261     EXPECT_STATUS(i965_UnmapBuffer(env, image.buf));
 262     EXPECT_STATUS(i965_DestroyImage(env, image.image_id));
 263 }
 264
 265 TEST(YUVImageTest, 444P)
 266 {
 267     std::valarray<uint8_t> data = {
 268         0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99
 269     };
 270
 271     YUVImage::Shared image = YUVImage::create(VA_FOURCC_444P, 2, 2);
 272     ASSERT_PTR(image.get());
 273
 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() );
 282
 283     image->bytes = data;
 284
 285     std::valarray<uint8_t> y = image->y();
 286     std::valarray<uint8_t> u = image->u();
 287     std::valarray<uint8_t> v = image->v();
 288
 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() );
 292
 293     image->bytes = uint8_t(0);
 294
 295     EXPECT_FALSE( (image->bytes == data).min() );
 296
 297     image->y() = y;
 298     image->u() = u;
 299     image->v() = v;
 300
 301     EXPECT_TRUE( (image->bytes == data).min() );
 302 }
 303
 304 TEST(YUVImageTest, IMC3)
 305 {
 306     std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73};
 307
 308     YUVImage::Shared image = YUVImage::create(VA_FOURCC_IMC3, 2, 2);
 309     ASSERT_PTR(image.get());
 310
 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() );
 319
 320     image->bytes = data;
 321
 322     std::valarray<uint8_t> y = image->y();
 323     std::valarray<uint8_t> u = image->u();
 324     std::valarray<uint8_t> v = image->v();
 325
 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() );
 329
 330     image->bytes = uint8_t(0);
 331
 332     EXPECT_FALSE( (image->bytes == data).min() );
 333
 334     image->y() = y;
 335     image->u() = u;
 336     image->v() = v;
 337
 338     EXPECT_TRUE( (image->bytes == data).min() );
 339 }
 340
 341 TEST(YUVImageTest, I420)
 342 {
 343     std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73};
 344
 345     YUVImage::Shared image = YUVImage::create(VA_FOURCC_I420, 2, 2);
 346     ASSERT_PTR(image.get());
 347
 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() );
 356
 357     image->bytes = data;
 358
 359     std::valarray<uint8_t> y = image->y();
 360     std::valarray<uint8_t> u = image->u();
 361     std::valarray<uint8_t> v = image->v();
 362
 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() );
 366
 367     image->bytes = uint8_t(0);
 368
 369     EXPECT_FALSE( (image->bytes == data).min() );
 370
 371     image->y() = y;
 372     image->u() = u;
 373     image->v() = v;
 374
 375     EXPECT_TRUE( (image->bytes == data).min() );
 376 }
 377
 378 TEST(YUVImageTest, NV12)
 379 {
 380     std::valarray<uint8_t> data = {
 381         0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc,0xca,0x6b,0x12,0x99};
 382
 383     YUVImage::Shared image = YUVImage::create(VA_FOURCC_NV12, 2, 4);
 384     ASSERT_PTR(image.get());
 385
 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() );
 394
 395     image->bytes = data;
 396
 397     std::valarray<uint8_t> y = image->y();
 398     std::valarray<uint8_t> u = image->u();
 399     std::valarray<uint8_t> v = image->v();
 400
 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() );
 404
 405     image->bytes = uint8_t(0);
 406
 407     EXPECT_FALSE( (image->bytes == data).min() );
 408
 409     image->y() = y;
 410     image->u() = u;
 411     image->v() = v;
 412
 413     EXPECT_TRUE( (image->bytes == data).min() );
 414 }
 415
 416 TEST(YUVImageTest, UYVY)
 417 {
 418     std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
 419
 420     YUVImage::Shared image = YUVImage::create(VA_FOURCC_UYVY, 2, 2);
 421     ASSERT_PTR(image.get());
 422
 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() );
 431
 432     image->bytes = data;
 433
 434     std::valarray<uint8_t> y = image->y();
 435     std::valarray<uint8_t> u = image->u();
 436     std::valarray<uint8_t> v = image->v();
 437
 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() );
 441
 442     image->bytes = uint8_t(0);
 443
 444     EXPECT_FALSE( (image->bytes == data).min() );
 445
 446     image->y() = y;
 447     image->u() = u;
 448     image->v() = v;
 449
 450     EXPECT_TRUE( (image->bytes == data).min() );
 451 }
 452
 453 TEST(YUVImageTest, YUY2)
 454 {
 455     std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
 456
 457     YUVImage::Shared image = YUVImage::create(VA_FOURCC_YUY2, 2, 2);
 458     ASSERT_PTR(image.get());
 459
 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() );
 468
 469     image->bytes = data;
 470
 471     std::valarray<uint8_t> y = image->y();
 472     std::valarray<uint8_t> u = image->u();
 473     std::valarray<uint8_t> v = image->v();
 474
 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() );
 478
 479     image->bytes = uint8_t(0);
 480
 481     EXPECT_FALSE( (image->bytes == data).min() );
 482
 483     image->y() = y;
 484     image->u() = u;
 485     image->v() = v;
 486
 487     EXPECT_TRUE( (image->bytes == data).min() );
 488 }
 489
 490 TEST(YUVImageTest, 422H)
 491 {
 492     std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
 493
 494     YUVImage::Shared image = YUVImage::create(VA_FOURCC_422H, 2, 2);
 495     ASSERT_PTR(image.get());
 496
 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() );
 505
 506     image->bytes = data;
 507
 508     std::valarray<uint8_t> y = image->y();
 509     std::valarray<uint8_t> u = image->u();
 510     std::valarray<uint8_t> v = image->v();
 511
 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() );
 515
 516     image->bytes = uint8_t(0);
 517
 518     EXPECT_FALSE( (image->bytes == data).min() );
 519
 520     image->y() = y;
 521     image->u() = u;
 522     image->v() = v;
 523
 524     EXPECT_TRUE( (image->bytes == data).min() );
 525 }
 526
 527 TEST(YUVImageTest, 422V)
 528 {
 529     std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff,0x00,0x73,0x54,0xcc};
 530
 531     YUVImage::Shared image = YUVImage::create(VA_FOURCC_422V, 2, 2);
 532     ASSERT_PTR(image.get());
 533
 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() );
 542
 543     image->bytes = data;
 544
 545     std::valarray<uint8_t> y = image->y();
 546     std::valarray<uint8_t> u = image->u();
 547     std::valarray<uint8_t> v = image->v();
 548
 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() );
 552
 553     image->bytes = uint8_t(0);
 554
 555     EXPECT_FALSE( (image->bytes == data).min() );
 556
 557     image->y() = y;
 558     image->u() = u;
 559     image->v() = v;
 560
 561     EXPECT_TRUE( (image->bytes == data).min() );
 562 }
 563
 564 TEST(YUVImageTest, Y800)
 565 {
 566     std::valarray<uint8_t> data = {0x11,0xaf,0x23,0xff};
 567
 568     YUVImage::Shared image = YUVImage::create(VA_FOURCC_Y800, 2, 2);
 569     ASSERT_PTR(image.get());
 570
 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() );
 579
 580     image->bytes = data;
 581
 582     std::valarray<uint8_t> y = image->y();
 583
 584     EXPECT_TRUE( (std::valarray<uint8_t>{0x11,0xaf,0x23,0xff} == y).min() );
 585
 586     image->bytes = uint8_t(0);
 587
 588     EXPECT_FALSE( (image->bytes == data).min() );
 589
 590     image->y() = y;
 591
 592     EXPECT_TRUE( (image->bytes == data).min() );
 593 }
 594
 595 TEST(YUVImageTest, Invalid)
 596 {
 597     YUVImage::Shared image = YUVImage::create(VA_FOURCC('B','E','E','F'), 2, 2);
 598     EXPECT_PTR_NULL(image.get());
 599 }
 600
 601 TEST(YUVImageTest, I420toNV12)
 602 {
 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};
 607
 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());
 612
 613     image1->bytes = data1;
 614     image2->y() = image1->y();
 615     image2->u() = image1->u();
 616     image2->v() = image1->v();
 617
 618     EXPECT_TRUE( (image2->bytes == data2).min() );
 619 }
 620
 621 TEST(YUVImageTest, NV12toI420)
 622 {
 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};
 627
 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());
 632
 633     image1->bytes = data1;
 634     image2->y() = image1->y();
 635     image2->u() = image1->u();
 636     image2->v() = image1->v();
 637
 638     EXPECT_TRUE( (image2->bytes == data2).min() );
 639 }
 640
 641 TEST(YUVImageTest, UYVYtoYUY2)
 642 {
 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};
 645
 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());
 650
 651     image1->bytes = data1;
 652     image2->y() = image1->y();
 653     image2->u() = image1->u();
 654     image2->v() = image1->v();
 655
 656     EXPECT_TRUE( (image2->bytes == data2).min() );
 657 }
 658
 659 TEST(YUVImageTest, YUY2toUYVY)
 660 {
 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};
 663
 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());
 668
 669     image1->bytes = data1;
 670     image2->y() = image1->y();
 671     image2->u() = image1->u();
 672     image2->v() = image1->v();
 673
 674     EXPECT_TRUE( (image2->bytes == data2).min() );
 675 }
 676
 677 TEST(YUVImageTest, UYVYto422H)
 678 {
 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};
 681
 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());
 686
 687     image1->bytes = data1;
 688     image2->y() = image1->y();
 689     image2->u() = image1->u();
 690     image2->v() = image1->v();
 691
 692     EXPECT_TRUE( (image2->bytes == data2).min() );
 693 }
 694
 695 TEST(YUVImageTest, 422HtoUYVY)
 696 {
 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};
 699
 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());
 704
 705     image1->bytes = data1;
 706     image2->y() = image1->y();
 707     image2->u() = image1->u();
 708     image2->v() = image1->v();
 709
 710     EXPECT_TRUE( (image2->bytes == data2).min() );
 711 }
 712
 713 TEST(YUVImageTest, YUY2to422H)
 714 {
 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};
 717
 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());
 722
 723     image1->bytes = data1;
 724     image2->y() = image1->y();
 725     image2->u() = image1->u();
 726     image2->v() = image1->v();
 727
 728     EXPECT_TRUE( (image2->bytes == data2).min() );
 729 }
 730
 731 TEST(YUVImageTest, 422HtoYUY2)
 732 {
 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};
 735
 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());
 740
 741     image1->bytes = data1;
 742     image2->y() = image1->y();
 743     image2->u() = image1->u();
 744     image2->v() = image1->v();
 745
 746     EXPECT_TRUE( (image2->bytes == data2).min() );
 747 }