src/resource_camera.c

   1  /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   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 <stdlib.h>
  18 #include <Ecore.h>
  19 #include <camera.h>
  20 #ifdef DEBUG_THREAD
  21 #include <pthread.h>
  22 #endif
  23
  24 #include "log.h"
  25 #include "controller.h"
  26 #include "resource_camera.h"
  27
  28 struct __camera_data {
  29         camera_h cam_handle;
  30
  31         void *captured_file;
  32         unsigned int image_size;
  33
  34         preview_image_buffer_created_cb preview_image_buffer_created_cb;
  35         void *preview_image_buffer_created_cb_data;
  36
  37         capture_completed_cb capture_completed_cb;
  38         void *capture_completed_cb_data;
  39
  40         bool is_af_enabled;
  41 };
  42
  43 static struct __camera_data *g_camera_data = NULL;
  44
  45 static const char * __cam_err_to_str(camera_error_e err)
  46 {
  47         const char *err_str;
  48
  49         switch (err) {
  50         case CAMERA_ERROR_NONE:
  51                 err_str = "CAMERA_ERROR_NONE";
  52                 break;
  53         case CAMERA_ERROR_INVALID_PARAMETER:
  54                 err_str = "CAMERA_ERROR_INVALID_PARAMETER";
  55                 break;
  56         case CAMERA_ERROR_INVALID_STATE:
  57                 err_str = "CAMERA_ERROR_INVALID_STATE";
  58                 break;
  59         case CAMERA_ERROR_OUT_OF_MEMORY:
  60                 err_str = "CAMERA_ERROR_OUT_OF_MEMORY";
  61                 break;
  62         case CAMERA_ERROR_DEVICE:
  63                 err_str = "CAMERA_ERROR_DEVICE";
  64                 break;
  65         case CAMERA_ERROR_INVALID_OPERATION:
  66                 err_str = "CAMERA_ERROR_INVALID_OPERATION";
  67                 break;
  68         case CAMERA_ERROR_SECURITY_RESTRICTED:
  69                 err_str = "CAMERA_ERROR_SECURITY_RESTRICTED";
  70                 break;
  71         case CAMERA_ERROR_DEVICE_BUSY:
  72                 err_str = "CAMERA_ERROR_DEVICE_BUSY";
  73                 break;
  74         case CAMERA_ERROR_DEVICE_NOT_FOUND:
  75                 err_str = "CAMERA_ERROR_DEVICE_NOT_FOUND";
  76                 break;
  77         case CAMERA_ERROR_ESD:
  78                 err_str = "CAMERA_ERROR_ESD";
  79                 break;
  80         case CAMERA_ERROR_PERMISSION_DENIED:
  81                 err_str = "CAMERA_ERROR_PERMISSION_DENIED";
  82                 break;
  83         case CAMERA_ERROR_NOT_SUPPORTED:
  84                 err_str = "CAMERA_ERROR_NOT_SUPPORTED";
  85                 break;
  86         case CAMERA_ERROR_RESOURCE_CONFLICT:
  87                 err_str = "CAMERA_ERROR_RESOURCE_CONFLICT";
  88                 break;
  89         case CAMERA_ERROR_SERVICE_DISCONNECTED:
  90                 err_str = "CAMERA_ERROR_SERVICE_DISCONNECTED";
  91                 break;
  92         default:
  93                 err_str = "Unknown";
  94                 break;
  95         }
  96         return err_str;
  97 }
  98
  99 #ifdef DEBUG_THREAD
 100 static void __print_thread_id(char *msg)
 101 {
 102         pthread_t id;
 103         id = pthread_self();
 104         _D("[%s] tid %u", msg,  (unsigned int)id);
 105 }
 106 #endif
 107
 108 static void __print_camera_state(camera_state_e previous, camera_state_e current, bool by_policy, void *user_data)
 109 {
 110         switch (current) {
 111         case CAMERA_STATE_CREATED:
 112                 _D("Camera state: CAMERA_STATE_CREATED");
 113                 break;
 114
 115         case CAMERA_STATE_PREVIEW:
 116                 _D("Camera state: CAMERA_STATE_PREVIEW");
 117                 break;
 118
 119         case CAMERA_STATE_CAPTURING:
 120                 _D("Camera state: CAMERA_STATE_CAPTURING");
 121                 break;
 122
 123         case CAMERA_STATE_CAPTURED:
 124                 _D("Camera state: CAMERA_STATE_CAPTURED");
 125                 break;
 126
 127         default:
 128                 _D("Camera state: CAMERA_STATE_NONE");
 129                 break;
 130         }
 131 }
 132
 133 static long long int __get_monotonic_ms(void)
 134 {
 135         long long int ret_time = 0;
 136         struct timespec time_s;
 137
 138         if (0 == clock_gettime(CLOCK_MONOTONIC, &time_s))
 139                 ret_time = time_s.tv_sec* 1000 + time_s.tv_nsec / 1000000;
 140         else
 141                 _E("Failed to get time");
 142
 143         return ret_time;
 144 }
 145
 146 static image_buffer_data_s *__make_preview_image_buffer_data(camera_preview_data_s *frame)
 147 {
 148         unsigned char *buffer = NULL;
 149         unsigned int buffer_size = 0;
 150
 151         image_buffer_data_s *image_buffer = malloc(sizeof(image_buffer_data_s));
 152         if (image_buffer == NULL) {
 153                 _E("Failed to allocate image buffer data");
 154                 goto ERROR;
 155         }
 156
 157         switch (frame->num_of_planes) {
 158         case 1:
 159                 buffer_size = frame->data.single_plane.size;
 160                 buffer = malloc(buffer_size);
 161                 if (!buffer) {
 162                         _E("failed to malloc buffer");
 163                         goto ERROR;
 164                 }
 165                 memcpy(buffer, frame->data.single_plane.yuv, buffer_size);
 166                 break;
 167         case 2:
 168                 {
 169                         unsigned char *buffer2 = NULL;
 170                         buffer_size =
 171                                 frame->data.double_plane.y_size + frame->data.double_plane.uv_size;
 172                         buffer = malloc(buffer_size);
 173                         if (!buffer) {
 174                                 _E("failed to malloc buffer");
 175                                 goto ERROR;
 176                         }
 177                         buffer2 = buffer + frame->data.double_plane.y_size;
 178                         memcpy(buffer,
 179                                 frame->data.double_plane.y, frame->data.double_plane.y_size);
 180                         memcpy(buffer2,
 181                                 frame->data.double_plane.uv, frame->data.double_plane.uv_size);
 182                 }
 183                 break;
 184         case 3:
 185                 {
 186                         unsigned char *buffer2 = NULL;
 187                         unsigned char *buffer3 = NULL;
 188                         buffer_size = frame->data.triple_plane.y_size
 189                                                 + frame->data.triple_plane.u_size
 190                                                 + frame->data.triple_plane.v_size;
 191                         buffer = malloc(buffer_size);
 192                         if (!buffer) {
 193                                 _E("failed to malloc buffer");
 194                                 goto ERROR;
 195                         }
 196                         buffer2 = buffer + frame->data.triple_plane.y_size;
 197                         buffer3 = buffer2 + frame->data.triple_plane.u_size;
 198                         memcpy(buffer,
 199                                 frame->data.triple_plane.y, frame->data.triple_plane.y_size);
 200                         memcpy(buffer2,
 201                                 frame->data.triple_plane.u, frame->data.triple_plane.u_size);
 202                         memcpy(buffer3,
 203                                 frame->data.triple_plane.v, frame->data.triple_plane.v_size);
 204                 }
 205                 break;
 206         default:
 207                 _E("unhandled num of planes : %d", frame->num_of_planes);
 208                 goto ERROR;
 209                 break;
 210         }
 211
 212         image_buffer->image_width = frame->width;
 213         image_buffer->image_height = frame->height;
 214         image_buffer->buffer_size = buffer_size;
 215         image_buffer->buffer = buffer;
 216         image_buffer->format = frame->format;
 217
 218         return image_buffer;
 219
 220 ERROR:
 221         free(buffer);
 222         free(image_buffer);
 223
 224         return NULL;
 225 }
 226
 227 static bool __camera_attr_supported_af_mode_cb(camera_attr_af_mode_e mode, void *user_data)
 228 {
 229         struct __camera_data *camera_data = user_data;
 230
 231         _I("Auto-Focus Mode [%d]", mode);
 232
 233         if (mode != CAMERA_ATTR_AF_NONE)
 234                 camera_data->is_af_enabled = true;
 235
 236         return true;
 237 }
 238
 239 static void __capturing_cb(camera_image_data_s *image, camera_image_data_s *postview, camera_image_data_s *thumbnail, void *user_data)
 240 {
 241         struct __camera_data *camera_data = user_data;
 242         if (image == NULL) {
 243                 _E("Image is NULL");
 244                 return;
 245         }
 246
 247         free(camera_data->captured_file);
 248         camera_data->captured_file = malloc(image->size);
 249         if (camera_data->captured_file == NULL)
 250                 return;
 251
 252         _D("Now is on Capturing: Image size[%d x %d]", image->width, image->height);
 253
 254         memcpy(camera_data->captured_file, image->data, image->size);
 255         camera_data->image_size = image->size;
 256
 257         return;
 258 }
 259
 260 static void __completed_cb(void *user_data)
 261 {
 262         int ret = 0;
 263         struct __camera_data *camera_data = user_data;
 264
 265         _D("Capture is completed");
 266
 267         if (camera_data->capture_completed_cb)
 268                 camera_data->capture_completed_cb(camera_data->captured_file, camera_data->image_size, camera_data->capture_completed_cb_data);
 269
 270         camera_data->capture_completed_cb = NULL;
 271         free(camera_data->captured_file);
 272         camera_data->captured_file = NULL;
 273
 274         if (!camera_data->cam_handle) {
 275                 _E("Camera is NULL");
 276                 return;
 277         }
 278
 279         ret = camera_start_preview(camera_data->cam_handle);
 280         if (ret != CAMERA_ERROR_NONE) {
 281                 _E("Failed to start preview [%s]", __cam_err_to_str(ret));
 282                 return;
 283         }
 284
 285     return;
 286 }
 287
 288 static void __start_capture(void *user_data)
 289 {
 290         int ret = 0;
 291         struct __camera_data *camera_data = user_data;
 292
 293         ret = camera_start_capture(camera_data->cam_handle, __capturing_cb, __completed_cb, camera_data);
 294         if (ret != CAMERA_ERROR_NONE) {
 295                 _E("Failed to start capturing [%s]", __cam_err_to_str(ret));
 296                 return;
 297         }
 298 }
 299
 300 static void __camera_preview_cb(camera_preview_data_s *frame, void *user_data)
 301 {
 302         struct __camera_data *camera_data = user_data;
 303         static long long int last = 0;
 304         long long int now = __get_monotonic_ms();
 305
 306         if (now - last < CAMERA_PREVIEW_INTERVAL_MIN)
 307                 return;
 308
 309         // _D("###Time Ellapse [%lld], [%lld], [%lld]", last, now, now - last);
 310
 311 #ifdef DEBUG_THREAD
 312         __print_thread_id("PREVIEW");
 313 #endif
 314
 315         image_buffer_data_s *image_buffer_data = __make_preview_image_buffer_data(frame);
 316         if (image_buffer_data == NULL) {
 317                 _E("Failed to create mv source");
 318                 return;
 319         }
 320         image_buffer_data->user_data = camera_data->preview_image_buffer_created_cb_data;
 321
 322         ecore_main_loop_thread_safe_call_async(camera_data->preview_image_buffer_created_cb, image_buffer_data);
 323         last = now;
 324 }
 325
 326 int resource_camera_init(preview_image_buffer_created_cb preview_image_buffer_created_cb, void *user_data)
 327 {
 328         int ret = CAMERA_ERROR_NONE;
 329
 330         if (preview_image_buffer_created_cb == NULL)
 331                 return -1;
 332
 333         g_camera_data = malloc(sizeof(struct __camera_data));
 334         if (g_camera_data == NULL) {
 335                 _E("Failed to allocate Camera data");
 336                 return -1;
 337         }
 338         memset(g_camera_data, 0, sizeof(struct __camera_data));
 339
 340         ret = camera_create(CAMERA_DEVICE_CAMERA0, &(g_camera_data->cam_handle));
 341         if (ret != CAMERA_ERROR_NONE) {
 342                 _E("Failed to create camera [%s]", __cam_err_to_str(ret));
 343                 goto ERROR;
 344         }
 345
 346         ret = camera_attr_set_image_quality(g_camera_data->cam_handle, CAMERA_IMAGE_QUALITY);
 347         if (ret != CAMERA_ERROR_NONE) {
 348                 _E("Failed to set image quality [%s]", __cam_err_to_str(ret));
 349                 goto ERROR;
 350         }
 351
 352         ret = camera_set_preview_resolution(g_camera_data->cam_handle, IMAGE_WIDTH, IMAGE_HEIGHT);
 353         if (ret != CAMERA_ERROR_NONE) {
 354                 _E("Failed to set preview resolution [%s]", __cam_err_to_str(ret));
 355                 goto ERROR;
 356         }
 357
 358         ret = camera_set_capture_resolution(g_camera_data->cam_handle, IMAGE_WIDTH, IMAGE_HEIGHT);
 359         if (ret != CAMERA_ERROR_NONE) {
 360                 _E("Failed to set capture resolution [%s]", __cam_err_to_str(ret));
 361                 goto ERROR;
 362         }
 363
 364         ret = camera_set_capture_format(g_camera_data->cam_handle, CAMERA_PIXEL_FORMAT_JPEG);
 365         if (ret != CAMERA_ERROR_NONE) {
 366                 _E("Failed to set capture format [%s]", __cam_err_to_str(ret));
 367                 goto ERROR;
 368         }
 369
 370         ret = camera_set_state_changed_cb(g_camera_data->cam_handle, __print_camera_state, NULL);
 371         if (ret != CAMERA_ERROR_NONE) {
 372                 _E("Failed to set state changed callback [%s]", __cam_err_to_str(ret));
 373                 goto ERROR;
 374         }
 375
 376         ret = camera_set_preview_cb(g_camera_data->cam_handle, __camera_preview_cb, g_camera_data);
 377         if (ret != CAMERA_ERROR_NONE) {
 378                 _E("Failed to set preview callback [%s]", __cam_err_to_str(ret));
 379                 goto ERROR;
 380         }
 381
 382         ret = camera_attr_foreach_supported_af_mode(g_camera_data->cam_handle, __camera_attr_supported_af_mode_cb, g_camera_data);
 383         if (ret != CAMERA_ERROR_NONE) {
 384                 _E("Failed to set auto focus attribute check callback [%s]", __cam_err_to_str(ret));
 385                 goto ERROR;
 386         }
 387
 388         g_camera_data->preview_image_buffer_created_cb = preview_image_buffer_created_cb;
 389         g_camera_data->preview_image_buffer_created_cb_data = user_data;
 390
 391         return 0;
 392
 393 ERROR:
 394         if (g_camera_data->cam_handle)
 395                 camera_destroy(g_camera_data->cam_handle);
 396
 397         free(g_camera_data);
 398         g_camera_data = NULL;
 399         return -1;
 400 }
 401
 402 int resource_camera_start_preview(void)
 403 {
 404         camera_state_e state;
 405         int ret = CAMERA_ERROR_NONE;
 406
 407         if (g_camera_data == NULL) {
 408                 _I("Camera is not initialized");
 409                 return -1;
 410         }
 411
 412         ret = camera_get_state(g_camera_data->cam_handle, &state);
 413         if (ret != CAMERA_ERROR_NONE) {
 414                 _E("Failed to get camera state [%s]", __cam_err_to_str(ret));
 415                 return -1;
 416         }
 417
 418         if (state == CAMERA_STATE_CAPTURING) {
 419                 _D("Camera is now capturing");
 420                 return -1;
 421         }
 422
 423         if (state != CAMERA_STATE_PREVIEW) {
 424                 ret = camera_start_preview(g_camera_data->cam_handle);
 425                 if (ret != CAMERA_ERROR_NONE) {
 426                         _E("Failed to start preview [%s]", __cam_err_to_str(ret));
 427                         return -1;
 428                 }
 429         }
 430
 431         return 0;
 432 }
 433
 434 int resource_camera_capture(capture_completed_cb capture_completed_cb, void *user_data)
 435 {
 436         camera_state_e state;
 437         int ret = CAMERA_ERROR_NONE;
 438
 439         if (g_camera_data == NULL) {
 440                 _I("Camera is not initialized");
 441                 return -1;
 442         }
 443
 444         ret = camera_get_state(g_camera_data->cam_handle, &state);
 445         if (ret != CAMERA_ERROR_NONE) {
 446                 _E("Failed to get camera state [%s]", __cam_err_to_str(ret));
 447                 return -1;
 448         }
 449
 450         if (state == CAMERA_STATE_CAPTURING) {
 451                 _D("Camera is now capturing");
 452                 return -1;
 453         }
 454
 455         if (state != CAMERA_STATE_PREVIEW) {
 456                 _I("Preview is not started [%d]", state);
 457                 ret = camera_start_preview(g_camera_data->cam_handle);
 458                 if (ret != CAMERA_ERROR_NONE) {
 459                         _E("Failed to start preview [%s]", __cam_err_to_str(ret));
 460                         return -1;
 461                 }
 462         }
 463
 464         __start_capture(g_camera_data);
 465
 466         g_camera_data->capture_completed_cb = capture_completed_cb;
 467         g_camera_data->capture_completed_cb_data = user_data;
 468
 469         return 0;
 470 }
 471
 472 void resource_camera_close(void)
 473 {
 474         if (g_camera_data == NULL)
 475                 return;
 476
 477         camera_unset_preview_cb(g_camera_data->cam_handle);
 478         camera_stop_preview(g_camera_data->cam_handle);
 479
 480         camera_destroy(g_camera_data->cam_handle);
 481         g_camera_data->cam_handle = NULL;
 482
 483         free(g_camera_data->captured_file);
 484         g_camera_data->captured_file = NULL;
 485
 486         free(g_camera_data);
 487         g_camera_data = NULL;
 488 }