imgp/unittest/libmm_imgp_unittest.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <tzplatform_config.h>
  18
  19 #include "libmm_imgp_unittest.h"
  20 #include "mm_util_jpeg.h"
  21 #include "mm_util_imgp.h"
  22
  23 #define DECODE_FILE_PATH        tzplatform_mkpath(TZ_SYS_BIN, "libmm-imgp-unittest.jpg")
  24
  25 using ::testing::InitGoogleTest;
  26 using ::testing::Test;
  27 using ::testing::TestCase;
  28
  29 class libmm_imgp_Test : public ::testing::Test {
  30         protected:
  31                 void SetUp() {
  32                         std::cout << "SetUp()" << std::endl;
  33                 }
  34
  35                 void TearDown() {
  36                         std::cout << "TearDown()" << std::endl;
  37                 }
  38 };
  39
  40 TEST(libmm_imgp_Test, mm_util_convert_colorspace_p)
  41 {
  42         int ret = MM_UTIL_ERROR_NONE;
  43         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0};
  44         unsigned char *data = NULL;
  45         unsigned int width = 0;
  46         unsigned int height = 0;
  47         size_t size = 0;;
  48
  49         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
  50         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
  51         EXPECT_TRUE(decode_image.data != NULL);
  52
  53         ret = mm_util_convert_colorspace((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, &width, &height, &size);
  54         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
  55         EXPECT_TRUE(data != NULL);
  56         EXPECT_EQ(width, 640);
  57         EXPECT_EQ(height, 480);
  58         EXPECT_NE(size, 0);
  59
  60         if (decode_image.data)
  61                 free(decode_image.data);
  62         if (data)
  63                 free(data);
  64 }
  65
  66 TEST(libmm_imgp_Test, mm_util_convert_colorspace_n)
  67 {
  68         int ret = MM_UTIL_ERROR_NONE;
  69         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
  70         unsigned char *data = NULL;
  71         unsigned int width = 0;
  72         unsigned int height = 0;
  73         size_t size = 0;;
  74
  75         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
  76         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
  77         EXPECT_TRUE(decode_image.data != NULL);
  78
  79         ret = mm_util_convert_colorspace(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, &width, &height, &size);
  80         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  81
  82         ret = mm_util_convert_colorspace((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, NULL, &width, &height, &size);
  83         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  84
  85         ret = mm_util_convert_colorspace((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, NULL, &height, &size);
  86         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  87
  88         ret = mm_util_convert_colorspace((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, &width, NULL, &size);
  89         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  90
  91         ret = mm_util_convert_colorspace((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, &width, &height, NULL);
  92         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
  93
  94         if (decode_image.data)
  95                 free(decode_image.data);
  96 }
  97
  98 TEST(libmm_imgp_Test, mm_util_resize_image_p)
  99 {
 100         int ret = MM_UTIL_ERROR_NONE;
 101         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0};
 102         unsigned char *data = NULL;
 103         unsigned int width = 0;
 104         unsigned int height = 0;
 105         size_t size = 0;;
 106
 107         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 108         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 109         EXPECT_TRUE(decode_image.data != NULL);
 110
 111         ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, &width, &height, &size);
 112         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 113         EXPECT_TRUE(data != NULL);
 114         EXPECT_EQ(width, 320);
 115         EXPECT_EQ(height, 240);
 116         EXPECT_NE(size, 0);
 117
 118         if (decode_image.data)
 119                 free(decode_image.data);
 120         if (data)
 121                 free(data);
 122 }
 123
 124 TEST(libmm_imgp_Test, mm_util_resize_image_n)
 125 {
 126         int ret = MM_UTIL_ERROR_NONE;
 127         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 128         unsigned char *data = NULL;
 129         unsigned int width = 0;
 130         unsigned int height = 0;
 131         size_t size = 0;;
 132
 133         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 134         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 135         EXPECT_TRUE(decode_image.data != NULL);
 136
 137         ret = mm_util_resize_image(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, &width, &height, &size);
 138         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 139
 140         ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 240, &data, &width, &height, &size);
 141         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 142
 143         ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 0, &data, &width, &height, &size);
 144         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 145
 146         ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, NULL, &width, &height, &size);
 147         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 148
 149         ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, NULL, &height, &size);
 150         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 151
 152         ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, &width, NULL, &size);
 153         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 154
 155         ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, &width, &height, NULL);
 156         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 157
 158         if (decode_image.data)
 159                 free(decode_image.data);
 160 }
 161
 162 TEST(libmm_imgp_Test, mm_util_rotate_image_p)
 163 {
 164         int ret = MM_UTIL_ERROR_NONE;
 165         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0};
 166         unsigned char *data = NULL;
 167         unsigned int width = 0;
 168         unsigned int height = 0;
 169         size_t size = 0;;
 170
 171         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 172         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 173         EXPECT_TRUE(decode_image.data != NULL);
 174
 175         ret = mm_util_rotate_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, &width, &height, &size);
 176         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 177         EXPECT_TRUE(data != NULL);
 178         EXPECT_EQ(width, 480);
 179         EXPECT_EQ(height, 640);
 180         EXPECT_NE(size, 0);
 181
 182         if (decode_image.data)
 183                 free(decode_image.data);
 184         if (data)
 185                 free(data);
 186 }
 187
 188 TEST(libmm_imgp_Test, mm_util_rotate_image_n)
 189 {
 190         int ret = MM_UTIL_ERROR_NONE;
 191         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 192         unsigned char *data = NULL;
 193         unsigned int width = 0;
 194         unsigned int height = 0;
 195         size_t size = 0;;
 196
 197         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 198         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 199         EXPECT_TRUE(decode_image.data != NULL);
 200
 201         ret = mm_util_rotate_image(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, &width, &height, &size);
 202         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 203
 204         ret = mm_util_rotate_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, NULL, &width, &height, &size);
 205         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 206
 207         ret = mm_util_rotate_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, NULL, &height, &size);
 208         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 209
 210         ret = mm_util_rotate_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, &width, NULL, &size);
 211         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 212
 213         ret = mm_util_rotate_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, &width, &height, NULL);
 214         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 215
 216         if (decode_image.data)
 217                 free(decode_image.data);
 218 }
 219
 220 TEST(libmm_imgp_Test, mm_util_crop_image_p)
 221 {
 222         int ret = MM_UTIL_ERROR_NONE;
 223         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0};
 224         unsigned char *data = NULL;
 225         unsigned int width = 0;
 226         unsigned int height = 0;
 227         size_t size = 0;;
 228
 229         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 230         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 231         EXPECT_TRUE(decode_image.data != NULL);
 232
 233         ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, &width, &height, &size);
 234         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 235         EXPECT_TRUE(data != NULL);
 236         EXPECT_EQ(width, 320);
 237         EXPECT_EQ(height, 240);
 238         EXPECT_NE(size, 0);
 239
 240         if (decode_image.data)
 241                 free(decode_image.data);
 242         if (data)
 243                 free(data);
 244 }
 245
 246 TEST(libmm_imgp_Test, mm_util_crop_image_n)
 247 {
 248         int ret = MM_UTIL_ERROR_NONE;
 249         mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0};
 250         unsigned char *data = NULL;
 251         unsigned int width = 0;
 252         unsigned int height = 0;
 253         size_t size = 0;;
 254
 255         ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image);
 256         EXPECT_EQ(ret, MM_UTIL_ERROR_NONE);
 257         EXPECT_TRUE(decode_image.data != NULL);
 258
 259         ret = mm_util_crop_image(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, &width, &height, &size);
 260         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 261
 262         ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 0, 240, &data, &width, &height, &size);
 263         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 264
 265         ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 0, &data, &width, &height, &size);
 266         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 267
 268         ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, NULL, &width, &height, &size);
 269         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 270
 271         ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, NULL, &height, &size);
 272         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 273
 274         ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, &width, NULL, &size);
 275         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 276
 277         ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, &width, &height, NULL);
 278         EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER);
 279
 280         if (decode_image.data)
 281                 free(decode_image.data);
 282 }
 283
 284 int main(int argc, char **argv)
 285 {
 286         InitGoogleTest(&argc, argv);
 287
 288         return RUN_ALL_TESTS();
 289 }
 290