utests/src/ut_tdm_capture.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29 **************************************************************************/
  30
  31 #include "gtest/gtest.h"
  32 #include "ut_common.h"
  33 #include "tdm.h"
  34 extern "C" {
  35 #include "tbm_bufmgr.h"
  36 #include "tbm_drm_helper.h"
  37 }
  38
  39 #include <sys/epoll.h>
  40 #include <sys/timerfd.h>
  41 #include <vector>
  42
  43 class TDMCaptureWithoutCreation : public testing::Test {
  44 protected:
  45         tdm_display *dpy = nullptr;
  46         tbm_bufmgr bufmgr = nullptr;
  47         tdm_display_capability display_capability = (tdm_display_capability)0;
  48         bool has_capture = false;
  49         std::vector<tdm_output *> output_array;
  50
  51         virtual void SetEnvs()
  52         {
  53                 setenv("TDM_DLOG", "1", 1);
  54                 setenv("XDG_RUNTIME_DIR", "/run", 1);
  55                 setenv("TBM_DLOG", "1", 1);
  56                 setenv("TDM_DEBUG_MODULE", "all", 1);
  57                 setenv("TDM_DEBUG", "1", 1);
  58                 setenv("TBM_DISPLAY_SERVER", "1", 1);
  59         }
  60
  61         virtual void UnsetEnvs()
  62         {
  63                 unsetenv("TDM_DLOG");
  64                 unsetenv("XDG_RUNTIME_DIR");
  65                 unsetenv("TBM_DLOG");
  66                 unsetenv("TDM_DEBUG_MODULE");
  67                 unsetenv("TDM_DEBUG");
  68                 unsetenv("TBM_DISPLAY_SERVER");
  69         }
  70
  71         void SetUp(void)
  72         {
  73                 tdm_error error = TDM_ERROR_NONE;
  74                 int output_count;
  75
  76                 SetEnvs();
  77
  78                 /* FIXME: fix the error. If we initialize TBM before TDM we get fail
  79                  * in the tdm_output_set_dpms */
  80 #if 0
  81                 bufmgr = tbm_bufmgr_init(-1);
  82                 ASSERT_FALSE(bufmgr == NULL);
  83 #endif
  84
  85                 dpy = tdm_display_init(&error);
  86                 ASSERT_TRUE(error == TDM_ERROR_NONE);
  87                 ASSERT_FALSE(dpy == nullptr);
  88
  89                 error = tdm_display_get_capabilities(dpy, &display_capability);
  90 #ifdef FAIL_ON_UNSUPPORTED
  91                 ASSERT_TRUE(display_capability & TDM_DISPLAY_CAPABILITY_CAPTURE);
  92 #endif
  93                 ASSERT_TRUE(error == TDM_ERROR_NONE);
  94
  95                 if (display_capability & TDM_DISPLAY_CAPABILITY_CAPTURE)
  96                         has_capture = true;
  97
  98                 ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE);
  99
 100                 for (int i = 0; i < output_count; i++) {
 101                         tdm_output *output = tdm_display_get_output(dpy, i, &error);
 102
 103                         if (TDM_ERROR_NONE != error || nullptr == output)
 104                                 continue;
 105
 106                         tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
 107                         if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status))
 108                                 continue;
 109
 110                         if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
 111                                 continue;
 112
 113                         output_array.push_back(output);
 114                 }
 115         }
 116
 117         void TearDown(void)
 118         {
 119                 if (dpy)
 120                         tdm_display_deinit(dpy);
 121                 if (bufmgr)
 122                         tbm_bufmgr_deinit(bufmgr);
 123
 124                 UnsetEnvs();
 125         }
 126 };
 127
 128 struct UtCapture
 129 {
 130         tdm_output *output;
 131         const tdm_output_mode *output_mode;
 132         tdm_capture *capture;
 133         std::vector<tdm_layer *> layers;
 134         UtCapture(tdm_output *, const tdm_output_mode *, tdm_capture *,  std::vector<tdm_layer *>);
 135 };
 136
 137 UtCapture::UtCapture(tdm_output *_output, const tdm_output_mode *_output_mode,
 138                                          tdm_capture *_capture, std::vector<tdm_layer *> _layers)
 139 {
 140         output = _output;
 141         output_mode = _output_mode;
 142         capture = _capture;
 143         layers = _layers;
 144 }
 145
 146 class TDMCapture : public TDMCaptureWithoutCreation {
 147 protected:
 148         const tbm_format *formats = nullptr;
 149         int format_count = 0;
 150         std::vector<UtCapture> captures;
 151         std::vector<tbm_surface_h> buffers;
 152         static int utCaptureDoneHandlerSuccessCounter;
 153         friend void UtCaptureDoneHandler(tdm_capture *capture,
 154                                                           tbm_surface_h buffer, void *user_data);
 155         void SetUp(void);
 156         void TearDown(void);
 157         void UtCaptureGetInfo(UtCapture *capture, double scale, tdm_transform transform, tdm_info_capture *info);
 158         void UtCaptureGetInfo(UtCapture *capture, tdm_info_capture *info);
 159         tbm_surface_h UtCaptureCreateBuffer(UtCapture *capture);
 160         tbm_surface_h UtCaptureCreateBuffer(int width, int height, tbm_format format, int scanout);
 161         tbm_surface_h UtCaptureCreateBuffer(int width, int height, tbm_format format);
 162 };
 163
 164 int TDMCapture::utCaptureDoneHandlerSuccessCounter = 0;
 165
 166 void UtCaptureDoneHandler(tdm_capture *capture,
 167                                                   tbm_surface_h buffer, void *user_data)
 168 {
 169         TDMCapture *fcapture = (TDMCapture *)user_data;
 170
 171         if (!fcapture)
 172                 return;
 173
 174         for (tbm_surface_h buf : fcapture->buffers) {
 175                 if (buf == buffer) {
 176                         fcapture->utCaptureDoneHandlerSuccessCounter++;
 177                         break;
 178                 }
 179         }
 180 }
 181
 182 void TDMCapture::SetUp(void)
 183 {
 184         tdm_error error;
 185
 186         utCaptureDoneHandlerSuccessCounter = 0;
 187
 188         ASSERT_NO_FATAL_FAILURE(TDMCaptureWithoutCreation::SetUp());
 189
 190         if (!has_capture)
 191                 return;
 192
 193         for (tdm_output *output : output_array) {
 194                 const tdm_output_mode *output_mode = nullptr;
 195                 int output_modes_cnt = 0;
 196                 const tdm_output_mode *output_modes;
 197                 int temp_layer_count = 0;
 198                 std::vector<tdm_layer *> layers;
 199
 200                 error = tdm_output_get_available_modes(output, &output_modes, &output_modes_cnt);
 201                 ASSERT_EQ(TDM_ERROR_NONE, error);
 202
 203                 for(int j = 0; j < output_modes_cnt; j++)
 204                         if(output_modes[j].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
 205                                 output_mode = &output_modes[j];
 206
 207                 ASSERT_NE(nullptr, output_mode);
 208
 209                 if (TDM_ERROR_NONE != tdm_output_get_layer_count(output, &temp_layer_count))
 210                         continue;
 211                 if (0 == temp_layer_count)
 212                         continue;
 213
 214                 for (int i = 0; i < temp_layer_count; ++i) {
 215                         tdm_layer *layer;
 216                         layer = tdm_output_get_layer(output, i, &error);
 217                         ASSERT_TRUE(TDM_ERROR_NONE == error);
 218                         ASSERT_FALSE(NULL == layer);
 219                         layers.push_back(layer);
 220                 }
 221
 222                 tdm_capture *capture = tdm_output_create_capture(output, &error);
 223                 ASSERT_NE(nullptr, capture);
 224                 ASSERT_EQ(TDM_ERROR_NONE, error);
 225
 226                 captures.emplace_back(output, output_mode, capture, layers);
 227         }
 228
 229         error =
 230                 tdm_display_get_catpure_available_formats(dpy, &formats, &format_count);
 231         ASSERT_EQ(TDM_ERROR_NONE, error);
 232         ASSERT_NE(nullptr, formats);
 233         ASSERT_GE(format_count, 0);
 234 }
 235
 236 void TDMCapture::TearDown(void)
 237 {
 238         for (UtCapture & utCapture : captures)
 239                 tdm_capture_destroy(utCapture.capture);
 240
 241         for (tbm_surface_h buffer : buffers) {
 242                 tbm_surface_destroy(buffer);
 243         }
 244
 245         TDMCaptureWithoutCreation::TearDown();
 246 }
 247
 248 void TDMCapture::UtCaptureGetInfo(UtCapture *capture, double scale,
 249                                                                   tdm_transform transform, tdm_info_capture *info)
 250 {
 251         memset((void *)info, 0, sizeof(tdm_info_capture));
 252
 253         const tdm_output_mode *output_mode = capture->output_mode;
 254
 255         int w = output_mode->hdisplay * scale;
 256         int h = output_mode->vdisplay * scale;
 257
 258         if (transform == TDM_TRANSFORM_90 || transform == TDM_TRANSFORM_270 ||
 259                 transform == TDM_TRANSFORM_FLIPPED_90 || transform == TDM_TRANSFORM_FLIPPED_270) {
 260                 int tmp = w;
 261                 w = h;
 262                 h = tmp;
 263         }
 264
 265         info->dst_config.size.h = w;
 266         info->dst_config.size.v = h;
 267         info->dst_config.pos.x = 0;
 268         info->dst_config.pos.y = 0;
 269         info->dst_config.pos.w = w;
 270         info->dst_config.pos.h = h;
 271         info->dst_config.format = formats[0];
 272         info->transform = transform;
 273         info->type = TDM_CAPTURE_TYPE_ONESHOT;
 274 }
 275
 276 void TDMCapture::UtCaptureGetInfo(UtCapture *capture, tdm_info_capture *info)
 277 {
 278         UtCaptureGetInfo(capture, 1.0, TDM_TRANSFORM_NORMAL, info);
 279 }
 280
 281 tbm_surface_h
 282 TDMCapture::UtCaptureCreateBuffer(UtCapture *capture)
 283 {
 284         tbm_surface_h buffer;
 285
 286         buffer = tbm_surface_create(capture->output_mode->hdisplay,
 287                                                                 capture->output_mode->vdisplay, formats[0]);
 288         if (buffer)
 289                 buffers.push_back(buffer);
 290
 291         return buffer;
 292 }
 293
 294 tbm_surface_h
 295 TDMCapture::UtCaptureCreateBuffer(int width, int height, tbm_format format, int scanout)
 296 {
 297         tbm_surface_h buffer;
 298
 299         if (scanout)
 300                 buffer = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_SCANOUT);
 301         else
 302                 buffer = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_DEFAULT);
 303
 304         if (buffer)
 305                 buffers.push_back(buffer);
 306
 307         return buffer;
 308 }
 309
 310 tbm_surface_h
 311 TDMCapture::UtCaptureCreateBuffer(int width, int height, tbm_format format)
 312 {
 313         return UtCaptureCreateBuffer(width, height, format, 0);
 314 }
 315
 316 class TDMCaptureCommit : public TDMCapture {
 317 public:
 318 private:
 319         int epFd = -1;
 320         int timerFd = -1;
 321         int tdmFd = -1;
 322         static const int timeLimitSec = 3;
 323         static const int timeLimitNsec = 0;
 324 protected:
 325         void SetUp(void);
 326         void TearDown(void);
 327         void UtHandleCaptureEvent();
 328         int UtPrepareToCapture(double scale, tdm_transform transform, tdm_capture_type type);
 329         int UtPrepareToCapture(double scale, tdm_transform transform);
 330         int UtPrepareToCapture();
 331 };
 332
 333 void TDMCaptureCommit::SetUp(void)
 334 {
 335         struct epoll_event ep;
 336         tdm_error error;
 337
 338         ASSERT_NO_FATAL_FAILURE(TDMCapture::SetUp());
 339
 340         for (UtCapture & utCapture : captures) {
 341                 error = tdm_output_set_mode(utCapture.output, utCapture.output_mode);
 342                 ASSERT_TRUE(error == TDM_ERROR_NONE);
 343
 344                 error = tdm_output_set_dpms(utCapture.output, TDM_OUTPUT_DPMS_ON);
 345                 ASSERT_TRUE(error == TDM_ERROR_NONE);
 346
 347                 for (tdm_layer *layer : utCapture.layers) {
 348                         int w, h;
 349                         tdm_layer_capability lcapabilities;
 350                         tbm_surface_h buffer;
 351                         tdm_info_layer layer_info = {0};
 352
 353                         w = utCapture.output_mode->hdisplay;
 354                         h = utCapture.output_mode->vdisplay;
 355
 356                         error = tdm_layer_get_capabilities(layer, &lcapabilities);
 357                         ASSERT_EQ(TDM_ERROR_NONE, error);
 358                         if (!(lcapabilities & TDM_LAYER_CAPABILITY_PRIMARY)) {
 359                                 w = w / 2;
 360                                 h = h / 2;
 361                         }
 362
 363                         buffer = UtCaptureCreateBuffer(w, h, TBM_FORMAT_ARGB8888, 1);
 364                         ASSERT_NE(nullptr, buffer);
 365
 366                         layer_info.src_config.size.h = w;
 367                         layer_info.src_config.size.v = h;
 368                         layer_info.src_config.pos.x = 0;
 369                         layer_info.src_config.pos.y = 0;
 370                         layer_info.src_config.pos.w = w;
 371                         layer_info.src_config.pos.h = h;
 372                         layer_info.src_config.format = TBM_FORMAT_ARGB8888;
 373                         layer_info.dst_pos.x = 0;
 374                         layer_info.dst_pos.y = 0;
 375                         layer_info.dst_pos.w = w;
 376                         layer_info.dst_pos.h = h;
 377                         layer_info.transform = TDM_TRANSFORM_NORMAL;
 378
 379                         error = tdm_layer_set_info(layer, &layer_info);
 380                         ASSERT_EQ(TDM_ERROR_NONE, error);
 381
 382                         error = tdm_layer_set_buffer(layer, buffer);
 383                         ASSERT_EQ(TDM_ERROR_NONE, error);
 384                 }
 385
 386                 error = tdm_output_commit(utCapture.output, 0, nullptr, nullptr);
 387                 ASSERT_EQ(TDM_ERROR_NONE, error);
 388         }
 389
 390         /* TODO: use output_commit_handle */
 391         usleep(200000);
 392
 393         epFd = epoll_create1(0);
 394         ASSERT_TRUE(epFd != -1);
 395
 396         timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
 397         ASSERT_TRUE(timerFd != -1);
 398
 399         memset(&ep, 0, sizeof ep);
 400         ep.events |= EPOLLIN;
 401         ep.data.fd = timerFd;
 402         ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, timerFd, &ep) == 0);
 403
 404         ASSERT_TRUE(tdm_display_get_fd(dpy, &tdmFd) == TDM_ERROR_NONE);
 405
 406         memset(&ep, 0, sizeof ep);
 407         ep.events |= EPOLLIN;
 408         ep.data.fd = tdmFd;
 409         ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, tdmFd, &ep) == 0);
 410 }
 411
 412 void TDMCaptureCommit::TearDown(void)
 413 {
 414         if (epFd)
 415                 close(epFd);
 416         if (timerFd)
 417                 close(timerFd);
 418
 419         for (UtCapture & utCapture : captures) {
 420                 for (tdm_layer *layer : utCapture.layers)
 421                         tdm_layer_unset_buffer(layer);
 422
 423                 tdm_output_set_dpms(utCapture.output, TDM_OUTPUT_DPMS_OFF);
 424         }
 425
 426         TDMCapture::TearDown();
 427 }
 428
 429 void TDMCaptureCommit::UtHandleCaptureEvent()
 430 {
 431         struct itimerspec its;
 432         int count;
 433         struct epoll_event ep_event[2];
 434
 435         if (utCaptureDoneHandlerSuccessCounter == (int)captures.size())
 436                 return;
 437
 438         its.it_interval.tv_sec = 0;
 439         its.it_interval.tv_nsec = 0;
 440         its.it_value.tv_sec = timeLimitSec;
 441         its.it_value.tv_nsec = timeLimitNsec;
 442
 443         ASSERT_TRUE(timerfd_settime(timerFd, 0, &its, NULL) == 0);
 444
 445         while (1) {
 446                 count = epoll_wait(epFd, ep_event, sizeof(ep_event), -1);
 447                 ASSERT_TRUE(count >= 0);
 448
 449                 for (int i = 0; i < count; i++) {
 450                         if (ep_event[i].data.fd == timerFd) {
 451                                 return;
 452                         } else {
 453                                 ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
 454                                 if (utCaptureDoneHandlerSuccessCounter == (int)captures.size())
 455                                         return;
 456                         }
 457                 }
 458         }
 459 }
 460
 461 int TDMCaptureCommit::UtPrepareToCapture(double scale, tdm_transform transform, tdm_capture_type type)
 462 {
 463         tdm_error error;
 464         tbm_surface_h buffer;
 465
 466         for (UtCapture & utCapture : captures) {
 467                 tdm_info_capture info = {0};
 468
 469                 UtCaptureGetInfo(&utCapture, scale, transform, &info);
 470                 info.type = type;
 471
 472                 error = tdm_capture_set_done_handler(utCapture.capture, UtCaptureDoneHandler, this);
 473                 EXPECT_EQ(TDM_ERROR_NONE, error);
 474                 if (error != TDM_ERROR_NONE)
 475                         return -1;
 476
 477                 error = tdm_capture_set_info(utCapture.capture, &info);
 478                 EXPECT_EQ(TDM_ERROR_NONE, error);
 479                 if (error != TDM_ERROR_NONE)
 480                         return -1;
 481
 482                 buffer = UtCaptureCreateBuffer(info.dst_config.size.h,
 483                                                                            info.dst_config.size.v,
 484                                                                            info.dst_config.format);
 485                 EXPECT_NE(NULL, buffer);
 486                 if (!buffer)
 487                         return -1;
 488
 489                 error = tdm_capture_attach(utCapture.capture, buffer);
 490                 EXPECT_EQ(TDM_ERROR_NONE, error);
 491                 if (error != TDM_ERROR_NONE)
 492                         return -1;
 493         }
 494
 495         return 0;
 496 }
 497
 498 int TDMCaptureCommit::UtPrepareToCapture()
 499 {
 500         return UtPrepareToCapture(1.0, TDM_TRANSFORM_NORMAL);
 501 }
 502
 503 int TDMCaptureCommit::UtPrepareToCapture(double scale, tdm_transform transform)
 504 {
 505         return UtPrepareToCapture(1.0, TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT);
 506 }
 507
 508 class TDMCaptureCommitThread : public TDMCaptureCommit {
 509 protected:
 510         void SetEnvs()
 511         {
 512                 TDMCaptureCommit::SetEnvs();
 513                 setenv("TDM_THREAD", "1", 1);
 514         }
 515         void UnsetEnvs()
 516         {
 517                 TDMCaptureCommit::UnsetEnvs();
 518                 unsetenv("TDM_THREAD");
 519         }
 520 };
 521
 522 TEST_F(TDMCaptureWithoutCreation, DisplayGetCaptureAvailableFormatsSuccessful)
 523 {
 524         SKIP_FLAG(has_capture);
 525         const tbm_format * formats = nullptr;
 526         int count = -42;
 527         ASSERT_TRUE(TDM_ERROR_NONE == tdm_display_get_catpure_available_formats(dpy, &formats, &count));
 528         ASSERT_FALSE(-42 == count);
 529         ASSERT_FALSE(nullptr == formats);
 530 }
 531
 532 /* tdm_display_create_pp() */
 533
 534 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureNullAll)
 535 {
 536         SKIP_FLAG(has_capture);
 537         tdm_capture *capture;
 538
 539         capture = tdm_output_create_capture(nullptr, nullptr);
 540         ASSERT_EQ(nullptr, capture);
 541 }
 542
 543 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureNullOutput)
 544 {
 545         SKIP_FLAG(has_capture);
 546         tdm_capture *capture;
 547         tdm_error error;
 548
 549         capture = tdm_output_create_capture(nullptr, &error);
 550         ASSERT_EQ(nullptr, capture);
 551         ASSERT_NE(TDM_ERROR_NONE, error);
 552 }
 553
 554 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureSuccessNullError)
 555 {
 556         SKIP_FLAG(has_capture);
 557         tdm_capture *capture;
 558
 559         for (tdm_output *output : output_array) {
 560                 capture = tdm_output_create_capture(output, nullptr);
 561                 ASSERT_NE(nullptr, capture);
 562         }
 563 }
 564
 565 TEST_F(TDMCaptureWithoutCreation, DisplayCreateCaptureSuccess)
 566 {
 567         SKIP_FLAG(has_capture);
 568         tdm_capture *capture;
 569         tdm_error error;
 570
 571         for (tdm_output *output : output_array) {
 572                 capture = tdm_output_create_capture(output, &error);
 573                 ASSERT_NE(nullptr, capture);
 574                 ASSERT_EQ(TDM_ERROR_NONE, error);
 575         }
 576 }
 577
 578 /* tdm_display_get_capture_available_size */
 579
 580 TEST_F(TDMCapture, DisplayGetCaptureAvailableSizeFailNullAll)
 581 {
 582         SKIP_FLAG(has_capture);
 583         tdm_error error;
 584
 585         error = tdm_display_get_capture_available_size(nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
 586         ASSERT_NE(TDM_ERROR_NONE, error);
 587 }
 588
 589 TEST_F(TDMCapture, DisplayGetCaptureAvailableSizeSuccess)
 590 {
 591         SKIP_FLAG(has_capture);
 592         tdm_error error;
 593         int min_w;
 594         int min_h;
 595         int max_w;
 596         int max_h;
 597         int preferred_align;
 598
 599         error = tdm_display_get_capture_available_size(dpy, &min_w, &min_h,
 600                                                                                                    &max_w, &max_h, &preferred_align);
 601         ASSERT_EQ(TDM_ERROR_NONE, error);
 602 }
 603
 604
 605 /* tdm_capture_set_info() */
 606
 607 TEST_F(TDMCapture, CaptureSetInfoFailNullAll)
 608 {
 609         SKIP_FLAG(has_capture);
 610         tdm_error error;
 611
 612         error = tdm_capture_set_info(nullptr, nullptr);
 613         ASSERT_NE(TDM_ERROR_NONE, error);
 614 }
 615
 616 TEST_F(TDMCapture, CaptureSetInfoFailNullCapture)
 617 {
 618         SKIP_FLAG(has_capture);
 619         tdm_error error;
 620         tdm_info_capture info;
 621
 622         error = tdm_capture_set_info(nullptr, &info);
 623         ASSERT_NE(TDM_ERROR_NONE, error);
 624 }
 625
 626 TEST_F(TDMCapture, CaptureSetInfoNullInfo)
 627 {
 628         SKIP_FLAG(has_capture);
 629         tdm_error error;
 630
 631         for (UtCapture & utCapture : captures) {
 632                 error = tdm_capture_set_info(utCapture.capture, nullptr);
 633                 ASSERT_NE(TDM_ERROR_NONE, error);
 634         }
 635 }
 636
 637 TEST_F(TDMCapture, CaptureSetInfoSuccessStream)
 638 {
 639         SKIP_FLAG(has_capture);
 640         tdm_error error;
 641         tdm_info_capture info;
 642
 643         for (UtCapture & utCapture : captures) {
 644                 error = tdm_output_set_mode(utCapture.output, utCapture.output_mode);
 645                 ASSERT_EQ(TDM_ERROR_NONE, error);
 646
 647                 UtCaptureGetInfo(&utCapture, &info);
 648
 649                 info.type = TDM_CAPTURE_TYPE_STREAM;
 650
 651                 error = tdm_capture_set_info(utCapture.capture, &info);
 652                 ASSERT_EQ(TDM_ERROR_NONE, error);
 653         }
 654 }
 655
 656 TEST_F(TDMCapture, CaptureSetInfoSuccess)
 657 {
 658         SKIP_FLAG(has_capture);
 659         tdm_error error;
 660         tdm_info_capture info;
 661
 662         for (UtCapture & utCapture : captures) {
 663                 UtCaptureGetInfo(&utCapture, &info);
 664
 665                 error = tdm_capture_set_info(utCapture.capture, &info);
 666                 ASSERT_EQ(TDM_ERROR_NONE, error);
 667         }
 668 }
 669
 670 /* tdm_capture_set_done_handler() */
 671
 672 TEST_F(TDMCapture, CaptureSetDoneHandlerFailNullAll)
 673 {
 674         SKIP_FLAG(has_capture);
 675         tdm_error error;
 676
 677         error = tdm_capture_set_done_handler(nullptr, nullptr, nullptr);
 678         ASSERT_NE(TDM_ERROR_NONE, error);
 679 }
 680
 681 TEST_F(TDMCapture, CaptureSetDoneHandlerFailNullCapture)
 682 {
 683         SKIP_FLAG(has_capture);
 684         tdm_error error;
 685
 686         error = tdm_capture_set_done_handler(nullptr, UtCaptureDoneHandler, this);
 687         ASSERT_NE(TDM_ERROR_NONE, error);
 688 }
 689
 690 TEST_F(TDMCapture, CaptureSetDoneHandlerSuccessNullFailNullFunc)
 691 {
 692         SKIP_FLAG(has_capture);
 693         tdm_error error;
 694
 695         for (UtCapture & utCapture : captures) {
 696                 error = tdm_pp_set_done_handler(utCapture.capture, nullptr, this);
 697                 ASSERT_NE(TDM_ERROR_NONE, error);
 698         }
 699 }
 700
 701 TEST_F(TDMCapture, CaptureSetDoneHandlerSuccessNullData)
 702 {
 703         SKIP_FLAG(has_capture);
 704         tdm_error error;
 705
 706         for (UtCapture & utCapture : captures) {
 707                 error = tdm_capture_set_done_handler(utCapture.capture, UtCaptureDoneHandler, this);
 708                 ASSERT_EQ(TDM_ERROR_NONE, error);
 709         }
 710 }
 711
 712 TEST_F(TDMCapture, CaptureSetDoneHandlerSuccess)
 713 {
 714         SKIP_FLAG(has_capture);
 715         tdm_error error;
 716
 717         for (UtCapture & utCapture : captures) {
 718                 error = tdm_capture_set_done_handler(utCapture.capture, UtCaptureDoneHandler, this);
 719                 ASSERT_EQ(TDM_ERROR_NONE, error);
 720         }
 721 }
 722
 723 /* tdm_capture_attach() */
 724
 725 TEST_F(TDMCapture, CaptureAttachFailNullAll)
 726 {
 727         SKIP_FLAG(has_capture);
 728         tdm_error error;
 729
 730         error = tdm_capture_attach(nullptr, nullptr);
 731         ASSERT_NE(TDM_ERROR_NONE, error);
 732 }
 733
 734 TEST_F(TDMCapture, CaptureAttachFailNullCapture)
 735 {
 736         SKIP_FLAG(has_capture);
 737         tdm_error error;
 738         tbm_surface_h buffer;
 739
 740         buffer = UtCaptureCreateBuffer(&captures[0]);
 741         ASSERT_NE(nullptr, buffer);
 742
 743         error = tdm_capture_attach(nullptr, buffer);
 744         ASSERT_NE(TDM_ERROR_NONE, error);
 745 }
 746
 747 TEST_F(TDMCapture, CaptureAttachFailNullBuffer)
 748 {
 749         SKIP_FLAG(has_capture);
 750         tdm_error error;
 751
 752         for (UtCapture & utCapture : captures) {
 753                 error = tdm_capture_attach(utCapture.capture, nullptr);
 754                 ASSERT_NE(TDM_ERROR_NONE, error);
 755         }
 756 }
 757
 758 TEST_F(TDMCapture, CaptureAttachSuccess)
 759 {
 760         SKIP_FLAG(has_capture);
 761         tdm_error error;
 762         tbm_surface_h buffer;
 763
 764         for (UtCapture & utCapture : captures) {
 765                 buffer = UtCaptureCreateBuffer(&utCapture);
 766                 ASSERT_NE(nullptr, buffer);
 767
 768                 error = tdm_capture_attach(utCapture.capture, buffer);
 769                 ASSERT_EQ(TDM_ERROR_NONE, error);
 770         }
 771 }
 772
 773 /* tdm_pp_commit() */
 774
 775 TEST_F(TDMCapture, CaptureCommitFailNullCapture)
 776 {
 777         SKIP_FLAG(has_capture);
 778         tdm_error error;
 779
 780         error = tdm_capture_commit(nullptr);
 781         ASSERT_NE(TDM_ERROR_NONE, error);
 782 }
 783
 784 TEST_F(TDMCapture, CaptureCommitFailDpmsOff)
 785 {
 786         SKIP_FLAG(has_capture);
 787         tdm_error error;
 788
 789         for (UtCapture & utCapture : captures) {
 790                 error = tdm_capture_commit(utCapture.capture);
 791                 ASSERT_NE(TDM_ERROR_NONE, error);
 792         }
 793 }
 794
 795 TEST_F(TDMCaptureCommit, CaptureCommitSuccess)
 796 {
 797         SKIP_FLAG(has_capture);
 798         tdm_error error;
 799
 800         ASSERT_NE(-1, UtPrepareToCapture());
 801
 802         for (UtCapture & utCapture : captures) {
 803                 error = tdm_capture_commit(utCapture.capture);
 804                 ASSERT_EQ(TDM_ERROR_NONE, error);
 805         }
 806
 807         UtHandleCaptureEvent();
 808
 809         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 810 }
 811
 812 TEST_F(TDMCaptureCommitThread, CaptureCommitSuccess)
 813 {
 814         SKIP_FLAG(has_capture);
 815         tdm_error error;
 816
 817         ASSERT_NE(-1, UtPrepareToCapture());
 818
 819         for (UtCapture & utCapture : captures) {
 820                 error = tdm_capture_commit(utCapture.capture);
 821                 ASSERT_EQ(TDM_ERROR_NONE, error);
 822         }
 823
 824         UtHandleCaptureEvent();
 825
 826         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 827 }
 828
 829 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScale)
 830 {
 831         SKIP_FLAG(has_capture);
 832         tdm_error error;
 833
 834         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_NORMAL));
 835
 836         for (UtCapture & utCapture : captures) {
 837                 error = tdm_capture_commit(utCapture.capture);
 838                 ASSERT_EQ(TDM_ERROR_NONE, error);
 839         }
 840
 841         UtHandleCaptureEvent();
 842
 843         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 844 }
 845
 846 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransform)
 847 {
 848         SKIP_FLAG(has_capture);
 849         tdm_error error;
 850
 851         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_180));
 852
 853         for (UtCapture & utCapture : captures) {
 854                 error = tdm_capture_commit(utCapture.capture);
 855                 ASSERT_EQ(TDM_ERROR_NONE, error);
 856         }
 857
 858         UtHandleCaptureEvent();
 859
 860         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 861 }
 862
 863 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransform90)
 864 {
 865         SKIP_FLAG(has_capture);
 866         tdm_error error;
 867
 868         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_90));
 869
 870         for (UtCapture & utCapture : captures) {
 871                 error = tdm_capture_commit(utCapture.capture);
 872                 ASSERT_EQ(TDM_ERROR_NONE, error);
 873         }
 874
 875         UtHandleCaptureEvent();
 876
 877         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 878 }
 879
 880 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransform270)
 881 {
 882         SKIP_FLAG(has_capture);
 883         tdm_error error;
 884
 885         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_270));
 886
 887         for (UtCapture & utCapture : captures) {
 888                 error = tdm_capture_commit(utCapture.capture);
 889                 ASSERT_EQ(TDM_ERROR_NONE, error);
 890         }
 891
 892         UtHandleCaptureEvent();
 893
 894         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 895 }
 896
 897 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransformFliped)
 898 {
 899         SKIP_FLAG(has_capture);
 900         tdm_error error;
 901
 902         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_FLIPPED));
 903
 904         for (UtCapture & utCapture : captures) {
 905                 error = tdm_capture_commit(utCapture.capture);
 906                 ASSERT_EQ(TDM_ERROR_NONE, error);
 907         }
 908
 909         UtHandleCaptureEvent();
 910
 911         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 912 }
 913
 914 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransformFliped90)
 915 {
 916         SKIP_FLAG(has_capture);
 917         tdm_error error;
 918
 919         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_FLIPPED_90));
 920
 921         for (UtCapture & utCapture : captures) {
 922                 error = tdm_capture_commit(utCapture.capture);
 923                 ASSERT_EQ(TDM_ERROR_NONE, error);
 924         }
 925
 926         UtHandleCaptureEvent();
 927
 928         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 929 }
 930
 931 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransformFliped180)
 932 {
 933         SKIP_FLAG(has_capture);
 934         tdm_error error;
 935
 936         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_FLIPPED_180));
 937
 938         for (UtCapture & utCapture : captures) {
 939                 error = tdm_capture_commit(utCapture.capture);
 940                 ASSERT_EQ(TDM_ERROR_NONE, error);
 941         }
 942
 943         UtHandleCaptureEvent();
 944
 945         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 946 }
 947
 948 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleAndTransformFliped270)
 949 {
 950         SKIP_FLAG(has_capture);
 951         tdm_error error;
 952
 953         ASSERT_NE(-1, UtPrepareToCapture(2.0, TDM_TRANSFORM_FLIPPED_270));
 954
 955         for (UtCapture & utCapture : captures) {
 956                 error = tdm_capture_commit(utCapture.capture);
 957                 ASSERT_EQ(TDM_ERROR_NONE, error);
 958         }
 959
 960         UtHandleCaptureEvent();
 961
 962         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 963 }
 964
 965 TEST_F(TDMCaptureCommit, CaptureCommitSuccessScaleStream)
 966 {
 967         SKIP_FLAG(has_capture);
 968         tdm_error error;
 969
 970         ASSERT_NE(-1, UtPrepareToCapture(1.0, TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_STREAM));
 971
 972         for (UtCapture & utCapture : captures) {
 973                 error = tdm_capture_commit(utCapture.capture);
 974                 ASSERT_EQ(TDM_ERROR_NONE, error);
 975         }
 976
 977         UtHandleCaptureEvent();
 978
 979         ASSERT_EQ(captures.size(), utCaptureDoneHandlerSuccessCounter);
 980 }